Hacker Newsnew | past | comments | ask | show | jobs | submit | more lambda's commentslogin

So, where is the evidence that it is a handy first approximation? That is, that it makes any kind of testable predictions? Even if they don't always hold, there should be some correlations with some kind of quantifiable metric. So what quantifiable metrics to these personality categories correlate with?


As it happens, he answered exactly this question elsewhere:

https://news.ycombinator.com/item?id=9412144

The MBTI is reasonably well correlated with 4 of the "Big Five" personality traits, which are on good empirical footing.

https://en.wikipedia.org/wiki/Myers%E2%80%93Briggs_Type_Indi...


When Go was first announced in 2009, I thought "this is a nice idea, but I really wish it had generics and non-nullable references". Then Rust was announced a few months later, and I thought "wow, this is what Go should have been."

However, in the intervening time, Rust has diverged farther from Go. It no longer has green threads nor emphasizes message-passing based concurrency. In addition, Go was ready to use much sooner; by having a much simpler type system, and less ambitious concurrency story, Go has been ready to use and build up a library ecosystem for many years now, while Rust is only just now hitting stability to the point where you can write code and not have it break if you don't constantly keep it up to date with the latest nightly.

So, I think that they are both valid strategies. There has been lots of good code written in languages which don't provide as many safety guarantees or as strong a type system as Rust has; it's not an absolute requirement for all code to be written with such guarantees.

By staying simpler and not trying to solve as many problems, Go has been ready for production use for quite a lot longer, and I think that there are many things for which it is still simpler and easier to use.

That said, I do prefer Rust now that it's actually hitting a stable and usable state. I wish it had been ready sooner, but that's the price you pay for needing a lot of time on iterating on how to make these stricter semantics actually usable in practice.


Well, let's also not forget that a big factor in Go's success is Google.

Google has much deeper pockets than Mozilla to build a language and infrastructure.


This meme really should die.

It has never been true so there's nothing to forget.

The number of full-time Rust people paid by Mozilla is roughly the same as number of Go people paid by Google.

Mozilla is a wealthy company and while Google is even more wealthy, it doesn't mean that it spends all its money on Go. Both v8 and Dart are staffed with more people and Dart is not taking off the way Go is.

People are trying to rationalize away the explosive popularity of Go with all sorts explanations, the "it's all because it's Google" being one of them.

The simple explanation is: people use Go because it's a good language. That's the big factor in Go's success.


> Go because it's a good language.

Go fits a niche and is good enough, for now. But Go as a language is seriously flawed, and its flaws will become more and more obvious as the language gets more popular. People can certainly understand Go made the choice of "minimalism". But minimalism doesn't mean the language shouldn't have features people really need. The infamous "You don't need that in Go" sentence will not fly that much longer,especially given how the Go team and community tries to answer Go short comings. The biggest insult to intelligence is that "go generate" feature.It's just embarrassing.

Go for me is a missed opportunity. I still like it but I keep a close eye on alternatives that don't have their core library riddled with "interface{}" like types.

Because there is a need for something simpler and safer than C,that is easily accessible to "script kiddies",that is fast,that has easy concurrency, that compiles to machine code,that has type safety,that isn't tied to windows, in order for people to produce executables that can easily be distributed or concurrent servers.

Whatever language succeeds in that niche will be the biggest language of the next 10/20 years. Mark my words.


> that has type safety

Actually, there is no need for that. Type safety has nothing to do with software being more reliable or more secure. There is, however, a need in language creators, who understand that large standard library with static binaries and cross compilation are super important in a fast moving world where many different operating systems live together on many different architectures.


> Type safety has nothing to do with software being more reliable or more secure.

It is true that type safety doesn't necessarily mean that software is more reliable and secure (it depends on the type system, the semantics of the language, and a host of other things), but saying it has "nothing" to do with it is incorrect. In particular, preventing undefined behavior certainly has an effect on security, whether or not it's through a static type system. As pcwalton has mentioned on several occasions, something like 50% of critical CVEs in Firefox exploited attack vectors that would have been prevented by Rust's type system.


This is where I disagree and believe that such way of thinking about bugs cannot take us anywhere.

Bugs have nothing to do with formal properties of the language. They are the result of people's thinking process. And type system may just as well be the thing someone was dealing with while making his next CVE-worthy mistake.


