skysight-inc/HackerNews huggingface dataset:
continued ...

> Static types are also anti-modular. You have some library that exports say a Person (name, age ..). Any code that uses that data needs to see the definition for Person. They’re now tightly coupled. I’m probably not explaining this point well. Watch the video around 48:20.

This seems just wrong to me. You can declare structs as static in C and provide public helper functions that internally create data types, apply other static functions to them, and the produce results from them. In Haskell, it's very common to avoid exporting value constructors for data types, and to instead provide helper functions that allow for the implementations to remain hidden from anyone using the module. Modularity really has nothing at all to do with the dynamic vs. static typing debate.

I'll also throw one more downside of dynamic typing into the ring -- you sometimes will see really poor attempts to use so-called "defensive programming." In Python this is an especially bad code smell -- you'll see a huge block of assert statements right at the top of a function definition, in which all kinds of type properties and invariants of the arguments are asserted, so that TypeError can be raised immediately.

For one, in a dynamic typing setting, it's probably better if that stuff is the burden of the caller rather than the callee, in the spirit of a function "doing one thing and doing it well" it shouldn't also have to carry around all of its own type and invariant assertions. Notice that in a static language though, this isn't a problem and even is a huge benefit because it doesn't require the huge, human-error-laden block of asserts to achieve it. Just a nice, simple static typing annotation and then the compiler will deal with it.

Related to this, and as a final point, we should also need to give more "severity" to dynamic typing exceptions that occur at run time due to type errors. For example, in the financial job I mentioned before, it would be common place for an analyst to submit a very large batch processing job to the internal job manager. Some of these jobs took > 48 hours to compute and the output would mutate databases and so on.

So when someone set it running on Friday evening and expected there to be results in a database on Monday, imagine how awful it was to see that a TypeError had occurred and that not only did your manually created assertions fail to capture it, but also, there was no way of proving it couldn't happen without just running your code -- so you burnt maybe 30 hours of computational effort just to be told that upon hitting a certain point in the code, here's a TypeError.

