Coding: Fleeting Thoughts

[RoadieRich]

Damnit, I knew it was something simple. It's working now, after another couple of minor modifications.

[You, sir, name?]

http://hipstergrammers.tumblr.com/

[Ended]

Facepalm moment of the day: I suddenly found that when I tried to build my program from scratch, it would fail with multiple screenfulls of cryptic error messages. Eventually tried gradually reverting back to the (known good) repository head. Nope, still fails to build!

Spoiler:

In retrospect, some of the error messages should have given it away:

Code: Select all

./list(1): error: this declaration has no storage class or type specifier
./list(1): error: expected a ";"


A while ago I had needed a temporary file to store a list of source files. In what would prove to be an unwise choice, I called the file "list", left it in the compile path, and forgot about it. My tortuous compile process somehow managed to pick this file up instead of the standard library header (even though I only ever included it with angle brackets!).

[phlip]

So cool having another CS nerd in the family... my sister and I spent NYE coding, took a break at midnight to watch the celebrations on TV, and quickly unanimously decided that coding was more entertaining than fireworks, and went back to it.

Anyway, two of the courses she took last year at uni were Assembly, using an emulated toy RISC architecture invented by the lecturer, and Concurrency and Distributed Systems. And she'd always claimed that the two should be combined, making a concurrent version of the toy ASM system... partly because it'd be hilarious and partly because the emulator for the toy system is written in Java, and th lecturer of the concurrency class hates Java with the intensity of a million suns. So today, we did that.

So I now have a very simple, context-switching, non-preemptive, round-robin threaded concurrency system, written in this toy assembly language. And it works, and was fun to write. I'll call that a successful night.

[edit] In case you're curious...

[Ubik]

Finally I have something more complex than a cube or sphere (which was actually just a subdivided and deformed cube) on screen. Here's a screenshot of my desktop. The plane isn't rendered with smoothing yet. That's the next step in implementing my .obj loader.

Edit: Also the file list of the IDE on left, overengineering much?

[headprogrammingczar]

You say it's overengineered now, but wait until you don't know how a project is organized. That tree pane is a lifesaver.

[RoadieRich]

This looks like it could be a lot of fun.

[Xeio]

Code: Select all

if (index == 0 || Other1)
{
}
else if (index == 0 && Other2)
{
}

Er, all the code that would be in that second if statement is dead code, isn't it?

I hate when I run into something like this and it seems so obvious that I must be missing something...

EDIT: Or more annoying, that while I know in its current form I could just delete that code, I wonder if the original author didn't intend it to be such, or if it was just something that didn't get cleaned up when the if logic was altered...

[Yakk]

Does the Other1 code have any side effects?

Ie, index != 0, but Other1 both changes index to 0 and returns false.

Then the second branch can execute.

---

In any case, this is why having things like Blame that gives you a per-line indication of the history of the file is very useful.

[Xeio]

In any case, this is why having things like Blame that gives you a per-line indication of the history of the file is very useful.

Well, in visual studio I can run annotate which does the same thing. It doesn't help much when all the code is over 4 years old and all by the same person.

And no, the others don't have any side effects.

[Yakk]

The change numbers should differ by line. So you look at that line and look at the change in question where the lines where changed. Things get annoying if reformatting passes occurred, but there are usually ways to work around that issue.

[RoadieRich]

Code: Select all

if (index == 0 || Other1)
{
}
else if (index == 0 && Other2)
{
}

Er, all the code that would be in that second if statement is dead code, isn't it?

I hate when I run into something like this and it seems so obvious that I must be missing something...

EDIT: Or more annoying, that while I know in its current form I could just delete that code, I wonder if the original author didn't intend it to be such, or if it was just something that didn't get cleaned up when the if logic was altered...

Because it's in an else block, it only runs if the condition for the first if statement is false and it's own condition is true, that is, if i = 'index==0', on = 'Othern', and x = 'execute the code in block 2:

x = (i ^ o2) ^ ¬(i v o1)

Apply De Morgan's law to the second half, and we get

x = (i ^ o2) ^ ¬i ^ ¬o1

The brackets fall out due to the associative law, and re-arranging for clarity:

x = i ^ ¬i ^ ¬o1 ^ o2

i^¬i=0, and p^0=0, so x=0, meaning yes, that code is dead.

edit: associative law, not commutative - I always get those two mixed up.

[Yakk]

Roadie, that doesn't quite hold, because we aren't coding in a functional language.

If Other1 is an expression like IndexShouldBeCleared(&index), or if index is a member variable, or one of myriad of other reasons, it could easily change index in the first expression to zero (after the index==0 check), and then return false.

We then fall through into the second expression. Index is zero, and it isn't dead code.

This is one of the many ways in which C++ contains some suck.

[Xeio]

This is one of the many ways in which C++ contains some suck.