Factually, Rust's type system guarantees, if consistently upheld, would have eliminated those bugs. Empirically, we know that in typesafe languages like Java, these types of vulnerabilities are far less frequent. These are facts: you cannot "disagree" with them.

Even if we assume that people write buggy code at about the same rate in C++ and Rust, as long as the vast majority of Rust code is not inside an unsafe block, Rust still reaps this benefit, because bugs in safe Rust shouldn't cause memory unsafety.

Finally, yes, bugs do have something to do with formal properties of a language. Really. They do. You can prove that software matches its specification, or fulfills certain properties. People have. SeL4 is a thing. Relying on a static type checker means you only need to trust the static type checker to be correct in order to enforce the appropriate properties, not all code written in the language, and "the Rust type checker" is a much smaller kernel to trust, and will be more widely exercised and heavily scrutinized, than "all other Rust code ever written." This is literally the entire point of static type systems.

I apologize, but this is going to be my last response to you, because I don't think we can have a productive conversation about this.


> Factually, Rust's type system guarantees, if consistently upheld, would have eliminated those bugs.

You are missing my point. It doesn't guarantee to not cause other bugs. And saying that something eliminates some type of bugs is completely misleading, because this is not what matters. It matters to not cause other bugs as well as eliminate some bugs. Which is impossible to guarantee with formal methods. And which is why current academic approach to languages cannot bring us anything, until the whole system changes.

Psychological approach to programming language design is what has to happen. Anything else is broken.


It's impossible to eliminate all bugs, no matter what you do. Psychological design will eliminate some bugs but not all. Static type system will eliminate some bugs, but not all. The best you can do is try to eliminate as many bugs as possible, by doing multiple things that give the best returns, given the bugs you're targeting.


> Actually, there is no need for that. Type safety has nothing to do with software being more reliable or more secure.

If you said this to me in an interview I would politely end the interview there and you would not be hired. A high school student with no programming knowledge at least can be taught. If you're confident in what you just said, you're both ignorant and unteachable.

I really can think of no more scathing indictment of Go than this is the thinking of a typical Go user.


Let's make a small amendment to your simple statement.

>The simple explanation is: people use Javascript because it's a good language. That's the big factor in Javascript's success.

>The simple explanation is: people use PHP because it's a good language. That's the big factor in PHP's success.

Doesn't feel right, does it?

Google and corporate sponsors are incredibly important in building the ecosystem of programming language. Traction may be the single major defining characteristic of language success and one can certainly buy traction with money and influence.


But it's true. Google's association is a big factor in its success. It's not the only reason nor likely the biggest now but it was important at least at the beginning. The fact is that every week we hear about new programming languages. Almost none of them end up being widely used.

Having someone like Google, Mozilla, Apple, Microsoft etc behind it makes a big difference.


It's not so much that Google promotes Go. It's that Google uses Go internally for production code. Thus, the compiler, and the library modules used for web-type services, are thoroughly exercised, and used by in-house people who can insist that bugs be fixed quickly. It took Go far fewer years to achieve stable libraries than, say, Python.


The biggest factor probably was that Rob Pike had basically been prototyping the language for 20 years.

