I honestly don't know but I am guessing it is because integers are Python objects, so when an integer constant appears in the source code the interpreter has to get a data structure representing this integer. This would allow methods to be called on the object.

Miscegenation with low-caste Dravidians.

A straight rewrite in a language other than Fortran will very likely make it slower. What language did you have in mind?

A very thorough look at the C64. https://www.youtube.com/watch?v=ZsRRCnque2E

I'd like to see a film of this.

This is why the x32 ABI was created for Linux. https://en.wikipedia.org/wiki/X32_ABI

Because writing a new build system appears easier than learning how to use the existing ones.

Here's one thing:

https://bitbucket.org/weanoob/whorehouse/src/8a9fba4083af2e1397563db509cd7077889b6902/scenes.py?at=master#scenes.py-123

Self-explanatory, really. In other words, it would be easier to understand if you stored this logic in a data structure instead of using "print" statements. But's that's really a very minor point: it's easy to understand as it is.

https://bitbucket.org/weanoob/whorehouse/src/8a9fba4083af2e1397563db509cd7077889b6902/scenes.py?at=master#scenes.py-39

A bit confusing here. You use a global variable to store a list of the scenes, but then you also have a parameter to say which list to use:

https://bitbucket.org/weanoob/whorehouse/src/8a9fba4083af2e1397563db509cd7077889b6902/scenes.py?at=master#scenes.py-205

If you can't create a scene that isn't in the global list, then one wonders what the point of the parameter is.

Generally I don't see global variables as that bad. You'll know that they are bad when you start to get confused by the code.

https://bitbucket.org/weanoob/whorehouse/src/8a9fba4083af2e1397563db509cd7077889b6902/combat.py?at=master#combat.py-13

With global variables like these, one thing you can do to make the code easier to understand is to comment extensively about (a) where the variable is set, and (b) where the variable is read. This way, when you see a function accessing it, you will have a better idea what code set the value of the variable.

https://bitbucket.org/weanoob/whorehouse/src/8a9fba4083af2e1397563db509cd7077889b6902/combat.py?at=master#combat.py-73

Seems a bit strange to use exception handling to know whether the command is recognized or not.

One question is how to read the code. So I see there is an exception here called KeyError. What throws this exception? Is it caught elsewhere? I thought I could look through this file for this KeyError but it only appears twice in the file and neither place gives me a clue. This shows a basic principle of what makes code easy to understand: put stuff near each other in the source code so you don't have to look across many locations in the source code to understand the logic, and when this isn't the case, comments help.

https://bitbucket.org/weanoob/whorehouse/src/8a9fba4083af2e1397563db509cd7077889b6902/combat.py?at=master#combat.py-70

stuff and stuff_split are bad variable names. Maybe input_line and input_arguments or something?

https://bitbucket.org/weanoob/whorehouse/src/8a9fba4083af2e1397563db509cd7077889b6902/combat.py?at=master#combat.py-8

So you have the all_spells variable which you access in a few places in this file. I looked at the spells.py file where the all_spells variable is initialized. But I wasn't sure if spells were added elsewhere as well. I think it would be hard to tell without looking through the rest of the source code.

Probably some information in the links on this page https://news.ycombinator.com/item?id=11506431 that I got the submission from. I don't tend to watch videos though so couldn't say what was in them.

I thought something like that, but tooth is supposed to be h. It isn't t, because t appears twice, even though the two t's aren't next to each other. I think it means the first character that doesn't appear in the string twice.

C version fails for input aba. The code here prints a even though a is a duplicate.

For aabbc, it thinks the answer is b.

Here's my shitty C:

char
first_non_repeating (char *s)
{
        char *p;
        int dup;
           characters with '0'. */
        for (; *s; s++) {
                if (*s == '0') {
                        continue;
                }
                dup = 0; 
                for (p = s + 1; *p; p++) {
                        if (*p == *s) {
                                *p = '0';
                                dup = 1;
                        }
                }
                if (!dup) {
                        return *s;
                }
        }
        return 0;
}
int
main ()
{
        char strings[] = "yellow\0tooth";
        char *s;
        for (s = strings; s < strings + sizeof (strings);
             s += strlen (s), s++) {
                printf ("%s ", s);
                printf ("%c\n", first_non_repeating (s));
        }
}

This guy? OMG. He was responsible for this: https://github.com/opal/opal/issues/941. Makes my blood boil.

I love these, I had one when younger, and still have it!

Just found a link to full paper: https://storage.googleapis.com/deepmind-data/assets/papers/deepmind-mastering-go.pdf

Yes, but can a computer ride a unicycle? Checkmate, atheists.

   je _removenl    ;If they are equal remove the newline
    jmp _main
_removenl:

could jne _main instead.

    jmp _main
_main:

jmp unnecessary.

Here's an article that discusses different meanings of class inheritance: Go and Rust - objects without class.

Dunning-Kruger effect? If someone says they know C++, they likely know less of it than someone who says they partially know C++ but they're worried they don't understand some of the darker areas.

83 submissions to ReportSpammers

Great work!

I know, you want a number, just use an int. I mean, int32_t is more visually complicated - how does using that communicate your intentions any better, either to another person or to the computer?

If you pedantically claim that you should use the largest integer type to avoid the risk of integer overflow, I'll pedantically retort that you should use a bignum library for all of your "int"s.

Who's going to remember what intptr_t actually means? Not me.

I always use -O0 because I got sick of getting value optimized out in gdb.

edit: most of this article is fascist garbage, I'd take it all with a pinch of salt

Use an AdBlock software and turn off JavaScript for all but a few chosen websites and you'll have a better experience.

His last posts on Twitter before he died. Holy crap!

A word of warning: this article is quite old (1999), but most of it appears to be still valid.

LOL well spotted.

Part 2 here: https://lwn.net/Articles/662053/.

I thought that comic was an exaggeration! The point is it's wasteful of network bandwidth to be downloading an entire repository because something broke. Of course it's possible to fix it, it's just reading the manpages to find out how, which would be difficult, depressing and time-consuming.

By restricting the discussion Of this proposal to 1:1 conversations between myself and members of the Community, I hope to better hear everyone’s specific concerns without generating unnecessary noise

Good idea.

An explicit goal of this proposal is to promote cultural diversity within our community and make it more welcoming and inclusive.

Who cares?

Diversity is critical to the project; for Go to become a success, it needs contributors and users from all backgrounds. (See Go, Open Source, Community.)

Uh, no it doesn't. Not really. What it needs is competent people.

If someone takes issue with something you said or did, resist the urge to be defensive. Just stop doing what it was they complained about and apologize.

I knew that would be in there somewhere.

You know, all this stuff is a good idea:

Be friendly and welcoming Be patient Remember that people have varying communication styles, and that not everyone speaks English fluently. Be respectful In particular, respect differences of opinion. Be charitable Interpret the arguments of others in good faith, do not seek to disagree. When we do disagree, try to understand why.

But you know it's a foil for suppression of free speech and affirmative action.

Go was created by Rob Pike and Ken Thompson, wasn't it? Why can't they be dictators of the project? Instead we have this:

Reporting issues

The Code of Conduct Working Group are a group of people that represent the Go community. They are responsible for handling code-related issues. They are:

And a committee of people who'll decide if what you said was inappropriate.

If you encounter a Code of Conduct-related issue, you should report it to the Code of Conduct Working Group using the process described below. Do not post about the issue publicly or try to rally sentiment against a particular individual or group.

This I can agree with. Too often complaints about harassment turn into harassment themselves.

Furthermore, if your conduct outside the Go community is against our values (below), it may affect your ability to participate within our community.

This is a fucking disgrace. It means someone could be excluded from the Go community for voting for the wrong political party, for example!

J responds to D by asking them to "butt out". S emails J privately, noting that J's reaction was uncalled-for, and suggests that J apologize to D.

I might do this myself, although probably wouldn't suggest an apology, I'd just say it was inappropriate. Again keeping this private is the best idea.

Go’s type system is so simple even my grandma could understand it.

Well, it's true that most people's grandmas aren't interested in computer programming.

All in all I don't think that people being rude to each other is that much of a problem in free software or open source. I read a lot of email threads as well and don't see it.

Truth be told I'd never realised that these were obsolete.

Please just fuck off.

If I had a code of conduct for my project, it would be "All are welcome to contribute. Keep conversation technical, and please avoid any political garbage. Anyone trying to harass a contributor for their activities outside of the project, or because they allegedly said something offensive, will be taken out and shot with a hollow-point bullet."

That's just a loop, right?

Even worse:

if (condition) {
  goto do_it;
}
if (condition2) {
  thing1();
  if (condition3) {
    thing2();
do_it:
    thing3();
  }
}

In case that wasn't a rhetorical question, constructs using goto can be equivalent to a tail-recursive function call, and can also be used to simulate a return from a function, and even a return from multiple functions, as with setjmp or exception handling. Usually you wouldn't need this, but it can be useful in a language without coroutines, where you maintain what would be a separate call stack as an explicit data structure. It's also useful in languages without continuations for implementing backtracking algorithms, where you want your program to, in a sense, go back in time. If you're interested in exploring this subject, read Donald Knuth's paper "Structured Programming with Goto Statements", and look into.the Lambda Papers by Steele and Sussman, for example "Lambda the Ultimate GOTO".

Surely all you need is a call stack to implement functions that can be called more than once at a single time?

invariably end up looking like spaghetti to the untrained eye

IIRC the function call procedure in the machine language used by Donald Knuth in his Art of Computer Programming books (MIX) modified the jump instruction at the end of the function to jump back to the function call site.

I guess early compilers for FORTRAN that didn't allow recursion must have done something similar.