skysight-inc/HackerNews huggingface dataset:
I used to be a huge dynamic languages fan, with python being my favorite language over the majority of my career. Then I worked on a large python project of ~100k LOC with a team of ten. That's when I realized that writing code faster isn't the problem. Reading it is, making changes to code someone else wrote is, and refactoring across dozens of modules is a problem. Static languages help a lot with all three. I still love dynamic languages for small tasks, but I'd rather use a static language like Go which still keeps much of the dynamic feel, and helps catch my mistakes at compile time. I actually just set it to watch the project directory for changes and recompile automatically in a terminal on another screen (actually to run the unit tests, which includes compiling.) That's constant feedback and comparable to dynamic languages speed for edit-compile-test runs. But the best part is the unit tests. They run so much faster with Go that I don't get distracted waiting for them to finish, and that keeps me in the zone and much more productive.
I haven't seen that. That's really cool, and current applications should drop right into it, too. Disconnecting the touch surface from the mouse solves a lot of the current problems with touch screens.

Does the kind of large multitouch surface with flyover support needed by 10/GUI actually exist? Because I think I want one.
... and this integration uses that as well, so that nan stuff still works.
I would think that the increased productivity of Python over C++ has more to do with Python being a higher level language than static typing per-se.

I'm translating some Python into C++ right now for performance reasons. Manual memory management, lack of list comprehensions, and many other things are making it slower to write than the Python was but having to specify types is really the least of it. The extra visual noise often makes the code less readable but that isn't true of all static languages.
* Dangerous combinations, like alcohol, can be a contributing factor.

* Black market drugs can have widely varying contents and potencies (rat poison and fentanyl).

* Tolerance changes have already been mentioned.