(But google's name certainly helped.)


Not to take anything away from your comment on this being a language that has been brewing for years, but people really should give Robert Griesemer more credit for his influence on the language design.

I know he's the least publically visible of the three, but IIRC godoc and gofmt are mostly his babies. After getting used to those I think I miss them more in other languages than I miss the concurrency.


Well said.

Rob Pike is explicit about early Go development; everything that went into Go was agreed upon by Robert, Ken, and Rob. If all three didn't agree it didn't go in.


But it's not as if they threw a massive amount of manpower or budget at it. I think Go succeeded more by association (to Google) and the fact that it hits a sweet spot for many people - it produces native code, but does not have the complexity of C++ or the unsafety of C.

I have written a fair bit of Go code. But I will switch to Rust without a second though once the ecosystem takes of. The lack of simple things like generics or algebraic data types in Go is jarring.


It is actually linked to from the front page of http://www.rust-lang.org/; it's the "more examples" link under the example. But I guess that's just far enough down to be easy to miss; it's just below the fold on my screen.


Oy: that's just poorly named. I've seen it a million times before, but never would I have thought that "More Examples" would lead to a book.


In part because the "cottage industry" for photographers rights is based on getting people to pay, while most free software authors aren't actually interested in being paid for it, they are just interested in keeping it free. When the focus is on getting paid, a cottage industry can form that is based off the revenue from extracting royalties, but getting injunctions that apply until someone comes in compliance with a license is expensive due to lawyers fees and court costs, without any revenue to offset it.


Nailed it.

Which makes me wonder, perhaps in next iterations the GPL should include provisions stating that intentional infringement (perhaps defined as failure to comply after 1 year from date of the complaint) results in financial penalties, thus allowing a cottage industry to form.

It could be argued that this would have a chilling effect on the adoption rate of FOSS software in corporations, but I would argue we may have already reached a critical mass where it's more costly to develop your own solution and I would point out that this only applies to modifications that you make to the source code before distributing the result. Anyone can still download and use the software without worry.


You don't need an explicit penalty: if you violate the license, it terminates.

Here's the text of the relevant section of the GPLv3 (the GPLv2 only has an equivalent to the first paragraph):

You may not propagate or modify a covered work except as expressly provided under this License. Any attempt otherwise to propagate or modify it is void, and will automatically terminate your rights under this License (including any patent licenses granted under the third paragraph of section 11).

However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation.

Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice.

So, on a second violation of the GPLv3, or on a first violation if it takes longer than 30 days, the rightsholder can already say "You need to pay me if you want your rights reinstated."

Conservancy has been using a variant of this tactic: they get a friendly, clear rightsholder for something like Busybox (which has relatively few authors), inform a company that they're violating the GPL and revoking the Busybox license, and demand GPL compliance for all software, including stuff like Linux which has so many authors that getting a clear rightsholder involved is harder, before reinstating the Busybox license.


Willfull infringement is already a tort; the damages are set by statute at $150,000 (if properly registered etc). You do not need to add any provision to the GPL to go after US violators.

To the extent that doesn't happen means that copyright holders (developers) don't do it. Either because they don't know how, they didn't register in a timely fashion, they don't want to bother, or they don't want money.


Not only is that unnecessary, as laid out in a sibling comment, it would likely be ineffective legally, as you can't simply invent penalties and apply them through a license like that.


The financial penalties are implied. You can prove damages or argue for punitive damages.


But those are not mutually exclusive; they are complementary. It is not very effective to say "Um, stop being a violator pls." It is much more effective to say "Here is your invoice for being a violator, and don't let me catch you again."


I’m pretty sure most free software authors would be interested in being paid for it, if this wasn’t an unsolved problem.

Here’s one attempt at a solution:

https://snowdrift.coop


FWIW, that's a proposed solution to getting free software funded (and, by extension, not funding proprietary stuff), but it isn't a solution directly related to stopping GPL violation.


Because the failure conditions are worse.

Let's see, here are the possibilities:

1. Someone means well, you interpret it as them meaning well and respond accordingly. Everything is fine and dandy, everyone's happy. 2. Someone means well, and you interpret them as meaning ill, and respond accordingly. Now you are angry for no reason, they have had the experience of making a well meaning comment and being shot down for it. Everyone is miserable. 3. Someone means ill, and you interpret it as them meaning ill, and respond accordingly. Now they have gotten the thrill of getting through to you (remember, they mean ill, so that is their intent), and you are angry (for a good reason). You've made yourself miserable and a troll happy. 4. Someone means ill, and you interpret it as them meaning well and respond accordingly. Now they don't get the pleasure of having bothered you, you have shrugged it off an it's not great loss to you. You are now happier than option 3, and they haven't had a chance to hurt you like they meant to.

Of course, real life isn't quite a simple as that; but that does cover a very large number of possible interactions on the internet. By biasing yourself toward the most charitable interpretation of others comments, you reduce the risk of a simple misunderstanding leading to everyone being unhappy, reduce the risk of just giving a troll exactly what they want, and contribute to a more positive environment in general.

It really does help out in an awful lot of cases, and reduces friction dramatically if you always assume good faith unless you have very compelling evidence to the contrary.


Or choose free software. If it's free software, even if the original developer goes away, you can hire someone to keep working on it, or someone else can decide to make a business supporting it, or the like.


Or you just get left with a broken OSS project whose contributors moved on to shinier things, and nobody really much cares about continuing it, and you don't have the knowledge/time/resources to hire someone to do it.


But if the product is already working, chances are that you get away long enough (to do a graceful migration) by just doing small bug fixes, changes to support OS updates, etc.

This is what we are now doing for a project with Berkeley DB XML, which hadn't seen updates for five years. When there finally was an update, it was buggy and moved to the Affero GPL 3, which conflicts with other open source licenses used in the project. So, we continue to use the five year old iteration with a small set of patches.

(Lesson learned: once a product is owned by Oracle, prepare your evacuation plans.)


I was agreeing with the previous posters until I realized this has kind of happened to me. Tastypie was the go-to REST package for Django 3 years ago. Now it has kind of been abandoned and everyone is ranting about Django-REST-Framework.

Fortunately it is stable (for my use cases), and it doesn't actually seem ton be that big a deal that it isn't being worked on. Django_REST_framework is a lot nicer though.


One of the problems you get is that once something is stable, the maintainers generally don't have a huge incentive to dedicate already-over-committed time to work on features they don't personally need. Just triaging tickets on a popular project can be a major time commitment, particularly since a fair percentage of them will be helping people understand the API or trouble-shoot something in their project which is causing failures in your code.

In the case of tastypie, I think all of the maintainers have switched jobs at least once in the last few years and at the same time the general Django community has been moving in the direction of simplicity rather than complex generic frameworks. Daniel's list of things he's not interested in implementing in restless is a good list of things which have been painful in tastypie: https://github.com/toastdriven/restless#anti-features

I've only been a minor contributor but I've increasingly found myself favoring really simple views – roughly https://docs.djangoproject.com/en/1.7/topics/class-based-vie... – since I work almost entirely on read-only public data.

If you or someone you know would like to work on tastypie, we're looking for new maintainers:

http://toastdriven.com/blog/2014/may/23/state-tastypie/

If you have an urgent patch, let me know & I'll see about merging it.


Like I say, it is stable for what I am using it for just now.

I have started using REST framework for other parts of the project, and it seems a lot more consistent with Django's other components (serializers are similar to forms, APIViews are similar to the generic views). In the end that just makes things easier. Its less context switching essentially, which is really useful when I don't touch that part of the project for a few months, then need to update something.

Thanks for the offer though (and thanks for the framework, it has been useful). And unfortunately I don't have the time to help with maintenance.


I'm using Firefox on a Retina MacBook Pro, and I get low-DPI rendering; Chrome also does low-DPI rendering, but with better anti-aliasing. The text rendering looks even worse on Safari; it doesn't even appear to do proper hinting, so the widths of characters come out all uneven, though oddly it seems to antialias the largest text, your name, but not any of the rest of the text.

From worst to best, Safari appears to have inconsistent antialiasing and no hinting, Firefox has no antialiasing, while Chrome looks the best with antialiasing. They all look fairly blurry and out of place.


It's not searchable.

I can't copy and paste text off of it.

It's not accessible; screen readers can't read anything off of it.

It renders at half the DPI of my screen.

At some point, I wound up on a blank screen with no way to go forward or backward to anything but the "create a free website" banner. Haven't reproduced that to give you repro steps, but it happened.

It was frequently janky on my machine; animations would hang occasionally.

It doesn't work at all on my mobile browser (Firefox); I just get a white screen with the banner at the bottom (it did work on Chrome, but the "Back" button was frequently hard to hit).

All of this could be done by animating actual HTML content using JavaScript or CSS animations, in a way that would degrade gracefully for people who couldn't use those for some reason, and which would render at the full DPI of my screen, be copy/pastable, searchable, accessible, and so on.

By the way, the editor on makemake.io is fairly impressive. But it seems like it would be more appropriate for it to edit HTML with JavaScript or CSS animations, or SVG, rather than a custom rendering engine using Canvas.


  How does the data account for variation in development 
  procedures (e.g. some projects use master as their 
  bleeding edge branch)?
That shouldn't matter. You should always be able to successfully check out, build, and pass all tests on master. Otherwise, how are people expected to get development done? If you aren't able to build and run tests because you need to be fixing something that someone else committed broken, it will be a lot harder to ever make real progress.

Even if it's "bleeding edge", master should always build and always pass at least the minimal "fast" test suite; some projects may have more thorough "full" test suites that take many hours to run, and requiring that those be run on every change would slow down development too much, but at the very least, the quick "sanity check" test suite should always pass before something can land on master.


"Researcher" is appropriate for someone who actually produces academic output. It may not be immediately practical, but it consists of new ideas that have been formalized and tested sufficiently to pass peer review of other researchers.

Has the Mill architecture done that? Are there any actual papers about it? Anything beyond marketing fluff?

It seems like there are some ideas behind the Mill that seem interesting when you hear about them, but I haven't seen anything rigorous enough to even be reviewable.

And it doesn't look like that is the intent, either. Rather, from all appearance, it looks like they are trying to drum up interest for investment.


This may just be a semantic quibble, but I'd say that someone that produces academic output (usually in the form of original research) is an "academic", and the academy has it's own peculiar rules for deciding which output has merit.

The Mill stuff is just an example of research taking place outside of the academy.


If you are not producing any academic output, are not producing any commercial output, and are not even producing any patents, all you are producing is high-level handwavy talks, how do you distinguish that from a charlatan?

Ideas in a vacuum are not worth much. I have some random ideas for systems that I think would work better than current systems that people use all the time; stuff I would like to get to some time to develop into something real. However, without actually either rigorously formalizing those ideas and having them reviewed against the current literature, or producing a shipping implementation that demonstrates their feasibility empirically, they're pretty much worth the cost of the paper they are (not) written on.


(sent from a mobile; please pardon the typos)

Detrminatuon of charlatanism and crackpottery is also a function of past performance; no one considers that Shinichi Mochizuki’s proof of the ABC Conjecture is the product of a crackpot, even though people are still working to understand it nearly 3 years hence.

According to the Financial Times:

“Godard has done eleven compilers, four instruction set architectures, an operating system, an object database, and the odd application or two. In previous lives he has been founder, owner, or CEO of companies through several hundred employees, both technical and as diverse as a small chain of Country Music nightclubs and an importer of antique luxury automobiles. Despite having taught Computer Science at the graduate and post-doctorate levels, he has no degrees and has never taken a course in Computer Science.”[1]

Mill may turn out to be another Xanadu. On the other hand, the nice thing about computers is that you can use them to simulate anything, including a better computer (with respect to X), so it's not crazy to think that Mill may have something serious to offer.

Also, Godard sounds a lot like this this guy: http://en.wikipedia.org/wiki/Robert_S._Barton who designed this http://en.wikipedia.org/wiki/Burroughs_large_systems.

[1] http://www.ftpress.com/authors/bio/de5f140d-e5bf-4e83-b020-1...


That is usually a strong crackpot indicator.


It might not work as well as they hope for but there is nothing crackpottery about the Mill so far.

Or, to put it differently, there might be crackpottery in some of the things they haven't revealed yet. Who knows.

(Naturally, this says nothing about whether it will ever actually be built or whether any actual silicon will actually run fast -- there are so many other reasons besides the purely architectural reasons why it might not. Chips are hard.)

A concrete example of something the Mill does better (at least on paper and in a simulator): it does spills and reloads of values differently, in a way that doesn't go through the data caches. The same mechanism also handles local values in many cases. If they don't pollute the data caches, you can get by with smaller and/or higher-latency caches and still get the same (or higher) performance. The loads that are still there on the Mill are those that really have to be there (and are there in the compiler's intermediate representation, before register allocation).

There are also some innovations in the instruction encoding: they can put immediates inline in the instructions, like on the x86 and other Old Skool CISC architectures. They can even do that for quite large immediates. That's better than having to spend several instructions "building" the constants or having to load them at runtime from a table, as the RISC architectures do. They do this with a very regular encoding while keeping the encoding very tight (and variable-width). The way they pack many operations into each instruction means that even if the instructions are byte-aligned, the individual operations don't have to be. If the operations only need 7 bits for their encodings, then that's what you get. (The bit length is fixed per "slot" in the encoding so it's not as variable -- and slow -- as it sounds.)

Instruction decoding and execution is pipelined: the first part of the instruction is decoded first and starts executing while the rest of the instruction gets decoded. This ties in with the way call/return/branch is handled so the last part of the instruction effectively overlaps its execution with decoding and execution of the first part of the instruction at the new site. This works for loops as well so the end of the loop executes overlapped with the start of the loop and so that the prolog/epilog overlaps with the body. You can think of it as a very strong form of branch delay slots -- or as branch delay slots on acid. This is combined with an innovation that allows vectorized loops with very cheap prologs/epilogs so you can opportunistically vectorize practically all your loops. If a loop only executes twice (or thereabouts) you break even.


Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact

Search: