skysight-inc/HackerNews huggingface dataset:
In some ways Python is more liberal but in different areas - Metaclasses, 'magic' methods (hooking into __getattr__ allows some very clever behaviour), operator overloading, control of the abstract syntax tree and doing crazy stuff with imports. Try doing some of that in javascript.

You want prototypical inheritance? Here you go: http://tobyho.com/2009/05/23/prototype-inheritence-in/

Monkeypathing? Nothing forbids it other than a sea of raised eyebrows if there was a cleaner way to achieve the same thing.

The only limitation Python has with first-level functions is that they can't be anonymous. I know a lot of people chafe at this but I've never seen any javascript code that wouldn't be improved by removing a couple of levels of nested anonymous functions ;-)
It sounds like they will add support for the same constructs as JS will have in ES7 https://github.com/lukehoban/ecmascript-asyncawait
But scheme/racket is really not that far off from java compared to Haskell. I've never had a hard time working with it, even though I've never learned it formally (ok, two weeks of LISP a long time ago). Racket never felt weird, and many of its API are OO in everything but name, it's like C# with the same amount of FP abstractions (list comprehensions), and maybe some macros and continuations if you want to do something advanced.

But Haskell really is functional programming, there is no way to accidentally create an easy to use OO-style library. And then there are the monads....
It seems your public domain suffix list needs updating (kiev.ua is a public domain). Someone's posted a link to a relevant Mozilla project recently: https://publicsuffix.org/
A cynical translation: "We finally realised that Apple was onto a good thing with their minimalism, layered UI and UI as a metaphor for physically interacting with your data. So we're putting a lot of fancy words together to make it sound like we're doing something amazing and new, while all we're actually achieving is explicitly stating what Apple has assumed to be common sense for decades. After all if we want all these Android developers to conform to a common human interface guideline ruleset rather than inventing their own UI for every new application, we have to make that ruleset sound sexy and awesome!"

I love how the guy presenting on stage starts talking about a new material that will provide tactile feedback, as if Google is already launching phones with shape-shifting screens. Some Android fans are going to be mighty disappointed when we don't have tactile morphing screens in the stores for Christmas.
اسعار الوقود الجديدة فى مصر 2014 سعر صفيحة البنزين والسولار فى عهد السيسى
;; comparing with racket:

(define (grade student)
(cond
[(excellent-work student) "A+"]
[(and (okay-stuff student) (tried-hard student)) "B"]
[(okay-stuff student) "B-"]
[else "C"]))

;; Or

(require racket/match)

(define (grade student)
(match (map (lambda (fn) (fn student))
'(excellent-work okay-stuff tried-hard))
[(list #t _ _) "A+"]
[(list _ #t #t) "B"]
[(list _ #t _) "B-"]
[else "C"]))
Fallout Style CV
Aaron Swartz documentary censored?
If I got up one morning and found that someone had scrawled all over my living room walls I would be right to conclude that someone "did it." It would be truly "infantile" to ignore this as a possibility, and assume, instead, that somehow the living room "did it" all by itself while I wasn't watching. That attitude would be truly "lazy" and would not advance my "knowledge and understanding" of who the real culprit might be. It would furthermore be grossly unscientific. If I were to habitually think in such a way (rather than "using [my] brain to figure out the mechanism") it might actually harm my future job prospects.
It's none of my business, but to an outsider it seems like you're being extremely frank about this whole thing.
I'm a teen I guess. Haskell as a first language worked great for me, and I happened to write a game and a few scripts in Python two months ago so I think I can answer your question.

So, what made learning Haskell a good experience I think was mainly the strong type system. You could basically even early on use functions you barely knew what its name meant solely based on its type signature. It also made the progress of writing a program very nice, you write it and then it fails, you go back and try fix it, and when it compiles it usually worked.

There are some things to keep in mind though. Wild recursion is really the GOTO of functional languages, it's important to teach how to use the generalized folds and traversals early on. Secondly it is important to have simple analogies to concepts such as functors, monoids and monads etc. If you make sure to not care about these strange names then you can go pretty far by just trying to make the type signatures stick together, and it's not important for a beginner to grasp these directly either.

Python was quite smooth to learn coming from Haskell, the syntax is similar and it simply felt like programming in Haskell's do-blocks. It was very easy to get quickly going, I managed to write a little script talking to a JSON API almost directly after reading the official tutorial. I also digged a little bit into the realm of OOP, I wrote a simple game using Kivy. It felt quite nice actually, I could get some code re-use, although it was harder to get that (as newbie) than in Haskell.

EDIT: Something like typed Racket might been even better when I think about it, since Racket got a lot of resources for complete beginners. Then you get the benefit of easy to use syntax too, although syntax is probably not the biggest problem when starting out. For the record I usually recommend Python or Racket when people ask me where to start, because in the end I don't think it matter much what language you go with first, just make sure not to limit the paradigm of languages you learn afterwards.
That is an incredibly condescending way of arguing. On the other side of the coin you could claim that imperative programming is more practical, concerned with the actual steps needed to solve a problem, instead of an ideal, indirect formulation. Imagine having to explain someone how to bake an apple pie without being able to state any specific steps how to do it but instead describing the pie as some set of interrelationships of the ingredients. (That is probably not a fair characterization of FP, but it's at the same level as "[imperative programmars] love the machine").
Wow, the arrogance and ignorance is just incredible, just the way I remember. :-) Someone who doesn't buy into your highly constrained world-view must obviously be ignorant.

"doesn't seem like you got it" ... "purposefully not getting it" ... "principles [..] undeniably the best".

No, you like those principles best, and that's about the most you can say. We don't even have solid criteria with which to make that call, never mind there being any type of consensus as to which is "best" (except within specific communities, but with each community having a different consensus and the most closed-minded of these communities usually the most sure of themselves).

Just to head off more ignorant comments: I aced those courses, as well as a few more including the elective "foundations of FP" and did my oral exam on Backus's FP calculus, which inspired me to come up with Higher Order Messaging: http://en.wikipedia.org/wiki/Higher_order_message

I also did some courses on algebraic specification and graph grammars (related to category theory), as well as formal specification with Z (yes, aced those as well). While useful in certain very constrained areas, these techniques trade making the smaller problem better (spec -> code) for making the larger problem ( actual problem -> spec ) infinitely worse.

Of course, functional techniques are a part of my toolbox, as they should be for any professional. However, if they were the only contents or even the majority of my toolbox, I couldn't do what I do and have been doing for the last quarter century.
There are still some rough edges, but definitely one of the best redesigns I have seen.

+ large, beautiful readable fonts

+ Search bar is a search bar and easy to find

+ unnecessary borders removed

- Could use a little bit more branding

- No change-language feature

- Zoom disabled on mobile devices

- Some elements needs size tuning
Next time I have a long flight, I can now go through Project Euler and stop when I'm right. Having solutions is nice to have.

One interesting potential mode would be to (as suggested below) encrypt the solutions and switch --verify to --attempt, then keep track of # of attempts for scorekeeping.
CPUs are still getting a lot faster, at a geometric rate. But they are doing so at a different rate than they did in the '90s, where CPUS were getting enormously faster year over year.

Here's a chart (note that the vertical scale is logarithmic): http://preshing.com/images/integer-perf.png

In the '90s processors were doubling in performance every 20 months or so (i.e. a factor of 64x per decade). Since about 2005 processors have been doubling in performance about every 43 months. This is much slower than the insanely fast rate during the '90s but it is still very fast and still on an exponential curve.
> All I wanted to do earlier was drop the pin at my current location (which Google Maps couldn't divine due to no GPS) and then "Search Nearby" for eating places.

/me
goes to maps.google.com
clicks on a random area of the map
a "location" card pops up with lat/long and estimated name
clicks on the card to validate the location
a second card pops up below with a street view shot,
"photos", "explore this area" with "search nearby" and
"getting around" with traffic and travel options
a third "quick facts" card is slid below
clicks on "search nearby" and types "restaurants"

Also possible: type "restaurants near whatever", or simply "restaurants", which scopes the request on the current viewport.

Seriously.
How search begins at ReaderDeck
With an irrelevant dig at minimum wage thrown in as a bonus "not as bad as" argument.
It's worth mentioning that the tool this blog post is about defines a simplified version of Haskell's standard library. In particular, there are no type classes exported from Prelude, much less monads or functors. In the end, it's not really any more complex than Scheme, except for syntax.

Now, true, the syntax is much more complicated than Scheme. You can operators and precedence and all that. But while definitely complex, it is mostly consistent with math notation. I tried to teach with Scheme first (following www.bootstrapworld.org) before I created this, and I found the change in syntax from what they are used to can be a real obstacle for children. This is also consistent with the comment about MIT moving to Python, which similarly has much more complex but familiar syntax.
> While I do believe that the principles used in FP languages are vastly superior I don't think this is really a matter of debate. The advantages are obvious and if you didn't realize it you probably weren't taught well enough.

No, there are plenty of people who will debate this, programming languages academics even. There is a vocal FP crowd that fawns over elegance, but there are plenty of other people who are more pragmatic about it.

> I sometimes wonder if the wins from FP languages are lost on the people not already scarred by the pitfalls of imperative programming.

Pity the poor programmers who get things done, write huge beautiful systems, all without worshiping lambdas? And by taking shortcuts ala side effects as a way to making things easier.

> Maybe someone uninitiated in programming won't have as many problems formulating functional solutions to problems in Haskell too.

It depends on how much math they have behind them. You take a mathemegician, sure, but a high schooler who is still having trouble with pre-calc?
Wouldn't the opposite - stream editor (programmable) in Lisp - be more useful?
Erlang, just for fun:

grade(#student{work=Work, tried_hard=Tried}) -> grade1(Work, Tried).
grade1(excellent_work, _) -> 'a+';
grade1(okay_stuff, yes) -> b;
grade1(okay_stuff, _) -> 'b-';
grade1(_, _) -> c.

Edit: formatting.
Yes! In particular, Harvest for Mac: http://www.getharvest.com/mac.

Killer features:
- Start/stop timing in one-click or keyboard shortcut
- See exact time in menu bar: https://www.dropbox.com/s/d56zb9ryffik7ey/Screenshot%202014-...
- Idle time detection - leave your computer with timer running. When you're back, Harvest asks "You've been gone 15 minutes, should that time be counted?"

Still hoping for:
- better offline support (can't stop timer w/o internet access, which means a bit of mental work when working offline on the Caltrain).
Has this been reproduce somewhere else? I have always been very sceptical of that claim since I first read it.
I don't see how lying about anything could be considered ethical. It may be socially acceptable to lie about yourself, but that doesn't make it ethical. Plenty of things that are socially acceptable are in fact profoundly unethical.

So, the line is in fact very simple: if you are an ethical person, you never lie.

Update: however, upon reflection, society forces us into practical considerations. If you avoid lying you will be taken advantage of because you weaken your position in society. For that reason, while lying is never ethical, it is sometimes the only realistic alternative. You may for example have people lying about being hiv-positive to get a job. There is no rational reason in many job categories to reject such an applicant, but in practice they won't get a job if they tell the truth. I also would make an exception for withholding the whole truth. Sometimes people have the right not to know things which would only hurt their feelings and bring no practical benefit.
Sounds somewhat familiar to what you can achieve with Paul Stretch. I assume it has something do with phasing...
Thanks. I think the structure and organisation of articles on Wikipedia is pretty sound, but some visual tweaks can help make the page more easily scannable and a litte bit more aesthetically pleasing (which I realise is a very subjective thing!)
Elm is this weird language that is really good at visual demos but is not anything interesting as far as language goes (if you want Haskell, just use Haskell, if you want FRP, there are plenty of libs for that, if you need pseudo FRP on web, then elm makes sense).

Scratch would be impossible to use as a functional language, especially for the logo-style turtle procedural behavior they are aiming at.
Top things for "World Cup" are videos of girls with big boobs in low cut shirts. Classy.
A space leak is simply pinning memory unintentionally, which definitely happens in most garbage collected languages.

Perhaps Python programmers would be baffled by time leaks instead :)
Thanks very much! I wanted to keep all the existing features of an article page rather than eliminate anything. I think it's possible to do this while making the page feel a little less busy and cluttered.
Thanks for sharing your experiences! I've always been curious about this.
I don't know the level of difficulty involved in the former, but "spoofing" cell data is possible by making the phone connect to sub-optimal towers. This would cost you service quality and battery life, but you'd "appear" elsewhere. This requires reversing and patching proprietary software, though.
It has a fatality rate of UP TO 80-90%. Some outbreaks it's been as low as 35% and the current outbreak in west Africa has a 65% fatality rate.

Ebola isn't super contagious. Way, way more people die from the flu every single year than have died from Ebola ever.
Could you be more specific? Which Material interaction do you think you could improve upon?
Show HN: Ectoplasm, alternative bridge between Node.js and PhantomJS
Its deliberate dumbness was a good idea that does not get enough credit. You should not be doing complex logic in the template layer.

I still think it could be made more user friendly for designers, though. We need some sort of app that will autofill django templates' context variables with test data so that designers can see how it all looks and edit them under different circumstances without having to deal with the messiness or state of the system underneath.
Using jinja2 is technically possible, but it would be difficult to use other django apps at the same time as they all assume the standard django templates.
This has to be one of the most irritatingly pedantic aspects of C, as the vast majority of systems use 2's complement and so would overflow in the same way, but the compiler writers think it's an "opportunity for optimisation" and I think this ends up causing more trouble than the optimisations are worth. The only sane interpretation of something like

if(x + 1 < x)
...

is an overflow check, but silently "optimising away" that code because of the assumption that signed integers will never overflow is just horribly hostile and absolutely idiotic behaviour in my opinion. A sensible and pragmatic way to fix this would be to update the standard to define signed overflow, and maybe add a macro that is defined only on non-2s-complement platforms.
The UI needs to be more complicated than that. I've forgotten to note the finish time, and have needed to update things after the fact. Suppose, for example, that I've forgotten to exclude lunch from the timing system. With a pen&paper system I can mark "(lunch, 45 minutes)" after the fact. There are plenty of computer-based systems which can do the same, but their UIs are more complicated than the one you just outlined.

Also, with pen&paper billing is usually quantized to 10 or 15 minute intervals, which makes it easier to do the arithmetic.
Simple Google spreadsheet with formulas to automatically sum up hours and dollar spent, as well as subtract what remains in my projects.

As well, quick drop down to select what is being worked on by whom.
I love the visual direction, and I think it will work very well for a diverse set of Google products. The style guide is beautifully done and well articulated.

In terms of interaction design, however, it doesn't break any new ground, apart from better transitions (but at times, too much).

> So the team set about creating this metaphorical material, which is a little bit like magical paper.

A bit of nitpicking: "a bit like magical paper" can hardly be called a Metaphor. It's just a loose analogy. In fact, I have to force my imagination to see the paper-ness in the UI, otherwise it just feels like flat UIs with realistic shadows.
I use SpikeTime.

The website is only in german, but the tool can be used in english. I don't get why they don't translate the website ... but well the tool is really cool.

http://www.spiketime.de/
5 Earth Anomalies That You (Probably) Never Knew Existed
ISIS at israel's border LOL
> It depends on how much math they have behind them.

Very much so, and also depends very much on the problem at hand. Yes, compilers and yet another RB-Tree implementation can be great in FP. Most real-world problems aren't that. In fact, most real world problems I have encountered (and see) tend to be massively about manipulating state. Often they do little else than shuffle data around.

I sometimes think "computers" are misnamed, because they do so little actual "computation". "Data around-shufflers" might be more appropriate.
specifically, the idea that UI elements should behave as if they were tangible objects isn't a new idea. this is what apple have been doing for.. quite a while, and honestly I didn't think this was breakthrough stuff - elastic bounce on scroll views, smooth, clean, and consistent UI transitions, and previously skeuomorphic design principle.. the idea that that interactions with a interface should mirror our interactions with things in real life doesn't seem like a shocking revelation.

what's worse is that they have had this epiphany, and then.. seemingly ignored it.
Use your experience to do another startup, but avoid doing things which led to startup failure. The worst thing you could do is give up. Also try to find investors first instead of spending family money on first business.
I dont need it
http://hacki.ng
Reasons Why You Can’t Live Without A Particle Accelerator
Is Linkedin down?
OAuth2 vs. Basic Authentication
> Here's a chart

Interesting that in order to compare apples to apples it's single threaded. That means for a back of the envelope estimation of ideally parallel loads performance, the graph goes "through the roof" since it's exactly twice on my laptop or four times on my desktop.
>The poor abstraction really causes problems when you need to do anything beyond the simplest of use cases. To achieve even modest performance gains, you're better off hand writing your SQL. Additionally, doing even the most trivial of trivial aggregate queries will also mean that you're hand writing SQL.

This isn't really a big deal - you can just hand-write your sql directly using .raw() and just pull out the corresponding result set and use it as you were doing before.

I've had to do what you're suggesting, but not a huge amount. Maybe 10-15 times on large, high scale projects.

SQLAlchemy is better but the number of times I have to break out of its abstraction layer are not enough for me to feel like I really have a desperate need to use alchemy instead. It's a minor inconvenience, nothing more.
Whenever I get depressed there are some coping mechanisms I use.

* Play games (e.g. OpenArena and FreeCiv), cheating liberally and/or playing on easy settings. (Yeah, take that bot...)

* Go for long bike rides. Take water, some food, and a good book. Go somewhere new each time.

*Read a good book. I read SF&F, but whatever tickles your fancy.

Oh look, all escapist mechanisms. That's OK. I can't offer any suggestion as to debt relief, as that's something else. But...
Why? "my code" is in $GOPATH/src/github.com/natefinch/ ... all code that is not "my code" is in other directories. Why bother having to switch over to some other gopath to get there?

Go import directories, are, by definition, unique. My work code is under github.com/juju/. Why should I put labix.org/v2/mgo under some other root path? They're unique directories either way.
>It's a matter of there actually being principles instead of the alternative; nothing.

BS principles are not better than no principles.

Or principles that tie your hand around your back for that matter. And functional principles do that for a lot of cases, with respect to performance, memory impact etc.

Functional languages are not some kind of 2x or 10x multiplier of a programmers abilities. In fact most of the things that made LISP interesting have been ported since ages in modern non-functional languages, from GC to closures, and even macros.

>Most FP languages are not suitable for performance sensitive tasks and most people will admit this. For most other tasks, though, they're just going to allow you to work faster and get to where you're going with less hassle.

Not the case in the real world.

For one, this BS idea forgets all about ecosystems and libraries. Python will let you work faster and get where you're going with less hassle. Functional languages that have 1/10 the libraries available, and in various stages of abandonment because of lack of programmers will not.

>The alternative isn't as much a principle as it is a lack of principle.

Really? For one, what all "FP languages" do when they run, is "flip individual switches and modify memory". The way they model the program is just an abstraction (and a leaky one) from what happens in the machine.

Second, I thought the Church-Turing thesis shows that lambda calculus is equivalent to the Turing machine way, for one.

Third, where did you get the idea that non-FP languages don't have principles? Smalltalk, for one, sure has tons of unifying principles behind it. Prolog. Erlang.

And if Algol was good enough for Dijkstra, modern, 10-times better algol derivatives are good enough for me. Especially if they also have adopted tons of functional paradigms, which you can get to opt to use when it makes sense for your design, and not have them forced upon you.