* Taking drugs in a consistent place and/or circumstances causes the body to prepare for consumption (like Pavlov's dogs salivating at the bell). Unfamiliar situations can catch the body off guard.
I saw an episode of QI, in which Fry said up until 20th century pink was for boys and blue was for girls
.Net: A look through F# lenses
> People already know that their phones are made using materials excavated in awful conditions

Do they? If the level of inquiry most consumers put into the materials and production methods used to manufacture / extract / havest their everyday purchases are any indication, I'd venture to guess that only a very small percentage of folks think about what goes in their digital device.
WhisperPush – End of Life
This is why I think gradual typing with structural types is the Right Way, and will be what all modern programming languages move towards (like how we don't have to worry about manual memory management anymore).

Javascript with Flow, or TypeScript is a great example of this. Perl6 is using gradual typing.

The key thing is that there are times where you want the inflexibility of static typing, and there are times where you want the benefits of dynamic typing. Structural types also remove dependencies because the function defines the structure of the type it expects, and not a specific reference.

Also, I think github repos (and the person's tests) are heavily heavily bias towards individual projects. There's a massive difference between something only one person works on, and something that an entire team is developing over the course of years (as team members come and go).
Some colleges are better at getting women in STEM
It did say [Flagged] for a while, though. I was reading the discussion and it bounced in-and-out of existence while I was trying to contribute. The Reply button would disappear; at one point the link and title were removed, then restored. I guess this is what the Vouch system is for.
Task Manager Using Node.js EventEmitter and EventSource
21 Delicious Cups of Coffee to Keep Programmers Focused
Deep sea frogfish that walks on the ocean floor found in New Zealand
I wonder if the results would be the same had they compared a more advanced statically typed language with type inference like an ML or even go.
That's exactly what I thought.
> Success does not mean you're correct.

Err, yes, it does. That's precisely what success means. If you are successful at something, that means you did something right. What that something is is certainly up for debate, but you can't ignore success as an argument.
Same here. Epic's support for the community of devs who use Unreal is excellent, and they have made sweeping changes to their business model to align it with the needs of their user base which has really helped as well.
Agreed. I often find that most people who are very enthusiastic about dynamic typing have only seen it in action on solo or small projects.

Add complexity or people and dynamic typing quickly crumbles.
While it's not stockpiles of vulnerabilities, I don't think it's valid to say there's no evidence of vulnerability feeds. For example a bigger company can get early notification of embargoed vulnerabilities for various projects they use, sometimes with early patches.

I'd be surprised if USG didn't have access to pretty much every important feed like that. This gives every notified party at least a few days to act. (defence or otherwise)
The word 'waterfall' does not appear in this paper, not even to describe the model that Royce is criticizing (and it would be a completely inappropriate and misleading metaphor for the model he is advocating.) I suspect the use of 'waterfall' as a model of software development is a retronym coined (possibly by Royce, elsewhere) for what was once the only model of systematic software development, once its shortcomings and the need for an alternative became apparent. It has persisted because it is a convenient straw man: it is easy to make almost any new model look good when you compare it to the waterfall model. We should have burned this straw man long ago: 45 years have gone by since Royce explained its shortcomings and proposed better alternatives, so by now, we really should be able to justify our latest methods with something more than just "better than waterfall".
Sure, as long as everyone is paid 2X salary for every hour over 8. I've been abused at work, greatly. It changed my views. Not everyone has the same experiences and perspective.
I would disagree with you in the basic assumption that we let "everything just work out".

We do need laws that those who work over what has long been considered healthy- 8 hours, are compensated very well for their time. To the point that the incentive lies on the employer to hire more people.

There's nothing to stop you or anyone else from forgoing your pay. But working for free to most of us is unacceptable, we don't have as much money thus our transaction of time for money means more. And many have less power to call shots because they may be less valuable or talented.

Yet everyone receiving a paycheck deserves this basic protection from abuse.
Did his statically typed language include reasonable type inference? Because if not, then of course it took longer to write static types.

If so, then, well, that's interesting. I'm not sure I'm ready to take the training wheels off for myself, but maybe worth some thought?
Apple is just using another approach to having power users and novices using the same UI. How many people started by using a mouse for Edit (copy) before using, [Alt] [E]dit (copy), then Ctrl-C all in one step. Yes, you need to memorize Ctrl-C, but that's not a long term issue. The same is true of touch interfaces, you can use them knowing few shortcuts and slowly add more over time.

People spend hours a day interacting with a computer in one form or another, they will memorize things.

PS: Remember getting annoyed when Microsoft when gaga over the 'ribbon' concept? I bet you don't think about that one much anymore.
Apple is evil to the core (pun pun pun)
iCloud Social Network
We tried to solve the onboarding problem too early with tech (maybe pre-mature?). I imagine the trade-off between mission-criticalness vs willingness-to-try has a similar relationship to BJ Fogg's behavior model http://www.behaviormodel.org/ (motivation vs ease to achieve).
He Irons. She Stitches
Martin Luther King Jr., Subversives, and the Patriot Dragnet
> So Facebook complained that its emails were blocked?

Even better: Facebook complained that Facebook's email infrastructure blocked Facebook from sending further email from Facebook's campaign, and Facebook failed to notice that Facebook's email infrastructure was doing this, so TRAI is now responsible.
I just (more or less) duplicated your comment somewhere...jinx.
The study the OP references (from the original talk) seems suspect to me; in particular, the fact that the researcher created both a static and a dynamic version of his own language. Generalizations about the time required to "get stuff done" in all (or even most) statically/dynamically typed languages feel unwarranted. And then there are statements like this:

"he found [that] it took less time to find [type] errors than it did to write the type safe code in the first place."

Maybe that's an indication that his homegrown statically typed language was a crappy language, rather than exposing some fundamental truth about statically typed languages in general?
I used to run prime95 on all of my machines, back when power management (especially on desktops) was virtually nonexistent. Obviously, with the power management features we have now, an idle CPU (especially outside of a hosting environment) is not considered wasteful.
My name and email address is the very last thing in the Waze about box, because they used some code I open sourced. Turns out it's the only email address anywhere in the app.

Thanks to this, I get about a dozen emails a week from people asking for Waze help. (Lots more when Waze changes something, like hardware support for a particular device!)

I've tried contacting Google (either to get these people help, or to get my email address removed...) with no luck.

I empathize with Daniel. It's an unexpected downside to open sourcing something and asking for credit.
Adblock is destroying ads. Good
I would have thought Apple would not be OK with this.
It's only a little bit hyperbolic.

If a facility isn't providing jobs to local residents, there's no leverage to get sweetheart deals on local taxes.
In London most major museums are free (with a "shakedown") and have been for about 15 or 20 years. Special exhibitions tend to be charged for.

Ireland's economy and cultural sector is distinct from the UK's and much smaller. The Guinness Brewery and Book of Kells are really exceptional cases which cater to wealthy international tourists. They have little to do with local cultural life.
Ultimately, that's what makes HList / HMap / Records so interesting to my mind - heterogeneously typed containers without the manually-generated boilerplate.
> Config file isn't a config file, it's an executed bit of Clojure code

What exactly here is the problem for you? That config is not a config, or that it's specifically Clojure?
The 2016 Election Game – Cards Against Humanity for the Politically Unimpressed
I think this design handles those criticisms well. The application menu looks great for discoverability, and the context radial includes clear labels.
Startup Templates: Job Description
I'm in the same boat. For most of my career I've worked with dynamically typed languages, but I recently spent a year writing iOS apps with Swift. For me, the biggest win with statically typed languages isn't necessarily catching those obvious bugs (which, as you said, are fairly easy to avoid with discipline), but rather the increased discoverability. I can quickly glance at the type definition for a function/method and generally get an idea of how to use it, whereas the equivalent in dynamic languages usually involves reading documentation or looking at examples. And when this is integrated into your development environment like in the JetBrains products, Xcode, or Visual Studio, it's all seamless in a way that's not really possible with a dynamically typed language.

Of course, the other side of it is that statically typed languages tend to be less expressive, which makes things like JSON processing needlessly verbose. So it goes both ways.
> people who wear glasses

Just as a sidenote, I recently purchased a GearVR headset for use with my galaxy S6 and the headset allows me to calibrate the diopter such that I don't even need to use my glasses (though it is also possible to use it with them, though I prefer without). I feel like this will be a must-have for any future HMD, as in my experience it solves the glasses problem entirely.
Good question, no, no idea but of those two fftw would appear to have the edge so if you're going to compare do it with that one. I do know the fftw guys benchmarked an older version of it but I can't find the results (there used to be a bunch of graphs showing the relative performance of all those ffts listed).

It should be fairly easy to figure this out though, the benchmark code is public and if fft sizes you are interested in are known you could make a very precise comparison.

One warning about the mersenne fft code, it is not the most readable one on account of all the optimizations, but if all you're interested in is a drop-in library then it might suit your needs, especially if the size fft you're after is one that has already been optimized to the hilt by the mersenne project people. If you find you need to customize it then you're probably better off with a more universal implementation, even at the expense of some cycles.
Credit card fraud represents between 1% and 2% of an airline’s revenue
Not a passing fad. It will take off with time. Not everything is cheap or perfect at an early release.

We're trying to fool senses that have had millions of years to evolve.
No volume license? Not seeing the upside here.
Question for you.

As a normal user, grepping these values I actually get 0000000000000000. I can't imagine these being the actual values. Is it possible that because I remount my /proc with the hidepid=2 option the values are not visible for normal non-root accounts?
Ugh! These damn SJW types are so f-ing annoying. Sure, I get it, kids are mining cobalt in destitute, far flung places. What are we thinking, they should all be sitting at home in their McMansion and jacking off to internet porn and insulting people's mothers on XBox Live all day like other spoiled ass rotten crotch-fruit.
There have been two major Xcode releases since Swift was announced, 6 and 7.

Totally agreed on an official plugin system. There are a bunch of interesting unofficial ones out there, but I hesitate to even try them if I can't count on them to keep working.
The author of the article here. I know what you mean about my example. I in fact started with an example of red (255,0,0,255) texel next to fully transparent (0,0,0,0) texel, but found that example unconvincing - you don't really see the effect of premultiplication directly, as both texel values look exactly the same whether you premultiply or not. Really, another way to write the article would be to say, "whether or not you want it, the GPU will return premultiplied-looking values when you bilinear interpolate or mipmap." The interpolated value for (255,0,0,255) and (0,0,0,0) is (127.5,0,0,127.5). The only logical way to interpret this value is as a premultiplied value. I hope this helps. I'll add a sentence or two to the article along these lines, as it might help others to get what I'm trying to describe. Thanks for pointing out the confusion.
Meet the (up to 16.7cm) titan beetle:

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

http://www.odditycentral.com/animals/bugs-the-size-of-your-h...
I made this point in an earlier comment, but I'm a firm believer that if the speed at which you can physically type code is the bottleneck, then you are going to eventually have much bigger problems. Hastily written code will require more time to fix than it will cost you to slow down and think about a good design, regardless of language.
When Thinking About Investors, It's Not About Price
I assume he means more physically, and in that sense he is correct. You can use your smartphone or tablet basically anywhere and start using it on short notice. Something that you cannot really do with a tablet or laptop.
> I read "the Syran regime already has these vulnerabilities that could get exploited"

By the US (interested in removing Assad because of military supremacy), Saudis and Turkey ("our best allies," Sunnis to overcome "wrong believing" Assad). As planned since 2006.

The "rebellion" was mostly a Sunni extremist (as in, radicalized by the Saudi paid preachers) rebellion in the Sunni majority places, supported by the players above. Turkey was also strongly radicalized in the last few decades, also a lot of oil money. The US had also the "democracy" babble like that in Libya (supporting Al-Qaeda!) or Egypt ("but Muslim Brotherhood are our guys", we "really don't understand" why they turned Islamic, we don't read what they write, they told us it's democracy what they want). And the Iraq war was also to "bring democracy." It's hard to close the eyes so much.

If I understand, you have no sources for your initial claim:

> Assad did voluntarily release some Jihadists in order to exarcerbate the sectarian aspect of the conflict

That goal would be more than counterproductive. The "rebels" are almost in Damascus, threatening him. That he did some prisoner exchange or tried to appease the protest, I can imagine.
Seems like you have the bar set pretty high for what you consider to be a good designer. Would you mind sharing some of the work your studio does?

I am by no means a designer, but from an outsider's perspective(after all designs are consumed by regular folk like myself, not necessarily other designers) Lennart's work seems pretty well done. Especially considering that he is at the very start of his career.
I know everyone has their preference here so it doesn't help to just talk about anecdotes.

That said, the author really doesn't seem to take note of the largest benefit of type safety: Self-documentation.

Looking at someone else's source code with type hints gives you so much more of an idea of what's going on and what sorts of parameters any given function might take. With static types, that documentation is guaranteed to be right.

Dynamic languages also encourage the use of clever reflection in ways that make your code unreadable to someone who has limited scope of context.

For me, I'd rather be using a lib created in a static language.
I'd rather use a static language like Go which still keeps much of the dynamic feel, and helps catch my mistakes at compile time.

Right on. It's the "dynamic feel" which is really the key. It's the ability to iterate quickly, the access to anything in the runtime, and the ease of building software tools. It's an environment that makes you powerful by enabling everything and staying out of the way. Whether that's provided by "dynamic" typing is just an implementation detail.
Unreasonable Effectiveness Considered Harmful.
That could still reduce the European demand for Mexican and Colombian heroin, driving down US prices, correct?
To me, the best feature of dynamically-typed languages are dynamic container objects (JS object literals, PHP arrays, Lua tables, Lisp/Scheme lists), because instead of having every single container be a purpose-built one-off abstraction that is often not even completely inspectable, much less extendable, I can just have one standard structure for any data.

This is perfectly possible in static languages as well.
Pirating the Oscars 2016
I was just scanning the thread for a voice of dissent. Thank you for providing that.
Agreed, he's much more skilled than many designers I know.
Show HN: Freelance Debt, zero-risk debt collection for freelancers
In-page content personalization
E-democracy
By that definition though, anyone who comes out "ahead" on their premium is a freeloader. Perhaps a less charged term is needed? Freeloading sounds like this person has done something morally wrong, when in fact that have just used insurance as it is meant to be used.
For an example of this, see the "interactive fiction" heading of http://weblog.jamisbuck.org/2015/10/17/dynamic-def.html
Here's a starting point for you in your investigations into electrical propelled airplanes:

https://www.nasa.gov/centers/armstrong/Features/leaptech.htm...
Thanks for your thoughts :) We've updated the roadmap[1] to call out that JIT and more platforms are coming in future iterations.

1: https://github.com/Microsoft/ChakraCore/wiki/Roadmap
Snowball can only import data, not export it. Here is the footnote on the Snowball page:

Snowball currently supports importing data to AWS. Exporting data out of AWS will be supported in a future release.
That first datapoint... at worst, programs took 60000 seconds to write. That's 1000 minutes. That's just under 17 hours, or two days. In that time, it took less time for the programmer to catch type errors than for the programmer to write the static typing to catch the errors. I can buy that.

Now make the code base 10,000,000 lines. Maintain it for two decades with dozens of programmers. Now how relevant is that 2-days-at-the-worst datapoint?
Agreed 100%. This is actually the reason that I have been picking up go lately, you get some of the more lenient syntax of python, with static typing guarantees.
I have to ask though... would any of these people have better lives, young or old, than they would have without mining these materials? If they are kidnapped and forced into slave labor, that is not good, but if they work of their own accord and live better for it, then who am I to decide what their opportunities are.
He's doing experiments with programming in the small, probably with students as subjects. Not useful. Typing is most valuable for enforcing consistency within large programs, or between software components from different sources, where a change in one part may break other parts. If he wants to experiment with this, he should have groups of three or four students independently write parts of a program, then integrate them.

There's convergence on when to declare types. As I mentioned in a previous post, the trend is toward declaring function parameter types, but inferring the types of local variables. Go and Rust take this route. C++ now supports it with "auto". Even Python is considering adding optional function parameter type declarations.
Yep, same thing works for us on our HR app for small and medium companies called www.staffsquared.com.

While the automated lifecycle e-mails we generate are great at conveying useful information to new trial customers, one of the things that really set us apart from the competition is our free of charge onboarding customer service.

We tell customers that we'll do literally whatever it takes to get them onboard, even if that means entering their data manually for them. The lifetime revenue from a new paying customer makes this relatively small admin task, which relieves lots of friction, full of win.

We also generate a couple of e-mails to new customers both on a schedule and also when certain user activities are performed. The e-mails are designed to appear handcrafted and ask if we can provide any assistance with a particular feature or process. If our customers need anything they simply hit reply at which point a human picks up the conversation.
It's not that it can make just IDEs 'work better'. The compiler can work better with a great static type system. Haskell, for instance, is mind blowing.

Perhaps the problem is that static typing is confused with how some languages implement it. It can, and has, been implemented such that it dramatically improves compilation, correctness, static analysis and documentation without making code horrendously verbose.