And it's a pretty good argument against doing variable modification inside of an if statement.

Actually, I think the only time assignment is generally ok in a conditional clause is for a while loop condition. Stuff like reading in the next line while doing a check to make sure it wasn't the end of the file. Anything more complex than that though and I'd be very hesitant to do so, if only for readability.

[TNorthover]

Actually, I think the only time assignment is generally ok in a conditional clause is for a while loop condition. Stuff like reading in the next line while doing a check to make sure it wasn't the end of the file. Anything more complex than that though and I'd be very hesitant to do so, if only for readability.

It can work well in an if statement as well. LLVM uses it for testing whether casts work and making use of the value if so.

[RoadieRich]

Roadie, that doesn't quite hold, because we aren't coding in a functional language.

If Other1 is an expression like IndexShouldBeCleared(&index), or if index is a member variable, or one of myriad of other reasons, it could easily change index in the first expression to zero (after the index==0 check), and then return false.

We then fall through into the second expression. Index is zero, and it isn't dead code.

This is one of the many ways in which C++ contains some suck.

Indeed. Perhaps the answer should be "it doesn't get executed, modulo evil and wrongness."

[Xanthir]

Actually, I think the only time assignment is generally ok in a conditional clause is for a while loop condition. Stuff like reading in the next line while doing a check to make sure it wasn't the end of the file. Anything more complex than that though and I'd be very hesitant to do so, if only for readability.

While I accept that case in languages like C, I believe it shows that the language is lacking the essential feature of an extensible iteration protocol and associated loop structure.

[RoadieRich]

Alternatively, you could call it too extensible.

[troyp]

Applications of Machine Learning in Natural Language Processing

• optical character recognition
• automatic summarization
• spam detection
• classification of sentences into appropriate and inappropriate objects for the rejoinder "That's what she said"^*.

^* This capability should be added to Cleverbot. That chatbot/chatbot conversation would have been even better with this.

[Xeio]

Code: Select all

/// <summary>
/// Adds a num to the list of used nums
/// </summary>
/// <param name="num"></param>
/// <param name="array"></param>
private static void AddNumToList(string num, ref ArrayList array)
{
     //adds num to appropriate list
     array.Add(num);
}

Why not call array.Add(num) directly you ask? I dunno, because it's done like that about 50/50 in the file, I assume because the newer code isn't stupid.

Also, the ref keyword does nothing in this case...

But at least it's commented...?

EDIT: Oh, by the way, those lists use in the calls aren't even needed (one is only added to/cleared and otherwise unreferenced, the other can be replaced by... arbitrarily simple logic).

I thought we used to have a coding rant thread, but I couldn't find it.

EDIT2: Ah, I feel much better doing some damage to the code in that file. It's still far from good but I refactored a lot of crap away and simplified a bunch of logic.

[phlip]

You pointed out most of the horribleness, but still:

Code: Select all

string num

*stab*

[Yakk]

Really? If it is a string containing a number (certainly? probably?), that sounds like a near perfect name for it (maybe a bit short, given how that could confuse someone, but still)

[phlip]

Ordinarily I'd give the benefit of the doubt, and assume that they had a perfectly good reason to be storing numbers as strings... but given the circumstantial evidence...

[Xeio]

Well, the "number" is parsed from a longer string by a framework call, and for some unknown reason isn't parsed into an integer there directly, but I can't guarantee the same person wrote both things so I can only hate them for the code file I was looking at directly.

I replaced the lists with a boolean, since it only used Add, Clear, and "Count > 0" operations, so it didn't really matter what the data type was.

[Dason]

Whyyyyyy doesn't Debian support WPA for their net install. Grrrrrrrrrrrrrrrrrrrr.

[You, sir, name?]

Whyyyyyy doesn't Debian support WPA for their net install. Grrrrrrrrrrrrrrrrrrrr.

Probably licensing reasons. Same reason they ship a terrible and ancient fork of Firefox, rather than something that actually can understand modern web standards.

[headprogrammingczar]

Debian ships with the latest FF code. It's only the name and logo that conflict with Debian's copyright policy. The reason it ships with an old version of FF is their policy on testing vs stable.

[mister_m]

I just got finished with the first ever programming interviews that I ever had. Needless to say, I was quite nervous during the interviews and a little distracted. Both of these companies had me do phone interviews before I came in that I did (I think) fairly well on. i could list some excuses as to why I didn't do too great during the physical interviews, but I think it'd be better to just accept that I was underqualified, and try to become qualified.

I'm still losing sleep over them, as they certainly revealed some weaknesses in my abilities.

[Steax]

Not code, but design, but whatever. A large demo set of various fonts from Google Web Fonts, with only the good (i.e. more-than-incomplete families) fonts presented. Much better for picking fonts than viewing GWF directly.

[PM 2Ring]

Debian ships with the latest FF code. It's only the name and logo that conflict with Debian's copyright policy. The reason it ships with an old version of FF is their policy on testing vs stable.

Looks like a more recent version has finally made it into the stable repo. I've just started the download; I hope it doesn't break anything... * fingers crossed *

[moiraemachy]

So... as somewhat of a noob at coding, I'm learning Python and everything was perfect. Except I stumbled in that "variables as tags, not boxes" thing, and it seems an unnecessary complication. I get it now, but still: why not pointers? The alleged complexity of handling pointers disappears when you have dynamic typing... just make the assignment operation mean "point to this data" when used in a pointer. Am I being stupid?

[joshz]

I mean, so that's not necessarily a bad way to think of python variables. I'm not sure if that's how it's handled in practice for all types, but it does handle many types like that.

For many people, pointers are confusing, so the boxes analogy is popular (or I guess tags too, though I've never heard that before.)

[RoadieRich]

I mean, so that's not necessarily a bad way to think of python variables. I'm not sure if that's how it's handled in practice for all types, but it does handle many types like that.

For many people, pointers are confusing, so the boxes analogy is popular (or I guess tags too, though I've never heard that before.)

I don't know about the actual implentation details, but if you thinking of them as pointers, you won't go too far wrong.

The only time it changes is for new style classes with appropriate magic methods defined, when o.a=x can call o.__setattr__('a', x) or a.__set__(o, x), and o[i]=x, which calls o.__setitem__(i,x), all of which can do just about anything. I don't think it's possible to override the straight a=b, though. The += operator et al, on the other hand...

[troyp]

So... as somewhat of a noob at coding, I'm learning Python and everything was perfect. Except I stumbled in that "variables as tags, not boxes" thing, and it seems an unnecessary complication. I get it now, but still: why not pointers? The alleged complexity of handling pointers disappears when you have dynamic typing... just make the assignment operation mean "point to this data" when used in a pointer. Am I being stupid?

As others have pointed out, variables in Python do work like pointers (or rather references, ie. pointers that are taken and dereferenced automatically). And as you've noticed, these references are untyped - a particular variable can point to any type of data at all. One thing I think I should point out is that this is the essence of dynamic typing. A dynamically typed language is one whose "variables" are untyped references (or at least something similar).

I'm not sure what's confusing you about the "boxes vs tags" explanation: I haven't heard that before. It sounds about right, but "tag" seems subtly misleading to me...I tend to think of Python variables simply as "names" (and names, of course, are the original pointers).

The only time it changes is for new style classes with appropriate magic methods defined, when o.a=x can call o.__setattr__('a', x) or a.__set__(o, x), and o[i]=x, which calls o.__setitem__(i,x), all of which can do just about anything. I don't think it's possible to override the straight a=b, though. The += operator et al, on the other hand...

Yeah, I think it's best to regard attributes and methods as distinct from variables. Assigning a value to a variable has a simple, unambiguous meaning: that the variable name now refers to that object. Assigning a value to an attribute could mean anything.

[PM 2Ring]

So... as somewhat of a noob at coding, I'm learning Python and everything was perfect. Except I stumbled in that "variables as tags, not boxes" thing, and it seems an unnecessary complication. I get it now, but still: why not pointers? The alleged complexity of handling pointers disappears when you have dynamic typing... just make the assignment operation mean "point to this data" when used in a pointer. Am I being stupid?

No, your not being stupid. As an old C (and assembler) programmer, I quite like pointers. But I also like the Python approach of associating names to objects.
Also see Python Question / References and such

[TheChewanater]

Has anyone seen Rust yet?

[b.i.o]

Yes.

[troyp]

I just discovered J is now GPL3!

I'm a bit surprised, I had the impression Jsoftware made a lot of their money selling the source as insurance to companies that were heavily invested in it, so this could cost them - in the short term at least. Although long-term, it's probably a good move: this could really make J the king of the APL family, and the implementation will definitely benefit.

Anyway, I don't care why. I 3> you Jsoftwaaaare.
I am so going to start playing with this again now...

[Jplus]

Has anyone seen Rust yet?

Now I have, thank you.

Is there an online document that explains why this language exists? Because, I don't see any strong advantages over C++.

[b.i.o]

Is there an online document that explains why this language exists? Because, I don't see any strong advantages over C++.

From the GitHub Wiki:

What is this project's goal, in one sentence?
To design and implement a safe, concurrent, practical, static systems language.

I think the differences are in the first two. Rust, unlike C++, deals with memory safety for you, and also has a GC that you can use if you want to. It also has some other interesting things happening like typestates, which, as far as I understand them (not very far), are kind of like compile-time assertions. Rust also has strong built-in support for concurrency. Things are immutable by default, and there's support for message-passing concurrency. (I know there are ways to do concurrency in C++ too, but the whole of the Rust language is designed at the ground up with doing concurrency safely.)