iOS7 – Why Is Everyone Suddenly A Design Critic? - <AUTHOR> http://www.compylr.com/post/ios7-or-why-is-everyone-suddenly-a-design-critic

<comment><USER2> Who are those users to have an opinion of their own? If that's the way you think about your users, you probably don't deserve having them.

Maybe some people don't like the design, but can't move because they have already invested too much into the platform? A brand is a promise to not mess things up.

If users love everything Apple does we criticize them (The sheep!). If they form an opinion while still using Apple devices we criticize them as well (Those "experts"!).

Btw, I actually like the design. I was sort of shocked when I first saw it, but it grows on you pretty quickly.

</comment><comment> jack-r-abbit I am not a design expert. Far from it. I don't know shit about design. You know what I AM an expert in? What I like and don't like. You don't have to be a design expert to love something or hate something. You just need to know what you love or hate. I don't know who Andrew Sass is and don't give a shit how many awards his designs have earned... fuck him for telling me I can't have an opinion of what I like or don't like just because I'm not a design expert. You don't have to be a chef to know when someone is feeding you shit.

<comment><USER3> You can have an opinion as a non design expert. Don't expect anyone to give a fuck about it. Especially Apple, while they continue to make huge profits from the products that you, non-design expert "don't like".

<comment> jack-r-abbit But, clearly I can't have an opinion because you told me (and a lot of other people) to just shut the fuck up about it. Nice! Classy! Award-winning attitude!

Many, many, many companies make huge profits selling crap I don't like. So what? I don't expect anyone to give a fuck about my opinion. But I also don't expect anyone to tell me to shut the fuck up for having it. So why don't you take your own advice with your opinion. And we can go our separate ways.

</comment></comment></comment><comment><USER4> > "Before iPods, suburban normals gave zero fucks about their obtuse, bulking > heaps of plastic that spun CDs of boy bands from their hips."

Elitism aside, this seems contradicted by the fact that Steve Jobs used Sony as his model corporation. You know: the company that made the Sony Walkman etc...

[http://www.dailyfinance.com/2012/04/12/sony-outlook-steve- jo...](http://www.dailyfinance.com/2012/04/12/sony-outlook-steve-jobs-losses/)

</comment><comment><USER5> A lot of the criticism seems to be directed at the icons. They really don't look that great to me. Sorry that I have an opinion on the matter, you can direct your vitriol at me if it makes you feel better. Here's a redesign posted to HN earlier that I think looks quite a bit better: [http://dribbble.com/shots/1109343-iOS-7-Redesign/attachments...](http://dribbble.com/shots/1109343-iOS-7-Redesign/attachments/140192)

<comment><USER6> My only real negative criticism is with the icons. Everything else I can learn to love -- or already love -- but there are some fundamental issues with the gradient directions, shape details and overall consistency.

I think your redesign is a great step in the right direction! The gradients are going light-to-dark in a consistent manner, the scale of the shapes within each icon feels appropriate and you even simplified some of them further to make them more obvious. If your icons were the ones presented, I'd have much less to complain about.

<comment><USER5> These aren't mine, but here's the link to the HN post: [https://news.ycombinator.com/item?id=5861681](https://news.ycombinator.com/item?id=5861681)

</comment></comment></comment><comment><USER7> TL;DR "You can't express your opinion on design unless you can do better". I'm curious how the author watches football or movie. Silently for sure.

<comment><USER3> I never watch football, or any sports for that matter, and I _do_ watch movies silently - would be rude to my fellow moviegoers to do otherwise

<comment><USER7> Regarding the movies that's very nice of you. Do you discuss the movie with anyone after watching it?

</comment></comment></comment><comment><USER8> _More importantly, no one outside of this conference has even used the iOS7, so really, truthfully, everyone needs to shut the fuck up._

False. I'm thousands of miles away, and I've been using it since a couple hours after it was announced, which was about 20 hours before this post was published.

<comment><USER3> truth. should update to "most people outside of this conference"

</comment></comment><comment><USER9> Why is Everyone Suddenly having a blog and an opinion? Why can't everyone just shut the fuck up and not say a word about things that they are not an expert on?

Seriously, can't down vote this enough. The irony of a blog asking people to stfu.

<comment><USER3> yet, you're commenting on it...?

</comment></comment><comment><USER10> How does this dribble make it to HN? This article represents such an elitest out-of-touch opinion.

When designers forget that users or potential users are the final authority that matters, they're walking the path of irrelevance.

<comment><USER3> "When designers forget that users or potential users are the final authority that matters"

In the case of Apple, I disagree. Apple doesn't need to impress these users who bitch about their products, yet use them anyway.

Also "drivel"

<comment><USER10> Whoops - thanks for the drivel alert. I dribbled a bit.

I think Apple historically has done a great job overall and set a bar where the user experience is concerned. Recently, that hasn't been as true for me with certain Apple products and services. The brand deserves credit for mostly getting things right though.

However, to imply that users who have concerns about products they use are just complainers unworthy of being listened to, undervalues the process that leads to better products.

I believe, negative sentiment accumulates to a tipping point that can easily lead a once loyal and happy customer to another solution when or if one is available.

Whether a hybrid flat design approach works for iOS 7 or not, it's the users who will decide but no brand can afford to ignore those who are unhappy with a design BUT still use it.

</comment></comment></comment><comment><USER11> +1.

Now, how do I kill people on this MUD?

That antique joke aside, most people don't know enough to know that they don't know. People who think Edward Tufte is a cartoon rabbit pontificating on design... is this really any worse than listening to them pontificate on Turkish politics, or the prime lending rate, or the relative merits of three star restaurants in foreign countries where they'll never eat?

<comment><USER3> you're right it's not any worse :(

</comment></comment><comment><USER8> I may not know anything about design, but I know what I like.

<comment><USER3> congratulations. don't like ios7. dont buy it

</comment></comment><comment><USER12> Did anyone read the comments? Troll alert.</comment>


Windows 10 and Windows Server 2016 get new TCP improvements - <AUTHOR> http://windowsreport.com/windows-10-windows-server-2016-tcp-improvements/ <comment><USER2> 1st party link: [https://blogs.technet.microsoft.com/networking/2016/07/18/an...](https://blogs.technet.microsoft.com/networking/2016/07/18/announcing- new-transport-advancements-in-the-anniversary-update-for-windows-10-and- windows-server-2016/)

</comment><comment><USER3> I want to enjoy the technical details of the Technet post on their own merits, but I can't help but add "to better support our telemetry needs" to the end of some of the phrases, like so:

"Like Windows TFO, IW10 mostly affects small object transfers over the Internet. Windows IW10 can transfer small Internet objects up to twice as quickly as ICW4 _[to better support our telemetry needs]_ "

<comment><USER4> man this memes gotta stop. Everyone else does telemetry, why shouldn't Microsoft do it if it means making the product better for users?</comment></comment>


How would you negotiate a salary at Google? - <AUTHOR>

Google has recently given me an offer.  I find that the salary is not very competitive.  It seems to me Google feels that people should take the jobs for a lower salary anyway?  Have any of you readers have similar experiences?  If so how did you negotiate your salary? <comment><USER2> the same way i would negotiate a salary anywhere else.

figure out what the minimum salary you would need to work for them. interview at other companies. get other job offers. tell them that you want to work for them, but you have other offers elsewhere and the minimum you'd accept is $xyz.

you must be prepared to walk out if you're going to negotiate. if they balk, tell them they have a week to reconsider or you'll accept a position elsewhere.

also, don't forget that google does have a lot of intangibles and perks that other companies don't. in addition, working at google is CV gold. they're probably trying to lowball people and get the people who just want to work for them in their offices, posisbly weeding out the people in it for the money.

<comment><USER3> _in addition, working at google is CV gold_

Is it really? I mean, is there any evidence that Google alumni are better paid when they leave? There are an awful lot of companies that look "good" on a CV. Goldman Sachs looks pretty good on a CV, but they don't play silly games with lowballing new hires...

<comment><USER2> never said anything about being paid more. being a google alumni doesn't make you gold. however, it does look quite good.

</comment></comment></comment><comment><USER4> Microsoft used to be notorious for doing the same thing, and friends who were in very strong negotiating positions wound up walking over it. Microsoft may have eased up since then, but in 2001, they weren't kidding.

<comment><USER3> Microsoft used to be able to do that because their stock kept on going up and up. Less so now. Same with Google. I don't think Google (or any other "big name" employer) is as impressive on a CV as they would like to think. If you took say 75% of the market rate salary now thinking that it would get you 150% of the market rate when you jump ship in n years, then you might be in for a surprise.

<comment><USER4> Hey, I wouldn't do it. I'm just saying, sometimes when HR tells you they have an official policy of paying 60% of market, they aren't kidding.

<comment><USER3> Gotta wonder if HR are on 60% as well...

<comment><USER4> I'm pretty sure you can get HR people from a one-click shopping listing at Amazon.

</comment></comment></comment></comment></comment><comment><USER5> The best way to negotiate is by not needing that job at Google/ _(substitute some other company name)_ i.e. always be prepared to walk away.

</comment><comment><AUTHOR> I already work for a great tech company. The Google recruiter told me that Google can't match my current compensation. It's so strange? I spent a lot of time interviewing with them. So I made the case it doesn't compare with with I have.

<comment><USER6> They spend millions on free food..can't they spend few more k's for good engineers ..strange ?

<comment><AUTHOR> It is, I don't understand what's going on. Maybe a reflection of the times there.

</comment></comment></comment><comment><USER7> have another larger offer in hand is the standard way to negotiate a salary. i don't know how google handles that though.</comment>


Take this job and shove it - <AUTHOR> http://www.msnbc.msn.com/id/31684119/ns/business-careers/

<comment><USER2> Never, ever burn bridges. Even if you feel you were treated poorly and that you'll never see your boss again. You never know what might happen in the future. If you do, your coworkers who are left holding the bag will know who to blame. It also destroys any credibility you might have had.

</comment><comment><USER3> Unless you find yourself in the kind of structure and nice working atmosphere where they'd have the decency to give you advanced notice that you you we're going to be fired/laid-off so you can prepare, you probably shouldn't freely offer to do the same after you quit.

<comment><USER4> So severance pay is something akin to that advanced notice?

<comment><USER3> I'd agree with that, my thoughts are if your employer doesn't provide the people it lets go with a cushion (advanced noticed or severance pay) then the employee who leaves is in no way obligated to do something the employer wouldn't do for them

<comment><USER2> Obligated? No, no one can force you to leave with notice unless it was contractually enforced. However, it is common courtesy. And you refer to "the employer", who exactly is this? The CEO? Your direct manager? The board of directors? A lot of times the ones who have to let people go are not the ones responsible for the decision. Your boss may not have wanted people to get cut and may have totally disagreed with the way they're being forced to do it. But being the self-entitled person you seem to come across as, you're gonna stick it him and the rest of the coworkers you leave behind? That's fine, you're entitled to do that. But more often than not, karma is a mean bitch and she will come back and kick your ass.

<comment><USER3> Employment is like any other relationship. If it has been a good one that has run its course, then sure you act with courtesy. However, if its been a bad one like the ones in the article appear to be then you don't owe anyone anything.

</comment></comment></comment></comment></comment><comment><USER5> Employment is a business arrangement like any other. If you screw your employees, expect to get screwed back.

</comment><comment><USER6> Treat your employees like shit and they won't feel they have any reason to be kind. I have a feeling this is more closely related to people who do not like their job but rather work to provide for their families or themselves and layoffs, cutbacks and everything else threaten that so they get out as soon as possible.

</comment><comment><USER7> There is a certain amount of frustration employees feel with their employers when the relationship isn't balanced. If the employee leaves on bad terms, the employee loses any reference he or she might have from that company. It makes it harder to find employment elsewhere. But, when a company terminates the relationship, the employee has little recourse. The employment contract states that either party can terminate and any time for any (or no) reason, but it is the employer who is in the position of power. I think it is this frustration that causes such hard feelings from disgruntled employees.

</comment><comment><USER8> I've decided that when I resign from my position, I'm writing my resignation letter on a cake. Whether or not I smear said cake all over my employer's face, or share it with him at the table is a different matter; decided by how well s/he treated the people beneath them, including me. I think its important to differentiate between the things that the people above your boss are forcing him to do and the things hes doing that you don't like that he's NOT being told directly to do. For example, at my work, my boss has to come around every so often to make sure I'm working up to speed, and this is required by his superiors. What ISN'T required by the higher-ups is that he nit-pick what I'm doing, ^especially^ when I'm my speeds are above average. When I quit, I intend to make that clear on my cake, lol. I intend to lay out, "I don't like that corporate requires this this and this of X (my boss) because it is counter productive, and I don't like the way X, my boss, does this this and this without a reason to do so because it is an obstruction to the work flow." I think communication is a big part of it, but for some reason it seems like now-a-days outgoing interviews are a thing of the past. You know, where they interview you about your experience with the company as your going out the door. Then again, if I actually felt my employer was at all listening to my suggestions to begin with I probably wouldn't have resigned to begin with, so I guess that explains that.

</comment><comment><USER9> I don't see why you should feel _obligated_ to give two weeks' notice. Now, it's possible that you want to finish the project you're working on, or for some other reason you don't mind doing it. But, honestly, most of the time if you decided to quit, you're mentally checked out or even worse, hostile toward the company. And it's not as if two weeks is a long time, the employer can't get anyone to replace you that fast anyway. The company often has no obligation to give you any notice either. Now, you don't need to be flip about quitting, you can just say politely that you don't think it's working out for you, that you can't give 2 weeks notice because you need to use the time to take a break before the next gig starts, or that you won't be doing a good enough job or whatever. I think most normal people (co-workers) understand that you have to take care of yourself. That said, in my past I've given up up to six month notice, mostly because I've been lucky to work on great projects and with great people that I didn't want to undermine. But if you're not in that situation, I don't think that there are any _ethical_ considerations in quitting ASAP.

<comment><USER10> I'm curious; Is the two weeks notice standard in the states? How about other countries? Where I live (Denmark), the standard is one months notice from the beginning of the following moth. So effectively somewhere between 1 and two months.

</comment></comment><comment><USER11> I have personally been laid off three times. Once two months before my first child was born from a company I had worked for for 8 years. None of them give any kind of notice. My current employer fires people on Fridays just before quitting time. Again, no notice.

I'm of the opinion that what you give is what you get. The employer will let you go on Friday at 17:00, but then they expect 2 weeks notice? Yeah, right.

Edit: spelling.</comment>


Show HN: Extension for saving articles, videos etc. to personal online library - <AUTHOR> https://github.com/tolgaOzen/joosephExtension <comment><AUTHOR> Hello everyone,

We made an extension for organizing tab mess in our browser. We wanted our browsers without dozens of tabs.

Here's what you can do with extension and online library.

You can save articles, videos and more to your online library (Click the heart icon)

You can create collections to organize your tabs (eg. best repos and resources for Go)

You can search them on your library

You can share those collection with community and friends.

You can create learning paths, newsletters, favs lists with your collections.

You can discover hand-picked curated lists of other users. (If they are public)

Waiting for your thoughts, what do you think?

<comment><USER2> This seems really useful. I especially like the idea of learning paths that can be shared with others.

<comment><AUTHOR> Thank you!

We hope this becomes something useful. We're trying but there is some obstacles (like in everything else, not complaining about it).

Do you have any suggestion for us?

<comment><USER2> Here's my 2 cents. There are already experts who have compiled lists of great, free online resources in different fields (but they're just a list of links). You can convert those lists into content-rich learning paths on your platform and give credit to the original list creator. That might give you some momentum, at least around the learning path feature. I would also try to replicate some elements of MOOC websites, such as progression bars and notifications that show your progress on a learning path. Maybe even allow for the creation of simple quizzes. Give a simple badge for completing a learning path - it would be generic by default, but the creator of the learning path would be able to customize the badge associated with its completion. There's so much great info on the web that doesn't get used enough, and even the lists that pull it all together don't get enough attention.

There's room for this to become more than a plug-in. Your service can become a crowdsourcing platform for aggregated knowledge curation.

<comment><AUTHOR> Awesome thank you for sharing all these with us. I really like the badge idea, we can also let user to create their own goals. For instance, someone can say I want to consume 15 resources this week and we can create badges for it.

Yeah I like the idea. Thanks for sharing with us. Is there any request you want to make, we can build that.</comment></comment></comment></comment></comment>


Which editor do you use for Lisp? - <AUTHOR>

<comment><USER2> It sounds like you're used to editing files in Windows. So your hands are accustomed to standard Windows way of selecting text, cutting, copying and pasting. Emacs does not do things this way, not at all. You can google for "cua.el", a chunk of elisp that customizes Emacs to do that stuff in a much more Windows-ish way. It's definitely not identical though. There's also some elisp out there that makes Emacs scroll one line at a time, instead of ten lines or whatever stone age thing it does by default.

If you want the least pain in getting started with a lisp, I recommend PLT Scheme. Its editor, DrScheme, will seem very ordinary and familiar. That's not a win in the long run, but in the short run you can learn how to hack a lisp, Scheme in this case, without simultaneously retraining your hands and eyes to use Emacs. And learning a lisp is what you really want to do, believe me. I was in your shoes not too long ago, and this is what I did.

(And PLT Scheme is great.)

<comment><USER3> You can make Emacs scroll a line at a time by adding this to your .emacs:

(setq scroll-conservatively 1)

</comment></comment><comment><AUTHOR> Programming consists of a few things. An editor, a compiler, source control, and so on.

The editor is particularly important when it comes to being productive. I'm inexperienced with Lisp, and I've found a few things inside Visual Studio that I feel particularly reluctant to part with. "Go to Implementation" is one. I just move the mouse over a function call, press alt-G, and it takes me right to where that function is defined. Another is a complete list of defined procedures for the current file.

Does Lisp have an environment that has similar features?

Shawn

<comment><USER4> You haven't heard of emacs?

<comment><AUTHOR> I've heard the name. I didn't know you could specifically write Lisp in it. Thanks.

Is that the only one?

<comment><USER5> Emacs is the best. It's written in an old dialect of Lisp itself, and you can customize it and script sequences of actions in it with Lisp. It also has SLIME, which is the Superior Lisp Interaction Mode for Emacs, (see <http://common-lisp.net/project/slime/),> which is the most amazing IDE I have ever seen for any language, and I've used VS.NET and Eclipse and all the rest.

That's for Common Lisp (CL), which you may or may not want to develop in; I personally frequently choose to write in CL because it has a very large library, and because it has SLIME.

For Scheme, Emacs is also good, but there isn't something analogous to SLIME.

SLIME has go-to-definition of a function as one of its more basic features, along with auto-completion, convenient listings of arguments when you first write down a call to a particular function, and much more.

<comment><AUTHOR> Sounds like just the thing, thank you!

I have a quick question that I can't justify creating a new thread about. Since you brought up Lisp implementations though...

I was about to choose to write my programs with SBCL, but it looks like the Win32 port isn't yet complete. Since I'm aiming towards using Lisp in games, speed is an issue, and so is running on Windows. Would you or anyone reccomend a dialect of Lisp which is fast and runs under Windows? Even just 1/4th the speed of C would be excellent.

<comment><USER5> Ask on the #lisp IRC channel on freenode about whether the SBCL win32 port is complete enough for your purposes. It's coming along. Remember to ask your question and then leave the chat idling, so that if your question isn't answered right away, people who have left it idling and then come back to it can see your question and then answer it.

I believe CLISP runs on Windows. I have no idea whether this is at all practical, since I don't use Windows, but maybe you could use a Unix emulator like Cygwin and run SBCL (and your game) in that, invisibly to the user?

<comment><AUTHOR> Heh, creative. I'll investigate that. Thanks!

</comment></comment></comment></comment></comment></comment></comment><comment><USER6> pg mentioned that he uses vi with a REPL ( <http://news.ycombinator.com/comments?id=587> ).

I recently began using emacs + SLIME for writing Lisp and revert back to vim for everything else. I've also tried vim + VIlisp.vim, which sends Lisp code to a running Lisp interpreter. It seemed pretty decent though I don't really have enough experience writing Lisp to really compare.

Anyone else write Lisp in vi?

SLIME is great, but I really miss vim sometimes. Fortunately, Slim-Vim is in the works by the author of VIlisp.vim. Here's a couple comment pages on Lisp with vi/emacs:

<http://programming.reddit.com/info/1cij7/comments>

<http://www.lemonodor.com/mt/mt-comments.cgi?entry_id=689>

<comment><USER7> _Anyone else write Lisp in vi?_

Yes, I do all of my text editing in Vim. I <3 Vim.

<comment><USER8> I do use vim, too.

Debugging without slime is quite difficult however: as everything is available through slime, nobody cares about simplifying access to SBCL debugging features from outside slime. For example, having to prefix every variable access with SB-DEBUG:VAR when in the debug REPL is a real pain, and serves no purpose other than annoying non-slime users.

</comment></comment></comment><comment><USER9> You might want to also check out a Lisp plugin for Eclipse called Cusp ( <http://paragent.com/lisp/cusp/cusp.htm> ). There are builds for Windows available. The other Tim that programs here at Paragent developed it, and uses it as his main development environment (I'm an emacs/slime guy). It reuses parts of slime (the backend swank server) so works in a similar manner. It also comes with SBCL, so you can get up and going pretty quickly.

Regarding SBCL on win32 - it is pretty stable, but is still missing some functionality that SBCL has on other platforms (threads is the big one).

</comment><comment><USER10> I use my own plugin that I wrote for IntelliJ (Java IDE). I've been using IntelliJ for so long that I just like the feel of it, so I chose to do that rather than learn a new tool. I only whack Lisp code for fun, so it works OK for me.

<comment><USER11> is your plugin available anywhere?

I tried just defining a .lisp filetype in IDEA, but it doesn't work because it treats apostrophes as string delimiters.

</comment></comment><comment><USER12> I use Windows Lispworks' IDE, but it is disappointing. I'm going to move to SLIME as soon as possible.</comment>


Death is inevitable, but a bad death is not - <AUTHOR> https://m.youtube.com/watch?v=NknV2JTvRzo <comment><USER2> For those who don't follow video links, it's a short video from The Economist about end of life care (~12 months) after cancer diagnoses, with a focus on talking with patients about what they want.</comment>


What Do You Think Is Impeding Haskell From Getting Mainstream Adoption? - <AUTHOR> http://www.forbes.com/sites/quora/2014/04/29/what-do-you-think-is-impeding-haskell-from-getting-mainstream-adoption/ <comment><USER2> It's missing bugs that most developers consider features. I know that sounds snarky, but its roughly accurate. Haskell is great for not only what features the language has but also what features the language does not have. It's practically impossible to shoot yourself in the foot with it.

Assuming widespread adoption was a goal, I think Haskell could stand to learn from the Rust community. They could force you to explicitly declare when you want to write unsafe code. Rust does something like this with pointers. You need to go out of your way to use an unsafe pointer, but you can do so in the name of expediency.

I would love it if more language chose to gently coerce me into writing better code than one that doesn't allow me to write bad code. The former reduces the learning curve that normally kills adoption. A language you never adopt is a language you never learn from.

Coding in any language really should be a conversation. Besides executing the instructions you give it, languages should also be designed to teach you to code more intelligently and using its idioms.

Just the other day I was thinking about how you would take an abstract syntax tree and analyze functions to determine which ones are extremely similar and could be reduced to a fewer lines of code. Take this code from sequelize/sequelize for example:

[https://github.com/sequelize/sequelize/blob/master/lib/hooks...](https://github.com/sequelize/sequelize/blob/master/lib/hooks.js#L143)

Any sufficiently smart static analyzer should be smart enough to highlight the reduncy and highlight duplication to make you aware of it and make you think about how to reduce it. That could could be reduced to this pattern:

        [ 'beforeValidate',
          'afterValidate',
          'beforeCreate',
          'afterCreate',
          'beforeDestroy',
          'afterDestroy',
          'beforeDelete',
          'afterDelete',
          'beforeUpdate',
          'afterUpdate',
          'beforeBulkCreate',
          'afterBulkCreate',
          'beforeBulkDestroy',
          'afterBulkDestroy',
          'beforeBulkUpdate',
          'afterBulkUpdate'
        ].forEach(function(methodName) {
          Hooks[methodName] = Hooks.addHook.call(this, methodName, name, fn);
        });

129 lines down to 16; Even the generation of that array could be reduced to one that constructs that array from individual words. That would probably be excessive code deduplication though.

</comment><comment><USER3> The reason PHP got so popular is not it was included with Apache (?) but that it allowed to _get shit done_ (GSD).

That it got wildly popular is because GSD usually just involved cutting some example code and pasting it on a web page changing some literal strings.

The GSD thing I would also say of C++, Perl and Ruby. Java, not so much. That was another story.

About Haskell, I don't know it. But I'm curious: does it allow you to GSD?

<comment><USER2> Not so much GSD, but it does allow you to GSR ... Get Shit Right. When correctness is a goal, languages like Haskell, Java and Ada are may be the better tool for the job. They impose restrictions the force you to design correctness (Haskell) or impose bureaucracy (Java) that make it more likely that code does what it is supposed to do.

Haskell could achieve the same success as Java by teaching how to think about achieving correctness in thought. This often means teaching people to take the concrete concepts in a domain they know and move down successive levels of abstraction until you've broken down your problem into many pure functions. Few developers have given enough thought that this is second nature to them and fewer still are give jobs where they are afforded the luxury to do the necessary thinking up front about a problem to write things correctly the first time.

Businesses demand to see progress. If a language doesn't allow to quickly show progress to your peers, it's less likely to see adoption. With haskell complete solutions may only come together at the end when you put all your provably correct functions together.

Dynamic loosely typed language also lets you explore your problem space in code, whereas haskell forces you to explore your problem space as abstract ideas. When you don't know what you're building because the problem domain is foreign then the former feature is an asset for most developers.</comment></comment>


Circles Fatigue: The Dark Side Of Google+ - <AUTHOR> http://www.fastcompany.com/1767807/running-in-circles-on-google?partner=rss&utm_source=feedburner&utm_medium=feed&utm_campaign=Feed:+fastcompany/headlines+(Fast+Company+Headlines) <comment><USER2> Wow, what a silly attempt to criticize G+ for a brilliant and yet optional feature. He complains about having to manage too many circles. Ok...so group everyone in one circle, simple enough eh? You don't have to classify your contacts, you can simply put them in an "All" circle. Plus, are you saying it's easier to manage all your friends as individuals like you have to on FB? At least Google provides a way of classifying your friends, better than no way at all. Having too many Circles is the user's fault, and yet in the end, it doesn't even matter since you can easily treat all your contacts as one Circle.

If Google+ does not end up succeeding, it will not be because people get "Circles Fatigue". Sad attempt to be overly critical here.

<comment><USER3> Precisely! When i read this article my first reaction was 'what the hell!'. Be it any social network, you will have to spend quite some time to getting used to and then trying to make the most out of it. Like in case of twitter, it took me quite some time to arrange my contacts in lists, and same goes for yahoo messenger (when i used it!). Simply critisizing the product on the basis of something which is quite efficient and noteworthy is sad.

</comment></comment><comment><USER4> How did this guy ever organize his buddy list when he used AIM or whatever? It's painful for a day, but it's not like people move between groups very often, and unless you are a celebrity it's an infrequent task after the initial setup. Plus, they've made the UI for it slippery smooth (kudos to Google+ for the effort there).

</comment><comment><USER5> He is right, in that circles do take a little more thought... probably a little more than social network users are used too. There's a little bit of strategy involved in arranging circles usefully.

I'm not quite so sure that people realize circles are mostly a tool for sorting people (and not content) and controlling your broadcasts out, and less for sorting incoming broadcasts by topic. Seems like a lot of people just have awry expectations with the concept of circles.

Most people will probably have a few redo's on their circle arrangements in their future, as they start to grasp how they actually function. Some people might get frustrated and even quit.

Definitely not tired of it though... though I do wonder what its like for a famous person who gets thousands of followers - that might get a little old.

<comment><USER6> I agree it's cute when you first crack this open to think that you have to have a 1:1 mapping between your circles on G+ and what you considers your "real life" circles to be, however this isn't the case.

You just need to break down your circles to be based on the audience for what you share, sometimes this is as easy as "social" and "professional". Everyone lives their lives differently though.

"circles are ... less for sorting incoming broadcasts by topic" I disagree with this because streams are linked to circles, so you can easily create a circle for people you follow (like Twitter). You may not want to add these people to your "broadcast" circles.

p.s.: You aren't obligated to put people who follow you into a circle. Famous people probably ignore these requests (again, like Twitter).

</comment></comment><comment><USER7> From the article """ It's overwhelming. Perhaps I'm slightly OCD, but even the process of creating a group name has become a hassle. I had friends from "Fast Company" and then friends from "FastCompany.com;" roommates from "6E" (my apartment number) and roommates from college; and even a group called "Top Gun," whose purpose I struggle to remember. Several of my Circles had just one "friend." A "Circle" of one might sound a little zen, but it mostly just sounds sad. After a while, I simply gave up. """

YOu can't blame google when you start creating groups for individuals. You can limit anything to an individual just like you would to a circle, so there's no real point to that.

</comment><comment><USER8> I've experienced this "circle fatigue", but it's mainly because the service is new and I'm adding people to my circles on a daily basis as they get invited so it gets kind of irritating having to think which circle 10 people fit in everyday. Once more people come on I don't think it'll be much of an issue? I get like one FB friend request a week so if G+ is similar and I have to put someone into a circle once a week I don't think it's an issue.

Also, if someone doesn't like using the circles then what is stopping them from just putting everyone in one circle?

</comment><comment><USER9> I think people are putting way too much time and effort into circles.

If you have something you want to share with a select group of people (who have a shared interest, obviously) then make a Circle for them and share it.

Other than that, don't fret about it.

I have a few very broad Circles that I initially classify people into (they usually only get put in 1 Circle) and that's been good enough so far.

</comment><comment><USER10> It's still early. Google tends to roll out only mostly-baked things for the first edition, and then APIs to let you do what you want. While it's a little rough now, I fully expect it to get more polish in time.

I, for one, look forward to the API the most. Specialized tools for specialized uses - you can't please everyone with a single web interface. See also: tweetdeck.</comment>


NumPy Status Update - <AUTHOR> http://morepypy.blogspot.com/2013/12/numpy-status-update-november.html

<comment><USER2> I hate to be that guy, but all it says is that 'more progress has been made on the NumPy compatibility front'. Progress is great, but am I missing something news worthy here? Is this a milestone when I can run my numpy 1.4 compatible processing code on pypy?

</comment><comment><USER3> I think the way to the HN frontpage is completely random. PyPy 2.2 release (which features incremental GC and a bunch of cool stuff) was not newsworthy, a random, not very significant progress report is.

</comment><comment><USER4> Is there more background context for this? I recently have been getting into numpy and wondering what I'm missing. So I'm curious about this post, but wanting more information.

<comment><USER5> PyPy [1] is an alternative implementation of a python interpreter written in python. It includes a JIT to speed up frequently run code [2]. The canonical python interpreter is written in c, hence cpython[3], numpy interfaces with this cpython interpreter through its capi [4]. PyPy has a c api, but it is "slow" and not JIT friendly. Some of us thought it would be fun to reimplement the core numpy ndarray as a first-class PyPy object, and allow the JIT to work its magic. We are 90% of the way there, which means we only have 90% of the effort left to do.

Most of the basic stuff works, significantly missing are SIMD optimizations and lazy expression evaluation.

Unfortunately, much scientific python software is written using the cpython capi, so it will require quite a bit of retooling of things like scipy [5] for the implementation of numpy on pypy to become popular.

[1] [http://pypy.org](http://pypy.org) [2] [http://speed.pypy.org](http://speed.pypy.org) [3] [http://python.org](http://python.org) [4] [http://docs.python.org/2/c-api](http://docs.python.org/2/c-api) [5] [http://www.scipy.org/](http://www.scipy.org/)

<comment><USER4> Excellent, thanks much for the response!</comment></comment></comment>


Functional Programming in Python - <AUTHOR> https://github.com/dry-python/returns <comment><USER2> I do hope Python keeps incorporating more of the "good stuff" from functional programming. List/dict/set comprehensions make code better - I can look at something and see very clearly that it's correct. Type hinting is a great compromise between beginner/quick scripting needs and offering a fully-baked type system. Type hints do a lot more than most people expect - you can create useful compound and custom types (like Tuple[Int, Str, Iterable]). If we can get some pattern matching in there I'm not sure what I'd do. Spend less time debugging test failures I guess. Not sure what I'd do with that time. Maybe see my family or learn how to bake pastry. Or finally clean the top of the stove. Or just write more Python in the same amount of time? I don't know. Pattern matching.

Cool library, though.

<comment><USER3> Python 3 threw away pattern matching in function heads; used to be able to deconstruct tuples. I had just discovered that feature in Python 2 when I realized 2 was about to go EOL, and upon porting my code I discovered the change.

A sad day for this Erlang enthusiast.

</comment></comment><comment><USER4> This is neat. It reminds me of an silly project [0] I made a while back to implement do-notation in python. In OP's project you still end up with code that's basically this:

        y = (Maybe(just=x) if x > 0 else Maybe()).bind(lambda a:
             Maybe(just=x*a)                     .bind(lambda b:
             Maybe.mreturn(a+b)))

It's functionally sound and standard, but ergonomically painful. I built a really fun horrible hack to allow you to write that instead as this:

        with do(Maybe) as y:
            a = Maybe(just=x) if x > 0 else Maybe()
            b = Maybe(just=x*a)
            mreturn(a+b)

It swaps out the assignment operator `=` in the `with do()` block for the monadic bind operation, which you might be used to seeing as `<-`.

You just need to use my @with_do_notation decorator, which just completely rewrites your function using the ast library wherever it finds a block of `with do(SomeClass) as variable:`. I was even able to write ergonomically nice parser combinators [1] that would actually work pretty well if python had tail call optimization.

You shouldn't use it but it was great fun and opened my eyes to the ways you can abuse python if you really wanted to. Using decorators to introspect and completely rewrite functions is a fun exercise.

[0] [https://github.com/imh/python_do_notation](https://github.com/imh/python_do_notation)

[1] [https://github.com/imh/python_do_notation/blob/master/parser...](https://github.com/imh/python_do_notation/blob/master/parser_example.py#L97)

<comment><USER5> Your example isn't using "y", so you should also be able to drop the " as y" part (unless the AST hack requires it for some reason).

Edit: Oh, nevermind - the "y" is how you access it after the with statement. Weird for python, but it makes sense given the rewritten version. I was thinking your version would have a non-rewritten "result = _something_ " within the with block in a real use, but that's not what it's doing.

<comment><USER4> Heh, yup, it's part of the hackiness of it all. "with do(MyMonadClass) as my_variable: <some code>" equates to haskell's "myVariable = do <some code>". I can't remember why the MyMonadClass part was necessary. Maybe for the mreturn.

</comment></comment></comment><comment><USER6> Python + Functional = [http://coconut-lang.org/](http://coconut-lang.org/)

<comment><USER7> If I didn't already do elixir professionally I'd definitely be learning coconut, it looks super cool.

</comment></comment><comment><USER8> I like strongly typed and functional programming. But I would rather use a "pythonic" approach to solve problems in python. OFC there might be some cases where for example one of your dependency is python, and you still want to be able to write correct code. But in general, If you want types and functional constructs, IMO you should use something else.

</comment><comment><USER9> If there was one thing I'd change with python to make it more 'functional' it would be having lambdas that weren't expression-only. I know it's not a functional feature because it's for stateful programming, but the lack of it disallows some nice stuff.

<comment><USER10> I agree with you that having more than a single expression in lambdas would be super nice. That being said, I don't think it's necessarily stateful to allow more than a single expression! If you don't reassign any variables, then it's equivalent to a single expression. For instance, something like this (using made up syntax for extended lambdas) isn't stateful:

        lambda i:
            square = i * i

            if i < 0:
                return -1 * square
            else:
                return square

A decent heuristic for whether an algorithm is stateful might be to check if you can map it pretty easily to something like Haskell. In this case, it's not hard to do at all:

        \i ->
            let square  = i * i in
            if x < 0 then -1 * x else x

Of course, it might be more natural for some programmers to write the Python code in a stateful way like this:

        lambda i:
            square = i * i

            if i < 0:
                square *= -1

            return square

<comment><USER11> I'm sure there are cases where multiple lines would be nice, but I don't think this is one. This seems easier to read to me:

        lambda i: -i * i if i < 0 else i * i

Also, the functional way of doing multiple lines in a lot of situations would typically be to compose smaller lambdas.

<comment><USER10> Yeah, this is a trivial example. I picked it specifically to show that multi- line lambdas don't have to be stateful, not as an example of a lambda that couldn't be written in one line.

</comment></comment></comment></comment><comment><USER12> Hi, author of `returns` here! Thanks a lot for sharing this link.

I would love to highlight several features of `0.14` release we are working on right now:

1\. Typed `partial` and `curry` functions: [https://returns.readthedocs.io/en/latest/pages/curry.html](https://returns.readthedocs.io/en/latest/pages/curry.html)

2\. `Future` and `FutureResult` containers for working with async Python! [https://returns.readthedocs.io/en/latest/pages/future.html](https://returns.readthedocs.io/en/latest/pages/future.html)

3\. Typed functional pipelines with very good type inference: [https://returns.readthedocs.io/en/latest/pages/pipeline.html](https://returns.readthedocs.io/en/latest/pages/pipeline.html)

It is going to be released soon, stay tuned!

</comment><comment><USER13> The project cites this blog post[0] on the "anti-pattern" that is Python exceptions, and I honestly couldn't be turned off on this project anymore after reading it if this is the inspiration behind it.

The examples in the README and this blog post just give me huge "nope" vibes. Obviously Python could learn a lot more from functional programming, but this is the wrong way to go about a lot of it.

0\. [https://sobolevn.me/2019/02/python-exceptions-considered- an-...](https://sobolevn.me/2019/02/python-exceptions-considered-an- antipattern)

<comment><USER14> It would be helpful if you could provide specific things in the blog post that you don't agree with. I skimmed through it and it seemed reasonable.

<comment><USER13> The example cited where they don't know what to return in their `divide` function if a division by zero occurs is nonsense.

The answer is simple: let the `DivsionByZero` exception raise! You don't have to return anything!

Better yet, you should have input cleansing/data validation before it gets to that point. The alternative presented in the blog post is absurd over- engineering.

</comment></comment></comment><comment><USER15> How about writting modern and proper Python first? Not to mention designing a decent API?

Let's examine the README example for a minute:

        user: Optional[User]

        if user is not None:
             balance = user.get_balance()
             if balance is not None:
                 balance_credit = balance.credit_amount()
                 if balance_credit is not None and balance_credit > 0:
                     can_buy_stuff = True
        else:
            can_buy_stuff = False

I don't know if it's been deliberatly twisted, but that's not what I would called idiomatic or realistic for a Python program:

\- one should probably never reach this part of the code if there is no user. But I'll indulge the author.

\- don't put can_buy_stuff in an else close, what's the point?

\- using type hints for no reason, but not other modern facilities like the walrus operator?

\- do we really want users without a balance? Let's indulge this, but it seems a bad design.

\- what's with all those unecessary conditional blocks?

\- credit_amount should never be None. It's a Balance object, put a sane default value. But ok, indulging again.

So, you get down to:

        user: Optional[User]
        can_buy_stuff = False
        if user and (balance := user.get_balance()):
           can_buy_stuff = (balance.credit_amount() or 0) > 0

I don't think the solution the lib offers is superior:

        can_buy_stuff: Maybe[bool] = Maybe.from_value(user).map(
            lambda real_user: real_user.get_balance(),
        ).map(
            lambda balance: balance.credit_amount(),
        ).map(
            lambda balance_credit: balance_credit > 0,
        )

And that's if we are using the rules of the README, which are not fair.

If we have a well designed API, and we use a function (more testable, and hey, are we doing FP or not ?), then:

        def can_buy_stuff(user: User):
            if (balance := user.get_balance()):
                return balance.credit_amount() > 0
            return False

Checking the user should not be part of this algo, credit_amount should be 0 if never set. We could even remove return False, I keep it because I like explicitness.

You could even that as a method or raise NoBalance depending of your case.

Bottom line, if you really feel that strongly about None, don't jump on the bazooka to kill this fly, go to [https://discuss.python.org](https://discuss.python.org) and advocate for PEP 505 (None-aware operators): [https://www.python.org/dev/peps/pep-0505/](https://www.python.org/dev/peps/pep-0505/)

It's been deferred since 2015.

That doesn't mean we should not experiment with other paradigms in Python, and I do think this lib is an interesting experiment, but I don't find it conclusive.

<comment><USER16> I'd like to know what happens to can_buy_stuff and the rest of the code when user is Not None and balance_credit is -1.

<comment><USER17> user can't buy stuff and one unfortunate developer will hunt the bug that charged someone with negative credit.

</comment></comment></comment><comment><USER18> For 'Maybe' an 'Result' specifically, I feel that Python builtins + mypy offer superior experience: easier, safer, and less dependencies with a similar level of verbosity.

For Maybe example: I think this 'functional' style with fmaps in Python is problematic, because lambdas can't be multiline. If you have sevearal lines of logic, you'd need an auxiliary helper def, and at this point it becomes as unreadable.

For Results: I think returning Union[Exception, Value] (where Value is the 'desired' type) and then using isinstance(result, Exception) is much cleaner.

\- it can be statically checked with mypy to ensure the same level of type safety as Rust would have

\- minimal performance impact

\- no extra wrapping and unwrapping in the code. You can completely ignore mypy and error handling, until you're happy, then you harden your program by making sure it complies to mypy.

\- no extra dependencies, third party code dealing with your library doesn't have to deal with your wrappers! If they don't check for error type, when Exception is encountered, the program will most likely terminate with AttributeError, which is a desirable behaviour in such situation.

\- it's much easier to compose: propagating error with a decorator is neat, until you have some more sophisticated logic, e.g. for error aggregation

\- the only downside is that you end up with occasional `if isinstance(result, Exception)...`.

I reviewed results library specifically here [0] and elaborate on different error handling techniques in Python, including the approach I described.

[0] [https://beepb00p.xyz/mypy-error- handling.html#container](https://beepb00p.xyz/mypy-error- handling.html#container)

<comment><USER4> Lambdas can be multiline/multistep, but it's just as ugly as you'd expect. Maybe the most "pure" functional way to do it is to have multiple binds/applies/maps, so instead of something like `x=1; y=2; x + y` it's something like `1.apply(lambda x: 2.apply(lambda y: x + y)).` Still unreadable, but for different reasons. It's more about the grossness of using `xEmitter.map(lambda x: stuff with x in scope)` to bind x as a variable than it is about the inflexibility of lambdas.

</comment></comment><comment><USER19> I'm a big fan of functional programming but this documentation is kind of funny, unintentionally. I realize there is no better way to do it in Python.

And that's how your initial refactored code will look like:

      user: Optional[User]

      can_buy_stuff: Maybe[bool] = Maybe.from_value(user).map(  # type hint is not required
          lambda real_user: real_user.get_balance(),
      ).map(
          lambda balance: balance.credit_amount(),
      ).map(
          lambda balance_credit: balance_credit > 0,
      )

Much better, isn't it?

<comment><USER20> I'm also a FP fanboy, and this concept doesn't quite convince me. I'm not sure a Maybe type really helps that much in a dynamically typed language. All the safety you get from using Maybes is worth Nothing (pun intended) when credit_amount could still return let's say Just a string, or raises an exception.

If this chain of calls supposedly handles Nones at any level, then .map is not the right method. It should be .flatMap (or .bind). Unless this is a magic .map that handles either X or Maybe[X] and even exceptions (just like JS promises). This flexibility may be convenient and I can appreciate its pythonicness, but it's not really in the spirit of typed FP.

</comment></comment><comment><USER21> Why the lambdas at all in these examples...

      (lambda real_user: real_user.get_balance())

and not

      User.get_balance

(besides subclasses not getting their balance called...)

<comment><USER22> It's a bad example. You can of course do more with lambdas in python. Maybe "lambda real_user: real_user.get_balance()+1" or "lambda some_junk, real_user: real_user.get_balance()" would have been better.

</comment></comment><comment><USER23> Cool stuff but what's with the logo? The branding is a bit too Affliction- esque for something usually associated with elegance...

</comment><comment><USER24> Functional programming in Python:

Step 1: try to integrate more functional methods in your current Python programming due to their usefulness.

Step 2: get increasingly frustrated, and then give up, because Guido and the Python devs seemingly hate functional programming and keep hobbling it.

<comment><USER25> A part of me is happy to see these types of tools introduced to python, but another part makes me wonder why people continue to use python when they see the value of things like `Option`/`Maybe`'s, `Result`'s, instead of just using a language with the features included from the start.

In my experience, the initial ease and speed of development when using python doesn't nearly outweigh the medium to long-term costs of maintaining it and developing the codebase further - at least for codebases that are more than a simple tool or something like a django app. Writing things like go, rust, scala, java etc. isn't that much more difficult or slower, but it does require more up front planning and understanding of your problem domain.

<comment><USER24> I don't have the skills to pull it off completely, or maintain it, but I've often toyed with the idea of a language/DSL that superficially looks and behaves like Python, but transpires down into Rust or something.

Mostly just to see what a language that 'feels like' Python would be like with the addition of things like proper Option/Result's and a couple of other features (stronger typing?).

</comment></comment></comment><comment><USER26> The `Maybe` container seems to be a close analog of `Option` in Rust

[https://doc.rust-lang.org/rust-by-example/std/option.html](https://doc.rust- lang.org/rust-by-example/std/option.html)

<comment><USER27> Another synonym is Some in some languages.

<comment><USER20> WellActually™, Some is a synonym of Just, Maybe is a synonym of Option, and Nothing is a synonym of None.

</comment></comment></comment><comment><USER28> Python is all about the magic. Lambda expressions are a bit of a black box for me in Python, it would be nice if that was made more transparent, or perhaps a different function entirely

<comment><USER15> It's hard to strike a balance for this.

For many FP programmers, the lambdas are not nearly magic enough.

In Swift, you can do something like this :

        reversedNames = names.sorted(by: { $0 > $1 } )

It's a closure expression, and is an anonymous block of code that will magically bind parameters passed to it to numbered variables.

So you see the position Python is in: it has to balance a bit of magic for the power user, and yet not too much for the casual user.

It's a very delicate exercice, and it receives a lot of critics for it.

An F# or Lisp dev comming to Python will complain that it's not expressive enough.

A geographer comming to Python will struggle reading advanced code.

Yet we have to catters to all of them, give the huge Python popularity and it's goal to be "the second best language for everything".

I think Guido did a very decent job at it, although he gets a lot of heat for it. People don't like to hear "no" when they ask for a poney.

And the lambda expression is one of the most controversial decisions. Beginners have a hard time with it, but professional coders may snap when they hear it's limited to one line.

</comment></comment><comment><USER29> can't say i'm a fan of the decorator to implement functional concepts. jut feels dirty. type hints in python are just as meh. feels like it's not taking advantage of pythons duck typing.

a version of try and either, with a decent do notation taking advantage of for comprehension... [https://github.com/papaver/pyfnz](https://github.com/papaver/pyfnz)

<comment><USER21> I think if that some of these concepts should just be included with the 3.9 Annotated Type

        Annotated[IO[str], unpure]

in 3.9 and above if the authors want to commit to type hints being core to this. I agree that the decorators feel a little wrong

</comment></comment><comment><USER30> Why would you want to use the I/O monad in Python?

<comment><USER31> A big reason to use IO as a value (which IMO is a better name than IO monad), is the same in all languages: reasoning about immutable values is easier than side effects. If we can take complex IO operations and use composition tools exactly the same as other immutable values, it's very nice.

Of course, in my experience, this is so foreign to people who haven't worked with it for a time it is very difficult to sell in small reply.

<comment><USER15> We have coroutines for that: it delegates any blocking behavior to outside of your code.

Introducing a new paradigm while this one just got in would be overkill IMO.

<comment><USER32> That's why a lot of functional language research is moving towards effect handlers, which could be explained in a nutshell as "coroutines, but for anything"

</comment></comment></comment></comment><comment><USER33> this looks like it will slow down the code immensely

</comment><comment><USER34> > But, having null checks here and there makes your code unreadable.

        if user is not None:
             balance = user.get_balance()
             if balance is not None:
                 balance_credit = balance.credit_amount()
                 if balance_credit is not None and balance_credit > 0:
                     can_buy_stuff = True
        else:
            can_buy_stuff = False

Actually I think that's very readable

        user: Optional[User]

        can_buy_stuff: Maybe[bool] = Maybe.from_value(user).map(  # type hint is not required
            lambda real_user: real_user.get_balance(),
        ).map(
            lambda balance: balance.credit_amount(),
        ).map(
            lambda balance_credit: balance_credit > 0,
        )

        Much better, isn't it?

No?!? That's much worse.

<comment><USER35> Yeah, I'd much rather read this:

        def can_buy_stuff(user):
            if user is None:
                return False
            balance = user.get_balance()
            if balance is None:
                return False
            balance_credit = balance.credit_amount()
            if balance_credit is None:
                return False
            return balance_credit > 0

Edit: something like Swift's optionals and nil-coalescing syntax might make this easier to read:

       def can_buy_stuff(user):
           return (user?.get_balance()?.credit_amount() ?? 0) > 0

</comment></comment><comment><USER36> writing `lambda` must get really old

<comment><USER37> I look at it as a reminder that there may be a more Pythonic way of doing whatever it is you are using all the lambdas for.

<comment><USER38> After typing it more times than I could really care for, I now see it as Python spiting people who have experience with functional programming.

</comment></comment></comment><comment><USER39> Nice premise. But it makes the Python code look super complicated.

It overloads map() with a lambda function, to compose function pipelining.

Then, it introduces flow() as the new pipelining tool. But you have to use bind() on the last function call to return the value.

Interesting concepts, but unless Python incorporates this as a standard feature, then this will remain a fringe idea. And it will add significant load to the development and maintenance process of Python programs.

Admittedly, I like Elixir's pipe forward concept |>

That makes it super simple to do functional composition, and it will automatically bind and return the last value.

Then getting the user profile, can be like so:

         user_profile =
              userid |> get_request |> parse_json</comment>


Evernote offering $100,000 in prizes in "annual Devcup challenge" - <AUTHOR> http://devcup.evernote.com/

<comment><USER2> If anyone would like to team up, I'd definitely be interested. Heavy Evernote user here.</comment>


WTF Should I Buy From Amazon? - <AUTHOR> http://wtfshouldibuyfromamazon.com/

<comment><USER2> Funny idea! :) What about opening the Amazon page to target=_blank so that a new browser window/tab opens (instead of taking users away from your site)?

Also: Sign up for affiliate compensation on other Amazon markets (DE, UK, et a.). Use geolocation to target your visitors to the appropriate Amazon locale.

<comment><AUTHOR> These are good suggestions, thanks!

<comment><USER3> If you're too lazy or busy to do the geolocation yourself, check out <http://a-fwd.com/> :)

</comment></comment></comment><comment><USER4> Nice, I made something similar this past Christmas: <http://santaroulette.com/>

How did you decide which products to pick from?

<comment><AUTHOR> Haha awesome! My approach is actually pretty hacky - I just have an array of random words that I select from and then search amazon for :)

<comment><USER4> Yeah mine was pretty hacky too - I scraped Amazon's gift suggestion categories, then realized some of the suggestions were terrible (e.g. Maxim subscription for Mom) and had to hand-prune the lists. I like your approach better actually, a lot more open ended.

</comment></comment></comment><comment><USER5> That is funny; unfortunately, it's exactly the opposite problem I have with Amazon.</comment>


What's New in Webpack 2 - <AUTHOR> https://gist.github.com/sokra/27b24881210b56bbaff7 <comment><USER2> Huge. Between webpack and Babel, JS is quickly progressing towards becoming a powerful language that is easy to write, read and reason about. I'm currently in the process of moving an inherited "minified by hand" codebase to ES6, and the difference is incredible. Not only are linters catching hundreds of previously unknown edge cases and bugs, but the end result is more performant and smaller in file size. It's very satisfying, makes me not mind coding in JS again.

<comment><USER3> Have you looked into TypeScript? Type system helps you catch even more errors.

<comment><USER4> Since adopting Redux, I've not seen many advantages of TypeScript. My codebase is just pure functions that describe simple state objects. What sort of advantages do I stand to gain by bringing in TS in this situation?

<comment><USER5> When implementing overloaded functions, explicitly defining an interface would allow for much easier debugging than testing it afterwards. Running tests (that can take up to seconds sometimes) is far less efficient than seeing the problem nearly immediately

</comment></comment></comment></comment><comment><USER6> What's the current thinking as of 2016 about Browserify versus Webpack? We've been happy Browserify users for a couple of years now, but I'm drawn to both the code splitting and dynamic expressions parts of Webpack.

On the other hand, I'm not keen on introducing more complexity or changing things just to be "fashionable", and Browserify, Babel, and Gulp do work together reasonably well for us (though I didn't much enjoy getting it all working in the first place, and I'm always nervous about updating any of them).

<comment><USER7> I think Browserify is an excellent tool. It does the one job I generally need it to, importing dependencies so I can write modular JS code. Running it is a one-liner, and running it with Babel is one extra option. Its behaviour is reasonably transparent, so you can look at the actual output and see what is really going on even if source maps aren't helping for whatever reason.

Personally, I'm not such a fan of Webpack. It trips my "too complicated" alarm, like RequireJS before it. I've never worked on a project that needed the kind of dynamic behaviour these tools support, and you pay a price for that flexibility in the complexity of the tool and the output it produces. Likewise, while you can include almost anything as part of your bundled JS output with Webpack, I've seen few real world cases where this is a significant advantage, and again you get locked into Webpack and its complexity as the downside. Perhaps on some types of project the features Webpack offers represent more compelling benefits.

For perspective, I'm also not a fan of tools like Gulp, also on the grounds that their ecosystems tend to be fragile and they add unnecessary complexity to what is usually a pretty simply operation in the first place.

<comment><USER5> I selfishly want more people like you in the javascript ecosystem. I had a debate with a freind if mine about gulp. My argument is that all of these tools are useless since they can be done without them. If only certian tasks should be run, create a commander script that takes in amount of args and runs each of those tasks.

His argument is that these gulp and grunt files standardize build and test scripts. Now its something you can definitively check off a list and when looking at others code have a form of familiarity.

I personallt agree, complexity and extra wrappers around what is already working makes little sense. But there are reasons these types of frameworks exist

<comment><USER7> I guess I just don't see what benefit is gained by writing a dozen lines of fragile boilerplate to run Browserify via Gulp. If you want to put the build automation in a well-known location, a typical Browserify+Babel build is _one line_ in the scripts section in package.json that says something like

        "js": "browserify src/index.js -o dist/index.js -t [ babelify --presets [ es2015 ] ]"

If you need more complicated configuration, you can use separate sections of package.json to set useful defaults, which is also the common convention for build tools in the Node/NPM ecosystem.

<comment><USER5> Again, I agree. Picture this: mocha gives testing globals, browser offers the window and dom, node offers process arguments. Coming from a partial teachers perspective (well, I wasnt hired to teach but I did talk to the students alot) gulp seemed to offer comfort and order in a world where "you can do anything" seems to cause imobilization. That problem I believe can be solved through introducing students to a philosophy of "you are in control, machines are dumb, only google can save you" but I can see where seperation makes people much more comfortable

</comment></comment></comment></comment></comment><comment><USER8> What's needed for Webpack 2: better documentation.

<comment><USER9> Indeed! I gave up trying to configure it to load files relative to the root and just lived with all the import '../../../lib/compents/...'.

I just tried the new beta and – surprise – it works!

I still think the structure of, say, Grunt is much nicer to work with – it's just code and easy to understsand & modify. Webpack has what must be the most awkward configuration file format currently in use.

The website also looks like it's from the late 90ies, but I guess that's not too important.

Apparently, it produces better output :(

<comment><USER10> This was definitely confusing at first for me, too, but with a little work, you can clean up your imports/requires with just a few lines: [https://github.com/tobz/scryer/blob/master/webpack.config.js](https://github.com/tobz/scryer/blob/master/webpack.config.js)

Note the resolve section. I have mine rooted at either app or node_modules, and I have some basic extensions set up. This lets me require something like 'components/CardBinder', which ends up then mapping to 'app/components/Cardbinder.jsx'.

It ends up working nicely and lets me forget about precisely what type of thing I'm importing, instead focusing on the fact that I'm simply importing some resource, period.

</comment></comment></comment><comment><USER11> Hm, I'm not sure about having to pull in a Promise polyfill to support code splitting (`require.ensure()`) in IE11... If I'm already using a promises library from X, would it be possible to somehow instruct webpack use that? Does that make sense? Am I missing something?

<comment><USER12> You would have to make the Promise object from your choosen promise library global before any calls to require.ensure.

</comment></comment><comment><USER13> For me the big thing in this version is tree shaking. I think it will change usage of JS stuff more than most people think. For example, I will use Cycle more because currently I feel bad importing all of RxJS for my toy projects.

</comment><comment><USER14> has anyone used systemjs + jspm here ? I inherited a codebase using jspm (due to the override registry system that works great with legacy javascript packages - like Handsontabe) and am wondering about webpack.

<comment><USER15> We are using jspm on an inherited codebase that was concatenated "by hand" with Rails' asset-pipeline (it has lots of old libraries and the overrides are very good to handle them).

What we hate is jspm is extremely slow in development for us. There are two main causes:

      - The amount of xhr. This is solvable with http2's server push (but
        our dev server is in Ruby, and there's no http2 webserver yet).
      - Apparently jspm doesn't cache the result of Babel's compilation,
        so for each page refresh every file has to be recompiled again.

We will look at Webpack2 when it's released, if it allows us to use these legacy libraries and wins us some development speed we will not look back.

<comment><USER16> Do you have cache disabled?

Also, how long does your actual bundle time take? For small projects, I actually get away with just triggering the bundle command when appropriate files in the project change. I highly doubt it would work for you, but if you're spending 10 seconds waiting for stuff to come in over the network, and your bundle command runs in 5, you could just do that instead, and actually work with the bundled code (and generated source map)

Looks like I'm not the only one who thinks it's sometimes a good idea: [https://60devs.com/optimizing--default-jspm-workflow-with- gu...](https://60devs.com/optimizing--default-jspm-workflow-with-gulp-and- nginx.html)

<comment><USER17> I think JSPM should stress the part about bundling. It's the second person that I see who says "JSPM is slow" and the reason behind this slowness is that they didn't bundle the files or bundled them incorrectly.

We do the same in our project: we bundle all the 3rd party libs when they change, so only our own code gets retranspiled on each page load. During deployment, we bundle all the JS in a single bundle (which is good for us, as we don't have too much JS in that project).

<comment><USER18> Any chance you can go into detail how you bundle your 3rd party dependencies separately? I have tried that, without much luck.

<comment><USER19> For me it's like this:

> jspm bundle app/ __/ * - [app/ __/ *] js/tmp/dependency-bundle.js --inject > --no-runtime

That tells JSPM to bundle everything except your application if your app lives within the app/ directory.

> jspm bundle babel js/tmp/bundles/babel.js --inject --skip-source-maps > --minify

This tells it to bundle the Babel dependencies which aren't considered in the above.

</comment></comment></comment></comment></comment></comment><comment><USER20> I'm really curious about the decision to support es6 modules here. Seems like Webpack is stepping into Babel's territory, but I'm not sure to what end?

</comment><comment><USER21> Huh, they've pulled es6 compilation in, away from babel?

It's early in the morning here so my pre-coffee brain might be terrible, but did they say which compilation engine they were using for es6?

<comment><USER22> ES6 modules support are now baked into Webpack, which makes sense because that's supposed to be it's primary concern. Any other feature you'd still need to use Babel.

<comment><USER21> Yeah I saw that, I was more curious as to whether they had said anything about using a pre-existing compiler, or if they had built their own.

</comment></comment></comment><comment><USER23> For people in corporate environments that can't run webpack/browserify are there any standalone tool alternatives?

</comment><comment><USER24> Is tree shaking still planned for this version?

<comment><USER25> Yeah, it's in there.

[http://www.2ality.com/2015/12/webpack-tree- shaking.html](http://www.2ality.com/2015/12/webpack-tree-shaking.html)

</comment></comment><comment><USER26> I tries cycle.js the other day and had to use some webpack.

Seems like npms default webpack Version is some 2.0 beta?!

Somehow requires in scoped modules didn't work with it ans I searched about n hour for an solution till I saw that the webpack devs seem to consider a beta a good 'default' Version....

Going back do 1.12.12 helped.

I love npm D:

<comment><USER27> It may have been temporary because right now the default version it installs is 1.12.12</comment></comment>


Scaling Erlang - <AUTHOR> http://erlanginside.com/scaling-erlang-292

<comment><USER2> This is one sentence that links to real content, skip the middle man and go directly to:

[http://inakanetworks.com/blog/2011/10/07/scale-test-plan- sim...](http://inakanetworks.com/blog/2011/10/07/scale-test-plan-simple- erlang-application/)</comment>


Ask HN: About to get on a plane. Best way to read HN offline? - <AUTHOR>

Not sure if the flight will have wifi.  In the event it doesn't, I would love to download a few pages of HN articles & threads, for offline reading.<p>Ideas? <comment><USER2> Do you have an iPhone? The Hacker News app is pretty good and downloads all the stories so you can read them offline (does not download the comments though).

</comment><comment><USER3> Open a bunch of tabs and leave them open but log off? (Sorry if I'm too late.)</comment>


Texthero: Text preprocessing, representation and visualization from zero to hero - <AUTHOR> https://texthero.org/ <comment><USER2> Great tools. It would be great to have a topic modelling feature or something similar to discover new topics</comment>