1. 2

    Cool stuff, and I like the idea of spurring discussion about academic papers. But… is it intended for computer science papers? It looks like the vast majority of the submissions are in the field of medicine, minus a few more recent submissions. The two fields are different enough, and have a different enough audience, that I’m skeptical that a single site can usefully serve both.

    At very least you’d have to use some very heavy tag filtering.

    1. 2

      It’s intended for any discipline as long as the community is there. That’s why I started with tags that I thought it can start discussions.

    1. 2

      After reading through to the full PDF, I’m unconvinced that the argument it’s making is a good one.

      The context of this is in automated grading of student code projects. If you went through a CS degree, you know the kind: you’re given a function to implement, and your function is graded against a test suite. The instructors have a reference implementation that was presumably used to develop that test suite, and whose outputs are taken as the ground truth reference output.

      Typically, what instructors do is they try to make really thorough test suites based on the assignment spec, and grade students based on whether or not they pass it. This is what the authors call the “axiomatic” method, and it’s the standard for most automated testing in schools. They seem to argue that it’s too kind to the students and that it lets some students pass when they shouldn’t, an assertion that I already find skeptical. (If you want stricter grading, make more thorough and stricter tests.)

      So they say, “Hey, what if we asked the students to make their own test cases, and then added our students’ test cases to our test set? To see whether the tests are viable, we’ll just compare them to our reference implementation, and if the students’ expected test output agrees with our reference implementation, we’ll grade based on that too!” They called this “AlgSing”.

      The problem, and they acknowledge this in the paper, is that the assignment spec might not be 100% complete, and when it comes to an ambiguous case, just because your reference implementation does something doesn’t mean it’s the only possible correct implementation. For example, if you’re creating a binary search tree from a list of numbers, when you find a duplicate number you can always put it in either the left or the right subtree, and it makes no sense to penalize students for making a different arbitrary choice than you. If you blithely incorporate student tests into your test set, you’ll end up being way overzealous in failing student implementations.

      So what they suggest instead, is that in your reference implementation, every time you encounter an ambiguous case, you do both things, and create multiple different reference implementations. Then you can accept only student test cases where all your reference implementations agree with the expected output. They called this “AlgMult”.

      Except that I don’t think this helps much. You’re still potentially grading students on things that were never in the assignment spec, and all you’ve done is to shift the work from writing thorough test cases to writing a thorough set of reference implementations, which is arguably even more work.

      And all for what? For the sake of grading your students harder? That isn’t even a theoretical concern: they tested this on real student assignments, and on every assignment AlgMult failed an equal or greater number of students. In one case it went from labeling 28% of student assignments as faulty to 57%. Nearly double.

      So I don’t see the value in this. It doesn’t look like it saves work for the instructor, and it could easily still end up with students being penalized for bullshit reasons that you never explicitly communicated. There are better ways to fail students.

      1. 7

        Beautiful. I’m a little sad that this is only a spec and not an implementation.

        1. 5

          Looks like there is one in the works.. https://github.com/wolfgang42/rockstar-js

        1. 1

          Could the causality not be in the opposite direction, i.e. more music leading to lower profits, instead of the other way around?

          1. 3

            That demo song is a pretty bad rendition of the Donkey Kong intro theme; it doesn’t even follow a proper beat. Here’s a much better version:

            [:piano {:tempo 130}
             1/8 :c :c 5/8 :a 1/8 :f :g :f
             3/4 :d 1/8 :d :d 5/8 :a# 1/8 :g :a :g
             3/4 :e 1/8 :e :e 5/8 :+c 1/8 :a :a# :+c
             3/4 :+d 1/8 :f :g 5/8 :a 1/8 :e :f :g 3/4 :f]
            
            1. 5

              It’s interesting that this article goes on and on about “needless breach notifications”, but never once touches on the privacy implications of such a feature existing.

              Granted, it’s for business email, where the expectation of privacy is much lower, but still.

              1. 1

                Does anyone know what broken.net used to be? Right now it’s oddly enough just a simple website with the word “hello” and nothing else.

                1. 1

                  Maybe that’s the entire point. It’s a broken implementation of a web server.

                  EDIT: well, after some sleuthing I’ve found that it runs on nginx/1.13.6

                  1. 2

                    But the server works fine, spits out a valid page, HTTP 200 and everything. It’s just that the page is nothing more than literally “hello” in plaintext (not even HTML).

                    1. 4

                      I assume that it’s so reliable that when it breaks, probably the network is broken.

                1. 3

                  For a good laugh, look here at this PR.

                  1. 18

                    It’s both easier and more polite to ignore someone you think is being weird in a harmless way. Pointing and laughing at a person/community is the start of brigading. Lobsters isn’t big enough to be competent at this kind of evil, but it’s still a bad thing to try.

                    1. 6

                      https://github.com/tootsuite/mastodon/pull/7391#issuecomment-389261480

                      What other project has its lead calmly explaining the difference between horse_ebooks and actual horses to clarify a pull request?

                      1. 3

                        And yet, he manages to offend someone.

                        1. 4

                          Can someone explain the controversy here? I legitimately do not understand. Is the individual claiming to be a computer and a person? Or do they just believe that someday some people will be computers and desire to future-proof the messages (as it alluded to in another comment)?

                          1. 7

                            This person is claiming they think of themselves as a robot, and is insulted at the insinuation that robots are not people.

                            Posts like this remind me of just how strange things can get when you connect most of the people on the planet.

                            1. 6

                              So, I tried contacting the author:

                              http://mynameiser.in/post/174391127526/hi-my-name-is-jordi-im-also

                              Looks like she believes she’s a robot in the transhumanist sense. I thought transhumanists thought they would be robots some day, not that they already are robots now.

                              I tried reading through her toots as she suggested, but it was making me feel unhappy, because she herself seems very unhappy. She seems to be going through personal stuff like breaking up from a bad relationship or something.

                              I still don’t understand what is going on and what exactly does she mean by saying she’s a robot. Whatever the reason, though, mocking her is counterproductive and all around a dick thing to do. Her request in the PR was denied, which I think is reasonable. So “no” was said to something, contrary to what zpojqwfejwfhiunz said elsewhere.

                              1. 6

                                As someone who’s loosely in touch with some of the transhumanist scene, her answer makes no sense and was honestly kind of flippant and rude to you.

                                That said, it sounds like she’s been dealing with a lot of abuse lately from the fact that this Github thread went viral. I’m not surprised, because there are certain people who will jump on any opportunity to mock someone like her in an attempt to score points with people who share their politics. In this case she’s being used as a proxy to discredit the social justice movement, because that’s what she uses to justify her identity.

                                Abuse is never okay and cases like this require some pretty heavy moderation so that they don’t spiral out of control. But they also require a pretty firm hand so that you don’t end up getting pulled into every crazy ideascape that the internet comes up with. If I was the moderator of this GitHub thread, I would have told her, “Whatever it is you’re trying to express when you say ‘I am a robot,’ the Mastodon [BOT] flag is not the right way to do it.” End of discussion, and if anyone comes around to try to harass her, use the moderator powers liberally so as not to veer off-topic.

                                Then you could get into the actual meat of the discussion at hand, which was things like “If I have a bot that reposts my Twitter onto Mastodon, could that really be said to ‘not represent a person’? Maybe another wording would be better.”

                                In the end she’s just a girl who likes to say she’s a robot on the internet. If that bugs you or confuses you, the nicest thing you can do is just take it like that and just ignore her.

                                1. 8

                                  I don’t think she was rude to me. She’s just busy with other things and has no obligation to respond to every rando who asks her stuff. I’m thankful she answered me at all. It’s a bit of effort, however slight, to formulate a response for anyone.

                                  1. 3

                                    I mean, I can kind of see where you’re coming from, but I’d still argue that starting with “You should develop your software in accordance to my unusual worldview”, followed by flippantly refusing to actually explain that worldview when politely asked, is at least not nice.

                                    Regardless, that might justify a firm hand, but not harassment, because nothing justifies harassment.

                                    1. 2

                                      I see this point of view too. But I’m also just some rando on the internet. She doesn’t owe me anything, If someone needed to hear her reasons, that would have been the Mastodon devs. They handled it in a different way, and I think they handled it well, overall.

                                      1. 1

                                        I’m inclined to agree on that last point, though it’s hard to say for sure given all the deleted comments.

                                        And I do hope she can work through whatever she’s going through.

                                2. 4

                                  I don’t know, personally, anyone who identifies as a robot, but I do know a bunch of people who identify as cyborgs. Some of it’s transhumanist stuff – embedding sensors under the skin, that sort of thing. But much of it is reframing of stuff we don’t think of that way: artificial limbs, pacemakers, etc, but also reliance on smartphones, google glass or similar, and other devices.

                                  From that standpoint, robot doesn’t seem a stretch at all.

                                  That said, I agree that the feature wasn’t intended to be (and shouldn’t be) a badge. But someone did submit a PR to make the wording more neutral and inclusive, and that was accepted (#7507), and I think that’s a positive thing.

                                  1. 2

                                    Actually, that rewording even seems clearer to me regardless of whether someone calls themself a robot or not. “Not a person” sounds a bit ambiguous; because you can totally mechanically turk any bot account at any time, or the account could be a mirror of a real person’s tweets or something.

                                  2. 1

                                    That’s unfortunate. It’s always difficult to deal with these things. I, too, understood transhumanism to be more of a future thing, but apparently at least some people interpret it differently. Thanks for following up where I was too lazy!

                                  3. -6

                                    American ‘snowflake’ phenomenon. The offendee believes that the rest of the world must fully and immediately capitulate to whatever pronoun they decided to apply to themselves that week, and anything other than complete and unquestioning deference is blatant whatever-ism.

                                    1. 16

                                      Person in question is Brazilian, but don’t let easily checked facts get in the way of your narrative.

                                      1. -5

                                        Thanks for the clarification. Ugh, the phenomenon is spreading. I hope it’s not contagious. Should we shut down Madagascar? :-D

                                        1. 3

                                          TBH I think it’s just what happens when you connect a lot of people who speak your language to the internet, and the USA had more people connected than elsewhere.

                                          1. 0

                                            It definitely takes a lot of people to make a world. To paraphrase Garcia, “what a long strange trip it will be”.

                                      2. 3

                                        She says “she” is a fine pronoun for her.

                                  4. 1

                                    It’s wonderful. :)

                                  5. 3

                                    What is happening there? I can’t tell if this is satire or reality

                                    1. 2

                                      That’s pretty common with Mastodon; there’s an acrid effluence that tinges the air for hours after it leaves the room. That smell’s name? Never saying no to anyone.

                                      1. 12

                                        Seems “never saying no to anyone” has also been happening to lobster’s invite system :(

                                        People here on lobsters used to post links to content they endorse and learn something from and want to share in a positive way. Whatever your motivation was to submit this story, it apparently wasn’t that…

                                        1. 4

                                          The person who shared the “good laugh” has been here twice as long as you have.

                                          1. 1

                                            I’m absolutely not saying you’re wrong, but I’m pretty confident there’s something to be learned here. I may not necessarily know what the lesson is yet, but this is not the first or the last situation of this kind to present itself in software development writ large.

                                    1. 7

                                      So I’m generally in favour of GDPR, but I didn’t know about this requirement:

                                      If you have a business outside of the EU and you collect data on EU citizens, you should assign a representative in one of the member states for your business. This person should handle all issues related to processing. In particular, a local authority should be able to contact this person.

                                      I get where this clause is coming from (it’s hard to enforce laws on people who aren’t in the EU), but this arguably seems like the most difficult part of the law to comply with for small projects, startups, and businesses.

                                      If you even do so much as record IP addresses for traffic monitoring, you’re beholden to GDPR. Many of the other parts of that law (such as having a privacy policy, requiring consent, and allowing for deletion of data on request) are feasible to handle and automate. But this? If I’m reading this right this means that even a small side project or nascent startup hosted in the United States is going to have to hire or contract with someone in the EU for the purposes of satisfying this checkbox.

                                      Am I reading this right?

                                      1. 7

                                        The linked full text of Article 27 does narrow that requirement beyond the general conditions for being subject to GDPR. The narrowing provision is in 2(a).

                                        Rephrased to remove the double-negative and following up references to other articles, my read (as a non-expert, mind you!) is that the mandatory designation of a contact person in the EU only applies if, first of all, your processing of EU citizen data is “on a large scale” (vs. “occasional”), and furthermore includes one of the following three types of sensitive data:

                                        1. “[S]pecial categories of data as referred to in Article 9(1)”. These are defined as “personal data revealing racial or ethnic origin, political opinions, religious or philosophical beliefs, or trade union membership” as well as “the processing of genetic data, biometric data for the purpose of uniquely identifying a natural person, data concerning health or data concerning a natural person’s sex life or sexual orientation”. Article 9 places more stringent requirements on processing this kind of data than the normal GDPR requirements.

                                        2. “[P]ersonal data relating to criminal convictions and offences referred to in Article 10”. Fairly self-explanatory.

                                        3. Data that is otherwise “[likely] to result in a risk to the rights and freedoms of natural persons”. The vaguest of the three, but in context seems likely to mean data that is similar to the kinds of data in #1 and #2. I would guess someone just logging IP addresses wouldn’t fall under this, since the whole provision is about personally sensitive data—stuff along the lines of race, religion, health conditions, criminal convictions, etc.

                                        1. 2

                                          Cool, thanks for the explanation. It’s still a bit vague, but it sounds like this only applies if you’re doing large-scale processing of those more sensitive categories of data, which makes sense.

                                          In general it looks like this was thought through pretty well. Still, I wouldn’t be surprised if you started to see “GDPR contact as a service” companies springing up around Europe in the coming years, for small businesses who accept EU customers but don’t have offices there.

                                      1. 3

                                        I don’t want to stop anyone creating or signing any oath they like, but if I were to sign one with an “honest and moral work” clause then I’d want to be sure that my fellow signers agreed with my view on what comprises moral work.I’m pretty sure that most people here would disagree on which of the following fall under that banner:

                                        • Creating an ad server that uses supercookies
                                        • Building a mashup of airbnb, uber and tinder data
                                        • Writing robocall software for the GOP
                                        • Writing a cryptocoin miner in javascript
                                        • Creating a website to hook Ohmibod users up with patrons
                                        • Writing firmware that misreports emissions data when a car undergoes regulatory testing
                                        • Writing an Android app to teach bump stock modifications
                                        • Adding password decrypt into your service to allow SRE to diagnose user account problems
                                        • Creating a query interface for a database of racial profiles
                                        • Writing a “find my nearest abortion clinic” app
                                        • Employing machine learning during hiring to predict amount of time candidates will take off from work for medical reasons
                                        1. 1

                                          Well said, this is the biggest problem with the oath as it stands. Oaths like these aren’t supposed to just say, “Hey, be Good,” but are supposed to help define what Good looks like. This is especially true when you have a profession like ours where the creation of a software artifact is so far removed from the circumstances in which it might be used.

                                        1. 18

                                          Semi-random side note: Jackson said on twitter that he was really annoyed with this headline: https://twitter.com/ummjackson/status/949313665139802112

                                          1. 3

                                            Thanks. It’s far better to read the original source with all its nuance than to bother with an article that cherry-picks it and presents it as news. This is especially true when the original source is nothing more than three short paragraphs.

                                          1. 30

                                            All of them:

                                            The fact that they exist at all. The build spec should be part of the language, so you get a real programming language and anyone with a compiler can build any library.

                                            All of them:

                                            The fact that they waste so much effort on incremental builds when the compilers should really be so fast that you don’t need them. You should never have to make clean because it miscompiled, and the easiest way to achieve that is to build everything every time. But our compilers are way too slow for that.

                                            Virtually all of them:

                                            The build systems that do incremental builds almost universally get them wrong.

                                            If I start on branch A, check out branch B, then switch back to branch A, none of my files have changed, so none of them should be rebuilt. Most build systems look at file modified times and rebuild half the codebase at this point.

                                            Codebases easily fit in RAM and we have hash functions that can saturate memory bandwidth, just hash everything and use that figure out what needs rebuilding. Hash all the headers and source files, all the command line arguments, compiler binaries, everything. It takes less than 1 second.

                                            Virtually all of them:

                                            Making me write a build spec in something that isn’t a normal good programming language. The build logic for my game looks like this:

                                            if we're on Windows, build the server and all the libraries it needs
                                            if we're on OpenBSD, don't build anything else
                                            build the game and all the libraries it needs
                                            if this is a release build, exit
                                            build experimental binaries and the asset compiler
                                            if this PC has the release signing key, build the sign tool
                                            

                                            with debug/asan/optdebug/release builds all going in separate folders. Most build systems need insane contortions to express something like that, if they can do it at all,

                                            My build system is a Lua script that outputs a Makefile (and could easily output a ninja/vcxproj/etc). The control flow looks exactly like what I just described.

                                            1. 15

                                              The fact that they exist at all. The build spec should be part of the language, so you get a real programming language and anyone with a compiler can build any library.

                                              I disagree. Making the build system part of the language takes away too much flexibility. Consider the build systems in XCode, plain Makefiles, CMake, MSVC++, etc. Which one is the correct one to standardize on? None of them because they’re all targeting different use cases.

                                              Keeping the build system separate also decouples it from the language, and allows projects using multiple languages to be built with a single build system. It also allows the build system to be swapped out for a better one.

                                              Codebases easily fit in RAM …

                                              Yours might, but many don’t and even if most do now, there’s a very good chance they didn’t when the projects started years and years ago.

                                              Making me write a build spec in something that isn’t a normal good programming language.

                                              It depends on what you mean by “normal good programming language”. Scons uses Python, and there’s nothing stopping you from using it. I personally don’t mind the syntax of Makefiles, but it really boils down to personal preference.

                                              1. 2

                                                Minor comment is that the codebase doesn’t need to fit into ram for you to hash it. You only need to store the current state of the hash function and can handle files X bytes at a time.

                                              2. 14

                                                When I looked at this thread, I promised myself “don’t talk about Nix” but here I am, talking about Nix.

                                                Nix puts no effort in to incremental builds. In fact, it doesn’t support them at all! Nix uses the hashing mechanism you described and a not terrible language to describe build steps.

                                                1. 11

                                                  The build spec should be part of the language, so you get a real programming language and anyone with a compiler can build any library.

                                                  I’m not sure if I would agree with this. Wouldn’t it just make compilers more complex, bigger and error prone (“anti-unix”, if one may)? I mean, in some cases I do appriciate it, like with go’s model of go build, go get, go fmt, … but I wouldn’t mind if I had to use a build system either. My main issue is the apparent nonstandard-ness between for example go’s build system and rust’s via cargo (it might be similar, I haven’t really ever used rust). I would want to be able to expect similar, if not the same structure, for the same commands, but this isn’t necessarily given if every compiler reimplements the same stuff all over again.

                                                  Who knows, maybe you’re right and the actual goal should be create a common compiler system, that interfaces to particular language definitions (isn’t LLVM something like this?), so that one can type compile prog.go, compile prog.c and compile prog.rs and know to expect the same structure. Would certainly make it easier to create new languages…

                                                  1. 2

                                                    I can’t say what the parent meant, but my thought is that a blessed way to lay things out and build should ship with the primary tooling for the language, but should be implemented and designed with extensibility/reusability in mind, so that you can build new tools on top of it.

                                                    The idea that compilation shouldn’t be a special snowflake process for each language is also good. It’s a big problem space, and there may well not be one solution that works for every language (compare javascript to just about anything else out there), but the amount of duplication is staggering.

                                                    1. 1

                                                      Considering how big compilers/stdlibs are already, adding a build system on top would not make that much of a difference.

                                                      The big win is that you can download any piece of software and build it, or download a library and just add it to your codebase. Compare with C/C++ where adding a library is often more difficult than writing the code yourself, because you have to figure out their (often insane) build system and integrate it with your own, or figure it out then ditch it and replace it with yours

                                                    2. 8

                                                      +1 to all of these, but especially the point about the annoyance of having to learn and use another, usually ad-hoc programming language, to define the build system. That’s the thing I dislike the most about things like CMake: anything even mildly complex ends up becoming a disaster of having to deal with the messy, poorly-documented CMake language.

                                                      1. 3

                                                        Incremental build support goes hand in hand with things like caching type information, extremely useful for IDE support.

                                                        I still think we can get way better at speeding up compilation times (even if there’s always the edge cases), but incremental builds are a decent target to making compilation a bit more durable in my opinion.

                                                        Function hashing is also just part of the story, since you have things like inlining in C and languages like Python allow for order-dependent behavior that goes beyond code equality. Though I really think we can do way better on this point.

                                                        A bit ironically, a sort of unified incremental build protocol would let compilers avoid incremental builds and allow for build systems to handle it instead.

                                                        1. 2

                                                          I have been compiling Chromium a lot lately. That’s 77000 mostly C++ (and a few C) files. I can’t imagine going through all those files and hashing them would be fast. Recompiling everything any time anything changes would probably also be way too slow, even if Clang was fast and didn’t compile three files per second average.

                                                          1. 4

                                                            Hashing file contents should be disk-io-bound; a couple of seconds, at most.

                                                            1. 3

                                                              You could always do a hybrid approach: do the hash check only for files that have a more-recent modified timestamp.

                                                            2. 1

                                                              Do you use xmake or something else? It definitely has a lot of these if cascades.

                                                              1. 1

                                                                It’s a plain Lua script that does host detection and converts lines like bin( "asdf", { "obj1", "obj2", ... }, { "lib1", "lib2", ... } ) into make rules.

                                                              2. 1

                                                                Codebases easily fit in RAM and we have hash functions that can saturate memory bandwidth, just hash everything and use that figure out what needs rebuilding. Hash all the headers and source files, all the command line arguments, compiler binaries, everything. It takes less than 1 second.

                                                                Unless your build system is a daemon, it’d have to traverse the entire tree and hash every relevant file on every build. Coming back to a non-trivial codebase after the kernel stopped caching files in your codebase will waste a lot of file reads, which are typically slow on an HDD. Assuming everything is on an SSD is questionable.

                                                              1. 2

                                                                I cracked the first password with “AATFDAFD”. The second disk had password “HGFIHD” and the third had “AAJMAKAY”. Apparently random strings were popular passwords back then.

                                                                I suspect these are acronyms or something similar rather than random strings. The last one, for example: it ends in AKAY… as in A. Kay, as in Alan Kay? It’s hard to tell what the first part of the password was since the first two characters were lost.

                                                                1. 3

                                                                  Author response:

                                                                  I should mention that I didn’t want to leak someone’s actual password (even if it’s 40 years old), so I perturbed the passwords slightly. The real password doesn’t exactly end in AKAY, so it’s not Alan Kay. (Apologies for throwing cold water on your clever idea.)

                                                                  1. 1

                                                                    When I first read it (before realizing the author slightly messed them up) I figured AATFDAFD was just easy to type with your left hand on a QWERTY keyboard - a mechanical rather than logical password. Try it!

                                                                    But now I see from Doug Wyatt’s comment that it is an inside joke.

                                                                  1. 1

                                                                    Neat article. I’m going to add “midnight always happens once per day” to my mental list of “falsehoods programmers believe about time”.

                                                                    1. 4

                                                                      Chollet’s arguments read like pop sci handwaving while Yudkowsky’s rebuttal is pleasantly rigorous.

                                                                      On a related note, I often observe two huge cognitive failures around big issues like climate change or AI.

                                                                      One is in assessing possibilities and risks. AI explosion may not be probable but the risk is that it’s possible, and the potential negative consequences are huge, so caution is definitely warranted. Yet many people hasten to deny the possibility altogether by using weak or totally irrational justifications.

                                                                      The other is a failure to grasp non-linear effects or insistence on linear behaviour contrary to evidence (eg Chollet seems to be asserting that progress can only ever be linear, without really substantiating).

                                                                      1. 6

                                                                        climate change is a much bigger threat, because it’s super risky and super likely (certain, even).

                                                                        Apart from that, I’m not very convinced by the rebuttal. I still don’t believe in exponential curves in nature (the GDP? recent notion, moving target, not even clear what it measures). Progress in science becomes slower whenever a field matures; good luck making breakthroughs in areas of maths that are 2 centuries old. It should be the same for an hypothetical self-improving AI: it’s smarter, but making something even smarter is also much more difficult, so in the end it’s all about diminishing returns.

                                                                        1. 2

                                                                          Totally agree about climate change. What I was trying to say is: even if one takes the position that the worst effects of climate change have very low probability (contrary to established science), the consequences are so grave that action has to be taken regardless. But this obvious conclusion is lost on many people for some bizarre reason.

                                                                          It’s a similar story with AI. As soon as we establish that there is a possibility of superintelligent self-improving AI, we have to understand that there are huge risks associated with that, and have to proceed with caution rather than burying heads in sand.

                                                                          To your points:

                                                                          • I think the important thing is not to be convinced by the proponents of intelligence explosion, but rather to recognise that nobody has proof that it’s impossible.
                                                                          • We don’t need to find exponential processes in nature, because we’re not talking about a naturally occurring process (and it wouldn’t prove anything one way or another, anyway).
                                                                          • Progress in science, I believe, is pretty much impossible to measure, and I’m not sure that it has much relation to self-improving intelligence.

                                                                          Somewhat tangential to this discussion: for the purposes of assessing the risk of AI, it’s useful to take a broader perspective and realise that AI, in fact, doesn’t need to exceed human intelligence or be an autonomous agent to cause a lot of problems. In this context, arguments about the possibility of intelligence explosion are a distraction.

                                                                          1. 1

                                                                            As soon as we establish that there is a possibility of superintelligent self-improving AI, we have to understand that there are huge risks associated with that, and have to proceed with caution rather than burying heads in sand.

                                                                            That’s like calling for planetary defences against an alien invasion because the discovery of unicellular life on Mars is imminent.

                                                                            We don’t have strong AI. The pattern matching we call “AI” right now is nowhere near that, yet we are supposed to believe that the qualitative jump is imminent. I’ll go with the voice of reason on this one.

                                                                            1. 2

                                                                              This piece on when technological developments are worth worrying about was a nice read on the issue. Not sure I’m convinced, but it’s at least taking seriously the question of whether anyone should care yet.

                                                                              1. 1

                                                                                But how do you determine what the voice of reason is? There are many reasonable people advising caution it seems. Are you sure you’re not going with comforting beliefs rather than reason?

                                                                                1. 1

                                                                                  But how do you determine what the voice of reason is?

                                                                                  By the amount of changes of past mechanisms needed to fulfil the prophesied future and my own knowledge of medicine and software engineering.

                                                                                  1. 1

                                                                                    It’s not quite clear to me why expertise in medicine or software engineering is relevant to forming a reasoned position on intelligence explosion. (Let me know?)

                                                                                    I guess you might instead be referring to expertise in machine learning, AI, and neuroscience, in which case I’d love to learn your reasoning for why it’s impossible for intelligence explosion to occur (as long as it’s more substantial than reasoning by analogy, historical or otherwise).

                                                                          2. 2

                                                                            Got a link to the rebuttal?

                                                                          1. 5

                                                                            I feel bad saying this (I really do), but I can’t help shake the feeling that the true motive of the author was to market his game via this story.

                                                                            The world is filled to overflowing with failed business ventures. I’m not sure this one is particularly different or insightful or noteworthy.

                                                                            1. 4

                                                                              I actually found this perspective pretty interesting – the bar for success seemed really low. 300 sales to survive, 700 to stay in business? That’s what, between $1500 and $3500 after Steam’s cut and before taxes? In that light it’s actually kind of depressing how hard it is to even make a splash.

                                                                              1. 1

                                                                                the bar for success seemed really low. 300 sales to survive, 700 to stay in business?

                                                                                For a single-person business that seems reasonable. Compare with the “Manabi line”.

                                                                                In that light it’s actually kind of depressing how hard it is to even make a splash.

                                                                                There are just so many games out there though. Average sales are always going to equal number of users * number of games per user / number of games on sale. And there are so many people who want to make games.

                                                                              2. 3

                                                                                As I talked about above, I do think it’s worth talking about these kinds of situations. There are a lot of young people interested in games who would love to get into game development, there are a lot of colleges advertising their game-making programs and talking about how it’s such a great and fun career, and there’s a lot of attention given to the successful stories in indie development. Failure stories like these get told a lot less often, even though they’re likely the more typical scenario. If we don’t talk about them, we don’t give the people considering doing indie game development a clear picture of the risk involved.

                                                                                As for the marketing aspect, I can’t say whether that was his primary motive, but well, hey, I’m sure it doesn’t hurt.

                                                                              1. 4

                                                                                This is why I personally stopped focusing on game development. As a hobby it’s great, but it’s very hard to make a stable career as an indie. Technical skills don’t differentiate you anymore with the explosion of great free game-making tools either. What really sets you apart is your ability to market your game, and that’s not my core skill set.

                                                                                Remember: for every story you read like this, there are dozens, maybe hundreds of others that you don’t. Almost nobody gives interviews to the “losers” in the indie market.

                                                                                1. 2

                                                                                  The problem is that the game sucks.

                                                                                  The key to a good game is actually arts and game design, not technical aspect, unless you are doing something completely game-changing like quake did.

                                                                                  Why did he choose the grid-system ala eye of the beholder? I’m pretty sure this choice derived from table-top dnd back in the day and that choice is because it makes it easier to realise the mechanics of the game with pen and paper. It’s just awkward on a pc.

                                                                                  Besides that, what is to differentiate this game from other roguelike dungeon crawling games for which there are many really good ones? The fact that monsters can also pick up items? wow. such inspired.

                                                                                  What really sets you apart is your ability to market your game

                                                                                  I have to disagree here. Game discovery is at an all time high and I think there has been no better time than now for the better games to rise to the top. Gamers are so connected via social media, reddit, youtube etc that if your game is actually good people will find out.

                                                                                  1. 4

                                                                                    I mean, I’m not going to argue that the game was great. To be honest, I didn’t even research the game itself.

                                                                                    But this is a story I’ve seen multiple times now, and even been a part of personally (though to a less tragic extent, since I was too hesitant to jump in with both feet the way this guy did). A game can’t just be good, it has to be great, in a unique way, in order to stand out.

                                                                                    The point I was trying to make when talking about the technical aspects is that back around 10 years ago, when a game like World of Goo was considered to be the pinnacle of the indie game scene, there were very few good game-making tools available, especially free ones. You pretty much had to either write your own engine, or buy one from the smaller market of game-making tools available for you. And most of those tools only did 2D games. This meant that indie games back in the day tended to have to roll a lot more of their own technology, and that created a much higher barrier to entry.

                                                                                    These days, with the proliferation of great game-making tools, most of them free, that aspect is a lot easier. Don’t get me wrong, I think this is a good thing overall, since it allows a lot more people to make games and has led to a Cambrian explosion of new mechanics, new ideas, and even new genres. But on the developer’s side, that makes it much harder to stand out above the noise.

                                                                                    And sure, discovery and discussion is easier. But mediums like that are awash with a lot of noise as well. Steam alone had 837 games last month. Why should people talk about yours?

                                                                                    Marketing isn’t just advertisements and press releases, it’s fundamentally about answering the question I just asked. Understanding the market, and making something unique that it’ll stand out, is also good marketing. But with so much stuff available, doing that is hard.

                                                                                    The point is that indie game development is risky business, and that the risk is far beyond what people might expect. Even just selling a few hundred or few thousand copies, in order to break even, can be difficult. You could easily come out with a game and have it sell next-to-nothing.

                                                                                    That’s ultimately the moral that people should be taking from stories like this. They’re cautionary tales that don’t get told nearly often enough.

                                                                                1. 2

                                                                                  Why does the option have a -unknown-unknown suffix?

                                                                                  1. 14

                                                                                    Compilers often consider their target as a triplet in the form machine-vendor-os, such as x86-pc-linux, which would describe a compiler targeting x86 IBM compatible machines running Linux. In the case of webasm, the machine target is webasm, but the vendor/OS are irrelevant and not known at compile time.

                                                                                    1. 3

                                                                                      Thanks for the clear explanation :)

                                                                                      1. 2

                                                                                        The Rumsfeld of platforms?

                                                                                    1. 3

                                                                                      Pretty cool, but the error message could be worded a little more clearly for the application developer.

                                                                                      1. 3

                                                                                        This may be due to my familiarity with pthreads and C++ mutexes, but this error honestly was lucid for me. Could you give me an idea what you wish the error would say?

                                                                                        1. 7

                                                                                          pthread_mutex_destroy on mutex with waiters!

                                                                                          Random sampling of thoughts that a novice might think about this:

                                                                                          • “What is pthread_mutex_destroy? I’m not calling that in my code.”
                                                                                          • “What’s a ‘waiter’? It sounds like I’m in a restaurant.”
                                                                                          • “That pthread thing is “on mutex”? What does it mean by “on mutex”? (I know it means “called on a mutex”, but it omits enough words to not only be unclear about this but to also be grammatically incorrect.)
                                                                                          • “What do I even do about this message? Is it even a bad thing?”

                                                                                          Here’s a sample error message that would get it across much more clearly:

                                                                                          Warning: program terminated while a mutex was still locked.

                                                                                          Or, if the error message isn’t limited to program termination:

                                                                                          Warning: a mutex was destroyed while it was still locked.

                                                                                          You could also add some informational text to tell the programmer what to look for:

                                                                                          Please ensure that all mutexes are unlocked before they are destroyed.

                                                                                          I know when you’re programming, and you’re deep in the context of a particular system like pthreads, it’s really easy to just throw an error message into stderr that relies heavily on the specific keywords for that context. But the people who’ll see that message won’t necessarily have that context. They could be seeing it somewhere else entirely, working on a far higher level system. It’s worth keeping that in mind.

                                                                                          1. 8

                                                                                            “What’s a ‘waiter’? It sounds like I’m in a restaurant.”

                                                                                            That’s a reach. If you’re programming with mutexes, you know what “waiting on a mutex” is, and “waiters” is pretty obvious from that.

                                                                                            “That pthread thing is “on mutex”? What does it mean by “on mutex”? (I know it means “called on a mutex”, but it omits enough words to not only be unclear about this but to also be grammatically incorrect.)

                                                                                            I think error-message-ese, like headline-ese, is a distinct enough form of expression to have its own rules, given how much priority is given to brevity in error messages.

                                                                                            “What do I even do about this message? Is it even a bad thing?”

                                                                                            In the spirit of the above: In error-message-ese, an exclamation point means it’s a bad thing, or at least highly unusual.

                                                                                          2. 3

                                                                                            I find the specific wording a tiny bit confusing because in the specific example given in the article here, no thread is actually blocked waiting on the lock when it’s destroyed - one holds it, but none are blocked.

                                                                                            Totally a nitpick though.

                                                                                        1. 10

                                                                                          While I’m kind of indifferent to the language itself, those detailed error messages and the --explain command-line flag make me salivate. More programming languages should try to strive for that level of detail where possible.