This kind of error, which is categorically eliminated from possibility in a well-written static language program, should count for way, way more than a simple and stupid "oh I tried to call the API function with a list instead of a tuple, whoops my bad, let me just arrow-up in IPython and do it again" Type Error (though it's not clear to me that several of the referenced data in the post would make this distinction or penalize these types of errors more).
So he can quote the creator of 10/GUI, "DesktopNeo has some more promising ideas (there's some really good thought iterating on full-height window workflows)... it's a strong showing overall."
Why are those things an incentive to work your butt off? I see why those would lead to you being happy at your job, but I don't really see why being happy at your job means you should work extra hard. Just curious, as it seems to me those are things which would make someone stay at their job for a long time but not necessarily work extra hard. After all, it's not like your not working extra hard would lead to losing to those things.
You're correct. Windows NT 3.1 was visually nearly identical to Windows 3.1. This was part of the reason for releasing a 1.0 product with a 3.1 version number.
Rails has this available via a gem: Active Admin (http://activeadmin.info/).
Awesome idea, think it can work for boutique service firms just as well as freelancers. Always very difficult for the little guy to collect from the Fortune 500 Co or even the heavily backed startup..
Your best bet to understand the AI debate (and both sides) is to dig through lesswrong.com .

My brief answer is that people fear what they don't understand. And in this case the people shouting out their fears haven't properly and in detail stated their assumptions and definitions.

> I believe AI (or AGI) that is better than humans is quite far from done.

AI and AGI are wildly different things. My preference is to talk in terms of expert systems rather than the lofty sci-fi acronym. Such as Big Blue, Watson, etc...

Personally I think artificial personal assistants will help make the world a much more comfortable (and pleasant) place for those that can afford them. That is until the fourth or fifth generation when they're cheap as paper (or have a limited kind of reproduction).
It should only apply on a real liquidity event why every on isn't in SV lobbying there congress and senator reps amazes me.
“Heroes of CRISPR” Disputed
> by default

Arch don't even have coreutils "by default". Yes, I know, you're supposed to install them anyway, but if you follow the standard install guide, there is no GRsec.
Every bit of that "magic" is either meta programming or a dsl.

A large part of both rails and ruby is very well documented to the point where you can click on methods and see the code that makes them work.

When that fails you can debug with pry.

This stuff is not magic. Its not havening to reinvent the wheel poorly again and again.

The strongest sign someone hasnt spent much time building even a trivial app in ruby with rails is complaints of magic.

The magic straight forword once you see there is just code that generates methods (meta programming)

...
I agree, that made absolutely no fucking sense. That was some Youtube comment level stuff right there.
quit right some times they have a negative value (after tax)
Yup, type inference really feels like the sweet spot to me. Nice code "feel" with the backing of a static type system.
Yeah I got trashed karma wise on a previous comment explaining how I had to port some Ruby apps to Java. I don't even care that much about either technology but just mentioning that I had to port something to Java earned me -4.... seriously.
aah. Okay. Disclaimer, [b] this isn't my area [/b] and I'm going to miss some folks. I apologize to all of the important and interesting work that I'm missing.

Also, I'm really linking to research groups, so take these names as starting points and look at their students and other professors working with them.

First off, the Blizzard challenge is a major hub of activity. [4] Festival is an important piece of software [5]. Interspeech is an important conference [6] (take a look at the speech synthesis track and the organizers for that).

Alan Black [0] @ CMU is kinda a giant.

Keiichi Tokuda [3] @ Nagoya also a giant.

Simon King [1] @ Edinburgh, just had a paper linked to on HN a few days ago and does important work.

Mark Gales [2] @ Cambridge does work here, too.

[0] https://www.cs.cmu.edu/~awb/
[1] http://www.cstr.ed.ac.uk/ssi/people/simonk.html
[2] http://mi.eng.cam.ac.uk/~mjfg/
[3] http://www.sp.nitech.ac.jp/~tokuda/
[4] http://festvox.org/blizzard/
[5] http://www.cstr.ed.ac.uk/projects/festival/
[6] http://interspeech2015.org/wp-content/uploads/direct/INTERSP...
And it's not vulnerable: https://twitter.com/CopperheadSec/status/689553753423216641
Maybe because Apple is the one named company that refused to comment.

"(Samsung) SDI, told Amnesty it doesn’t do direct business with the major Chinese suppliers mentioned in the report and that they aren’t in its supply chain."
Automation will be used as much as possible, up to the point where a human must be involved, either to exercise judgment or because that human's job hasn't been automated away yet.

Consider the farming industry. In a couple of centuries, it has gone from 90%+ of the population to a couple of percent, while the number of people being fed has increased several times over. That's automation at work, pretty fast in human terms. Did it cause a massive dislocation and unemployment when 90% of the human population was more or less replaced by machines?
wow, speechlessly dyslexia, as in :
you can you up, no can no BB..
So to review:

everybody: obvious potential liar

everybody: potential blameless victim of ignorance
Guys, sometimes just enjoy the work. No need to nitpick on every detail. This is not a service and you are not a customer. It's a simple design concept.
Your biggest loss on lottery tickets is your stake.
I think about that one constantly, in the v sense that it motivated me to ditch Office as much as possible (I mostly use LibreOffice these days)
> Maybe that's an indication that his homegrown [...] language was a crappy language, rather than exposing some fundamental truth about [...] languages in general?

Can you come around and make this same argument any time someone makes a blanket statement about static languages being unconditionally better than dynamic ones?
From the article:
"Apple didn’t directly answer its questions about purchasing components containing cobalt processed by the main Chinese supplier. ... Apple, based in Cupertino, California, declined to comment further when contacted by Bloomberg News Monday."
So, modern ATLAS has a CPU throttling check, for example:
http://stackoverflow.com/questions/14592401/atlas-install-re...
From my experience, a statically-typed language also lets me think upfront about the structure of the data that a program will manipulate. Getting your data structured properly from the start would result in straightforward algorithms and less future refactoring, which is certainly more efficient than throwing away and rewriting code every few months.
100k lines of Python? I find it hard to believe that this project is properly organized. Rarely do you see 100k lines of Python solving a single problem, instead a project will be divided into many components, some of which can be reused in other projects. There shouldn't be any difference working on 1k line or 1 million-line code bases as long as the code is decoupled. Testing each part in isolation helps a lot (as opposed to running tests for a big monolithic ball of mud), as it ensures contributors are not introducing crazy dependencies.

I'm not against types at all, but don't think they solve problems related to big code bases.
Out of curiosity how would this service ever make money? Won't it become very capital intensive as it scales while the customer base appears to be driven by price.
I agree whole-heartedly. I was excited when I heard Windows 10 was adding multiple desktops, however I find they are quite lacking in use. For example if I want to move a single window of Notepad++ to a different desktop it moves all of the Notepad++ instances.

On top of that, I really don't want all of my software always open in a separate desktop. There is no need for me to keep Photoshop open, using resources, while I have transitioned from work to play time. I'd much rather have a "working" session saved and a "gaming" session saved where-in different programs are auto opened when I start a session.
If one were to look at my Facebook feed at any random time and imagine it representative, one would come away with the impression that vaccines are an evil plot by pharmaceutical companies to make money, that airplane contrails a.k.a. chemtrails are an unknown but surely nefarious conspiracy by the government involving mass quantities of psychoactive chemicals dumped into the air, that "natural" healing using tea and crystals and such is way more effective than doctors and hospitals and pharmaceuticals, and plenty more along those lines.

My mother is deeply into this stuff, and I have some friends through her who are lovely people aside from the part where they believe in this stuff. They don't make up a large proportion of my Facebook friends, but some of them are very loud about their beliefs.

Now imagine if you don't care a whole lot about this stuff one way or another, you get your shots on schedule because that's what people do, you never considered government conspiracies because the news never mentioned them, and you see the doctor when you get too sick because that's what everybody does. Then you become exposed to all this stuff, written very confidently and seeming to be backed up with solid facts, charismatic people, and high production values.

I think there's a good chance you'd start believing it!
This is my feeling as well.

I _like_ looking at header files. They're a good, compiler-mandated summary of what all this code is _for_. Figuring out what Python code does is always such a pain.

(I do, however, develop mostly in C++, so there's probably all kinds of workflow crap I don't know about in Python)
Italy, America, and the iPhone
I've been a lot of programming in both lately (Clojure and Objective-C), and did a ton of Java earlier in my career, and I find I like both. The biggest pain point for me in Clojure is the inability to easily refactor.

To overcome the limitation that the machine can't help as much when using a dynamic language, I've found that writing good unit tests with solid coverage gets me pretty far, and shortens the feedback loop when I break something.

But yeah, I sure do miss the right-click and 'rename' feature from Eclipse and Xcode when writing Clojure.
This person refers to themselves as "Legal Counsel" for the company, but I doubt he is an employee.
It's been a while since I last wrote C# code, does it really allow for heterogeneous value types? If so, that's cool. However, from my recollection, the C# API itself is all about opaque objects and behaviors. That's not a criticism of the paradigm, and I remember liking the C# standard libs and structures a lot better than Java's, but it's not something I would equate to generic heterogenous containers in dynamic languages. It's not in question whether you can replicate some of that in .NET, it's more about whether that's a core language idiom or not.

Edit: `collections.namedtuple` is Python, mixed that up.
The example is a bit cherry-picked. You could argue that the process went like this:

* 1980s - "takes a lot of time and money to churn through old legal docs, let's hire a paralegal"

* 2010s - "it's easy to churn through old legal docs, making it much easier to manage multiple legal cases in parallel. Let's hire a paralegal to help me juggle all of these cases."

...

* 2020s - I've hired HireASuperParalegal.com to do all of my paralegal sleuthing. They help me manage the workload of four paralegals for the price of one.

Meanwhile, how about telemarketers? Have their numbers increased in droves like--apparently--paralegals? I suspect not.

Anyway, @ergest mentioned that the doom-and-gloom is tiresome, and it certainly is. Personally though, I just find it a fun thought-exercise to think through how we'll matter in the long-run. In the meantime there'll be a "new" class of workers whose jobs move from paper-pushing to being specialized software-users and from there... what? Certainly "computer-or-software fix-it guy" jobs will be universally useful from now into the foreseeable future, but will they pay well? :-)
> Haskell, for instance, is mind blowing.

Mind blowing is the amount of output and obscurity of the error message you get from the type checker. It's harder to understand the error message than to debug the program if compiled "unsafely".
I see, I didn't quite connect the dots there. Well, if anybody cares about why I think insurance companies might say that, there it is....
> No, this has very little at all to do with reporting to vendors.

Right, and what little it has to do with reporting to vendors is this: If you want to throw a wrench in the surveillance apparatus, instead of selling privately, disclose to the vendor to spite the government.

But that's not to say that reporting a vulnerability to MITRE/CERT is going to land a 0day in the hands of the NSA. (But on the other hand, if you're lucky, you might kill a vector they were already using.)
He mentions in a tweet reply it was the other party that initiated it.
I know many people who would.
>recently

Ha.
If you're not technical enough to know what a VPS (dedicated server) is, you're not technical enough to run and maintain one. Important software updates need to be done, backups might now be your responsibility and whereas your shared hosting has monitoring and teams to keep it up, that team is now you (oh by the way, you'll need monitoring too).

You need to split the two components, as other HN readers have said. There are lots of reasons to use something like MailChimp (I use them) and only financial reasons not to. Find a mail provider for your marketing, and use shared hosting for your website - unless it's really popular - then either approach a customer friendly company (MediaTemple have been good to my previous non-tech clients) or be prepared to pay a contractor.

I'm guessing the fact you have an in-demand site and a 15k subscription list means your earning at least something, so think of this as investing. Trying to host/maintain the technology that underpins your business is like using discount supermarket oil in your sports car.
Starting ECMAScript6 post series
That sucks, dude. Be well.
Keep in mind that native modules coded against NAN1 do not work with NAN2. Not sure about forward compatibility of NAN.
Number of jobs is only half of the equation though- are the wages of all of those new jobs the same? If automation replaces expensive skilled labor with inexpensive labor than there is still plenty of room for concern.
Which is great, for projects where that kind of upfront waterfall design is sensible.

That's not most projects.
> With static types, refactorings can break your code if not supervised by humans.

The opposite is true, with static typing your code is supervised by the compiler, with dynamic typing you need to rely on humans or runtime errors.
I agree, I think there are many more issues to consider. However, the OP seemed to be focusing on that particular argument, hence my comment. A few examples:

"The results were that the people using the dynamic version of the language got stuff done much quicker"

"it took less time to find those errors [in the statically typed language] than it did to write the type safe code in the first place [in the dynamically typed language]."

"[programs written in]" dynamic languages took significantly less effort to create (less time)"
Unused imports and variables being errors is pretty squarely counter to that philosophy.

I don't think Go represents the "static typing, but lenient" philosophy particularly better than C#, for example, does. Go seems to focus on simple typing, not lenient typing. There's a big difference between the two.
Measuring the digital divide and cats on mars
This is obviously not true. Many (if not most) projects in the Node.js community for example, are made up of hundreds of thousands of lines of dynamically-typed code (mostly npm modules written by other people) and these projects are usually very easy to manage (many Node.js developers wont even realize that they have so much code running behind the scenes because third-party Node.js modules are taken for granted). The secret is breaking everything up into well-defined modules.

I suppose the same can be said about Python and other dynamically typed languages.
>"Since this bias is shared equally by all, it's guaranteed to produce nothing but escalation unless we develop the ability to be a bit more objective and respectful in our arguing."

Do you honestly believe that it is 'us' who will escalate? Or is it them? Does it look like they're looking for anything else? Look at the egregious response to the essays. Yes, i'm sure we are the ones at fault. I guess i'll stop, but you are wrong in a very plain and ordinary way and I think that request was in poor taste.
32 years old, only recently made the connection between poor moods and mental acuity and a series of nights with less than 8 hours sleep. :/
Hey Trevor,

You should check out atlas.co and sign up for the beta for an invite. I'm currently working on this project, and it is exactly aimed at the problem you're describing.

More details:

techcrunch.com/2015/11/24/contextual-search-platform-atlas-is-ivy-softworks-first-spinoff/

www.geekwire.com/2015/innovation-studio-ivy-softworks-unveils-first-product-atlas-search-engine-digital-life/
In countries where gay sex is taboo, Grindr and other apps open a window
This “Blizzard for the Ages” Headed for the East Coast Is the Real Deal
Because fewer people are involved, they can generally make the products to a more predictable standard ("quality") and cheaper. Lets say the item the plant made with all those people used to cost $10 for consumers to buy, but the efficiency improvement from the manufacturing plant now means that it costs $5 for consumers to buy.

All over the town/country/world, people who used to part with $10 now only part with $5. They now have an additional $5 to spend in their community. The manufacturing plant has enabled many others to have their money go further - how is that a bad thing?
> Northern New Hampshire: What are we going to do tonite?

There's a sale on Steam.

(I haven't checked, but there's always a sale on Steam).
I do agree with the arguments here literally, but I think they sound much more forbidding than they should be.

There are plenty of big projects around that could broken into a collection of small, independent projects without any loss.
Ironically, Krugman himself is an Apple fanboy:

http://libertymcg.com/2012/09/20/krugman-the-iphone-why-the-...

No hypocrisy here.
Some place with such incredibly awesome design that this isn't even worth a quick phone chat about a lousy unpaid internship.

Whatever this place is, they must have standards even higher than Apple's or Google's.
You think the rats won't continue to displace other species? And what happens to the rats when there's nothing left to displace? And then what happens to the cats?
among the main drivers to increase street heroin consumption (and thus deaths, etc) was the change in OxyContin formulation so that it became much harder to abuse. It would be ironic if it wasn't that tragic.

http://www.unodc.org/wdr2015/en/opiates.html
X-ray Breakthrough in Controlled Nuclear Fusion
Yet another financial services startup that didn't want to spend the $0 for an SSL certificate...
I wish other REPLs were like this. IPython does it too, but not sure others can.
DHH's is talking about the doctrine of the framework, not random apps built atop the framework.

rubyforge.org has been offline for over a year and a half, as announced over 2 years ago.

You describe a Rails application written by outside consultants that was undeployable, and compare it to apps written by internal Java developers. I believe the quality of the developers had more to do with the deployability than the languages of choice. You could just as easily have a Java application written by consultants, with undocumented JARs, magical PATHs, mystical server.xml's to make things work just right, and crazy ant scripts.
I guess what I was hoping to emphasize is that the number of variables involved in trying to quantify something like this make it difficult (probably impossible) to have an accurate comparison -- even more so when attempting to generalize the results of those comparisons to larger categories of programming languages.
Your company is probably doing it wrong if this guy isn't worth an interview.
When I was pretty young I was a complete and total klutz. Working in actual wires would have quickly degenerated into pathetic flailing for me, but working in a digital world would have been much easier.
Unknown things are to be avoided, until feedback shows that there's no threat, which makes aversion costly. Then simple observing is the lowest cost option until there's fewer novelties. The extra energy expended from interaction is then offset by the gains in feedback. Eventually even that peters out and finding something else to do makes more sense.