www.digitalmars.com         C & C++   DMDScript  

digitalmars.D.learn - string comparison

reply doubleagent <doubleagent03 gmail.com> writes:
Andrei's quick dictionary illustration [in his book, 'The D Programming
Language'] doesn't seem to work.  Code attached.

On my computer, with d2-0.5.0, I got the following output while testing.

andrei
0	andrei
 andrei
1	andrei


Also, why doesn't 'splitter' show up on the site's documentation of
std.string?  And what advantage does 'splitter(strip(line))' offer over
'split(line)'?
Dec 18 2010
next sibling parent reply doubleagent <doubleagent03 gmail.com> writes:
Compared to the relatively snappy response other threads have been receiving I'm
going to assume that nobody is interested in my inquiry.

That's cool.  Can anybody point me to an IRC chatroom for D noobs, and is there
anywhere to post errata for the book?
Dec 19 2010
next sibling parent reply Stanislav Blinov <blinov loniir.ru> writes:
20.12.2010 8:35, doubleagent пишет:
 Compared to the relatively snappy response other threads have been receiving
I'm
 going to assume that nobody is interested in my inquiry.

 That's cool.  Can anybody point me to an IRC chatroom for D noobs, and is there
 anywhere to post errata for the book?

may seem that people are active in other threads doesn't mean they are fast enough to analyse arising questions and problems while discussing some recent ideas and improvements and not forgetting to work and sleep ;) Besides, there are many people here from different parts of the world, different time zones. And lastly, hasn't this by chance been your first post? AFAIR, the first message is being moderated so it doesn't get to the public at once. BTW, There is a #D channel on freenode, if my memory serves.
Dec 20 2010
parent doubleagent <doubleagent03 gmail.com> writes:
I understand.  Thank you, and thanks for pointing out the chatroom.
Dec 20 2010
prev sibling next sibling parent "Steven Schveighoffer" <schveiguy yahoo.com> writes:
On Mon, 20 Dec 2010 00:35:53 -0500, doubleagent <doubleagent03 gmail.com>  
wrote:

 Compared to the relatively snappy response other threads have been  
 receiving I'm
 going to assume that nobody is interested in my inquiry.

Just a tip, don't expect snappy responses on Sunday... We all have lives you know ;) I for one usually have my computer that I do D stuff with off for most of the weekend. -Steve
Dec 20 2010
prev sibling next sibling parent "Steven Schveighoffer" <schveiguy yahoo.com> writes:
On Mon, 20 Dec 2010 11:13:34 -0500, Stanislav Blinov <blinov loniir.ru>  
wrote:

 And lastly, hasn't this by chance been your first post? AFAIR, the first  
 message is being moderated so it doesn't get to the public at once.

BTW, this message board is not moderated. -Steve
Dec 20 2010
prev sibling next sibling parent "Steven Schveighoffer" <schveiguy yahoo.com> writes:
On Mon, 20 Dec 2010 14:05:56 -0500, Steven Schveighoffer  
<schveiguy yahoo.com> wrote:

 On Mon, 20 Dec 2010 11:13:34 -0500, Stanislav Blinov <blinov loniir.ru>  
 wrote:

 And lastly, hasn't this by chance been your first post? AFAIR, the  
 first message is being moderated so it doesn't get to the public at  
 once.

BTW, this message board is not moderated.

I should clarify, it's retroactively moderated :) That is, if spam appears, it's allowed to go through, but then removed once discovered. -Steve
Dec 20 2010
prev sibling next sibling parent "Steven Schveighoffer" <schveiguy yahoo.com> writes:
On Tue, 21 Dec 2010 11:12:00 -0500, Stanislav Blinov <blinov loniir.ru>  
wrote:

 20.12.2010 22:06, Steven Schveighoffer пишет:
 On Mon, 20 Dec 2010 14:05:56 -0500, Steven Schveighoffer  
 <schveiguy yahoo.com> wrote:

 On Mon, 20 Dec 2010 11:13:34 -0500, Stanislav Blinov  
 <blinov loniir.ru> wrote:

 And lastly, hasn't this by chance been your first post? AFAIR, the  
 first message is being moderated so it doesn't get to the public at  
 once.

BTW, this message board is not moderated.

I should clarify, it's retroactively moderated :) That is, if spam appears, it's allowed to go through, but then removed once discovered.

... Your mail to 'Digitalmars-d-learn' with the subject Re: hijacking a class's members Is being held until the list moderator can review it for approval. The reason it is being held: Post to moderated list Either the message will get posted to the list, or you will receive notification of the moderator's decision. If you would like to cancel this posting, please visit the following URL: ... I should note that I post via mailing list, so maybe this is the catch.

Hm... I always use a newsgroup client, so maybe. But in any case, I've never known anyone to have been blocked from posting, and the newsgroup interface does not have any moderation on it. I'd be surprised if anyone with the ability to moderate spends any time moderating the newsgroup. That might be a canned message. -Steve
Dec 21 2010
prev sibling parent spir <denis.spir gmail.com> writes:
On Tue, 21 Dec 2010 11:49:42 -0500
"Steven Schveighoffer" <schveiguy yahoo.com> wrote:

 Hm... I always use a newsgroup client, so maybe.  But in any case, I've =

 never known anyone to have been blocked from posting, and the newsgroup =

 interface does not have any moderation on it.  I'd be surprised if anyone=

 with the ability to moderate spends any time moderating the newsgroup.

Mailing list neither (never got any moderation message). Denis -- -- -- -- -- -- -- vit esse estrany =E2=98=A3 spir.wikidot.com
Dec 21 2010
prev sibling next sibling parent reply Jonathan M Davis <jmdavisProg gmx.com> writes:
On Saturday 18 December 2010 23:01:30 doubleagent wrote:
 Andrei's quick dictionary illustration [in his book, 'The D Programming
 Language'] doesn't seem to work.  Code attached.
 
 On my computer, with d2-0.5.0, I got the following output while testing.
 
 andrei
 0	andrei
  andrei
 1	andrei
 
 
 Also, why doesn't 'splitter' show up on the site's documentation of
 std.string?  And what advantage does 'splitter(strip(line))' offer over
 'split(line)'?
 begin 644 dictionary.d
 M:6UP;W)T('-T9"YS=&1I;RP <W1D+G-T<FEN9SL*"G9O:60 ;6%I;B I('L*
 M"75I;G1;<W1R:6YG72!D:6-T:6]N87)Y.R`O+R!V6VM=+"!S;R!S=')I;F<M
 M/G5I;G0*"69O<F5A8V  *&QI;F4[('-T9&EN+F)Y3&EN92 I*2![" D)+R\ 
 M8G)E86L <V5N=&5N8V4 :6YT;R!W;W)D<PH)"2\O($%D9"!E86-H('=O<F0 
 M:6X =&AE('-E;G1E;F-E('1O('1H92!V;V-A8G5L87)Y" D)9F]R96%C:"`H
 M=V]R9#L <W!L:71T97(H<W1R:7`H;&EN92DI*2![" D)"6EF("AW;W)D(&EN
 M(&1I8W1I;VYA<GDI(&-O;G1I;G5E.R`O+R!N;W1H:6YG('1O(&1O" D)"6%U
 M=&\ ;F5W260 /2!D:6-T:6]N87)Y+FQE;F=T:#L*"0D)9&EC=&EO;F%R>5MW
 M;W)D72`](&YE=TED.PH)"0EW<FET969L;B B)7-<="5S(BP ;F5W260L('=O
 .<F0I.PH)"7T*"7T*?0H`
 `
 end

Whatever you did to attach your code, it just comes up as gibberish to me. The errata page is here: http://erdani.com/tdpl/errata/index.php?title=Main_Page I have no idea what example you're looking at, or what the problem is. There are some examples in the book which are not 100% correct (most, if not all of them, are in the errata) and a few which don't work yet due to bugs in dmd or features which are not completely implemented yet (e.g. currently, you can only have one alias this per class/struct, but TDPL says that you can have multiple). The reason that std.string.splitter() does not show in the documentation is that its return type is auto, and there is currently a bug in ddoc that makes it so that auto functions don't end up in the generated documentation. Looking at the code, it pretty much just forwards to std.algorithm.splitter() using whitespace as its separator, so you can look at the documentation there if you'd like. Looking at the code for std.algorithm.splitter(), I'd say that the main advantage of splitter() over split() is that it generates a lazy range. So, if you don't want to process the whole range or if you don't want to use as much memory by having to duplicate the entire range that you passed to split()/splitter(), then you'd use splitter(). split() does have the advantage that it gives you an array, so you don't have to use std.array.array() if you want an array, like you'd have to do with splitter(). Overall, splitter() is more generic. split() is specific to std.string, and std.string has a version of splitte() presumably so that there is a version which matches up with split()'s behavior. - Jonathan M Davis
Dec 19 2010
parent doubleagent <doubleagent03 gmail.com> writes:
 The reason that std.string.splitter() does not show in the documentation is
that
 its return type is auto, and there is currently a bug in ddoc that makes it so
 that auto functions don't end up in the generated documentation. Looking at the
 code, it pretty much just forwards to std.algorithm.splitter() using whitespace
 as its separator, so you can look at the documentation there if you'd like.

Thanks. The code was pretty self-explanatory but it's helpful to know that auto functions currently don't get documented.
Dec 20 2010
prev sibling next sibling parent "Denis Koroskin" <2korden gmail.com> writes:
Check your client setting, everything is perfect on my side (Opera  
built-in news client).
Dec 19 2010
prev sibling next sibling parent reply "Lars T. Kyllingstad" <public kyllingen.NOSPAMnet> writes:
On Sun, 19 Dec 2010 07:01:30 +0000, doubleagent wrote:

 Andrei's quick dictionary illustration [in his book, 'The D Programming
 Language'] doesn't seem to work.  Code attached.

That's strange. I ran the example you posted using DMD 2.050 myself, and it works for me. Are you 100% sure that you are running this version, and that it is not using an outdated Phobos version (from an older installation, for instance)? One suggestion: Try replacing the next-to-last line with this: dictionary[word.idup] = newId; The 'word' array is mutable and reused by byLine() on each iteration. By doing the above you use an immutable copy of it as the key instead.
 On my computer, with d2-0.5.0, I got the following output while testing.
 
 andrei
 0	andrei
  andrei
 1	andrei
 
 
 Also, why doesn't 'splitter' show up on the site's documentation of
 std.string?  And what advantage does 'splitter(strip(line))' offer over
 'split(line)'?

splitter is defined in std.algorithm. The fact that it becomes visible when you import std.string is due to bug 314: http://d.puremagic.com/issues/show_bug.cgi?id=314 (std.string is supposed to publically import just a few symbols from std.algorithm, but because of this bug the whole module gets imported publically.) The advantage with splitter is that it is lazy and therefore more efficient. split() is eager and allocates memory to hold the string fragments. -Lars
Dec 20 2010
next sibling parent Jonathan M Davis <jmdavisProg gmx.com> writes:
On Monday, December 20, 2010 06:01:23 Lars T. Kyllingstad wrote:
 On Sun, 19 Dec 2010 07:01:30 +0000, doubleagent wrote:
 Andrei's quick dictionary illustration [in his book, 'The D Programming
 Language'] doesn't seem to work.  Code attached.

That's strange. I ran the example you posted using DMD 2.050 myself, and it works for me. Are you 100% sure that you are running this version, and that it is not using an outdated Phobos version (from an older installation, for instance)? One suggestion: Try replacing the next-to-last line with this: dictionary[word.idup] = newId; The 'word' array is mutable and reused by byLine() on each iteration. By doing the above you use an immutable copy of it as the key instead.
 On my computer, with d2-0.5.0, I got the following output while testing.
 
 andrei
 0	andrei
 
  andrei
 
 1	andrei
 
 
 Also, why doesn't 'splitter' show up on the site's documentation of
 std.string?  And what advantage does 'splitter(strip(line))' offer over
 'split(line)'?

splitter is defined in std.algorithm. The fact that it becomes visible when you import std.string is due to bug 314: http://d.puremagic.com/issues/show_bug.cgi?id=314 (std.string is supposed to publically import just a few symbols from std.algorithm, but because of this bug the whole module gets imported publically.)

Actually, while that is a definite bug, splitter() _is_ defined in std.string as well (though it calls std.algorithm.splitter()), but it returns auto, so it doesn't show up in the docs, which is a different bug. - Jonathan M Davis
Dec 20 2010
prev sibling next sibling parent reply doubleagent <doubleagent03 gmail.com> writes:
 Are you 100% sure that you are running this version

I have to be. There are no other versions of phobos on this box and 'which dmd' points to the correct binary.
  dictionary[word.idup] = newId;

That fixes it.
 The 'word' array is mutable and reused by byLine() on each iteration.  By
 doing the above you use an immutable copy of it as the key instead.

I REALLY don't understand this explanation. Why does the mutability of 'word' matter when the associative array 'dictionary' assigns keys by value...it's got to assign them by value, right? Otherwise we would only get one entry in 'dictionary' and the key would be constantly changing. The behavior itself seems really unpredictable prior to testing, and really unintended after testing. I suspect it's due to some sort of a bug. The program, on my box anyway, only fails when we give it identical strings, except one is prefixed with a space. That should tell us that 'splitter' and 'strip' didn't do their job properly. The fly in the ointment is that when we output the strings, they appear as we would expect. I suspect D does string comparisons (when the 'in' keyword is used) based on some kind of a hash, and that hash doesn't get correctly updated when 'strip' or 'splitter' is applied, or upon the next comparison or whatever. Calling 'idup' must force the hash to get recalculated. Obviously, you guys would know if there's any merit to this, but it seems to explain the problem.
 The advantage with splitter is that it is lazy and therefore more
 efficient.  split() is eager and allocates memory to hold the string
 fragments.

Yeah, that's what I thought would be the answer. Kudos to you guys for thinking of laziness out of the box. This is a major boon for D. You know, there's something this touches on which I was curious about. If D defaults to 'safety first', and with some work you can get down-to-the-metal, why doesn't the language default to immutable variables, with an explicit modifier for mutable ones? C compatibility?
Dec 20 2010
next sibling parent reply doubleagent <doubleagent03 gmail.com> writes:
 Okay. I don't know what the actual code looks like

Here. import std.stdio, std.string; void main() { uint[string] dictionary; // v[k], so string->uint foreach (line; stdin.byLine()) { // break sentence into words // Add each word in the sentence to the vocabulary foreach (word; splitter(strip(line))) { if (word in dictionary) continue; // nothing to do auto newId = dictionary.length; dictionary[word] = newId; writefln("%s\t%s", newId, word); } } }
 ...

Okay, suppose you're right. The behavior is still incorrect because the associative array has allowed two identical keys...identical because the only difference between two strings which I care about are the contents of their character arrays.
 Also, it
 would be _really_ annoying to have to mark variables mutable all over the place
 as you would inevitably have to do.

Obviously your other points are valid, but I haven't found this to be true (Clojure is pure joy). Maybe you're right because D is a systems language and mutability needs to be preferred, however after only a day or two of exposure to this language that assumption also appears to be wrong. Take a look at Walter's first attempted patch to bug 2954: 13 lines altered to explicitly include immutable, and 4 altered to treat variables as const: http://www.dsource.org/projects/dmd/changeset/749 But I'm willing to admit that my exposure is limited, and that particular example is a little biased.
Dec 20 2010
parent doubleagent <doubleagent03 gmail.com> writes:
Good & I agree.
Dec 20 2010
prev sibling parent doubleagent <doubleagent03 gmail.com> writes:
 This could be related to bug 2954, for which a fix will be released in
 the next version of DMD.

Looking at that new descriptive error message ie error("associative arrays can only be assigned values with immutable keys, not %s", e2->type->toChars()); it appears to be a distinct possibility. Thanks.
Dec 20 2010
prev sibling next sibling parent Jonathan M Davis <jmdavisProg gmx.com> writes:
On Monday, December 20, 2010 10:44:12 doubleagent wrote:
 Are you 100% sure that you are running this version

I have to be. There are no other versions of phobos on this box and 'which dmd' points to the correct binary.
  dictionary[word.idup] = newId;

That fixes it.
 The 'word' array is mutable and reused by byLine() on each iteration.  By
 doing the above you use an immutable copy of it as the key instead.

I REALLY don't understand this explanation. Why does the mutability of 'word' matter when the associative array 'dictionary' assigns keys by value...it's got to assign them by value, right? Otherwise we would only get one entry in 'dictionary' and the key would be constantly changing.

Okay. I don't know what the actual code looks like, but word is obviously a dynamic array, and if it's from byLine(), then that dynamic array is mutable - both the array itself and its elements. Using idup gets you an immutable copy. When copying dynamic arrays, you really get a slice of that array. So, you get an array that points to the same array as the original. Any changes to the elements in one affects the other. If you append to one of them and it doesn't have the space to resize in place or dyou o anything else which could cause it to reallocate, then that array is reallocated and they no longer point to the same data and changing will not change the other. If the elements of the array are const or immutable, then the fact that the two arrays point to the same data isn't a problem because the elements can't be changed (except in cases where you'red dealing with const rather than immutable and another array points to the same data but doesn't have const elements). So, assigning one string to another, for instance (string being an alias for immutable(char)[]), will never result in one string altering another. However, if you're dealing with char[] rather than string, one array _can_ affect the elements of another. I believe that byLine() deals with a char[], not a string. Now, as for associative arrays, they don't really deal with const correctly. I believe that they're actually implemented with void* and you can actually do things like put const elements in them in spite of the fact that toHash() on Object is not currently const (there is an open bug on the fact that Object is not const-correct). So, it does not surprise me in the least if it will take mutable types as its key and then allow them to be altered (assuming that they're pointers or reference types and you can therefore have other references to them). But to fix the problem in this case would require immutability rather than const, because you're dealing with a reference type (well, pseudo-reference type since dynamic arrays share their elements such that changes to their elements affect all arrays which point to those elements, but other changes - such as altering their length don't affect other arrays and will even likely result in the arrays then being completely separate).
 The behavior itself seems really unpredictable prior to testing, and really
 unintended after testing.  I suspect it's due to some sort of a bug.  The
 program, on my box anyway, only fails when we give it identical strings,
 except one is prefixed with a space.  That should tell us that 'splitter'
 and 'strip' didn't do their job properly.  The fly in the ointment is that
 when we output the strings, they appear as we would expect.
 
 I suspect D does string comparisons (when the 'in' keyword is used) based
 on some kind of a hash, and that hash doesn't get correctly updated when
 'strip' or 'splitter' is applied, or upon the next comparison or whatever.
  Calling 'idup' must force the hash to get recalculated.  Obviously, you
 guys would know if there's any merit to this, but it seems to explain the
 problem.

in should use toHash() (or whatever built-in functions for built-in types if you're not dealing with a struct or class) followed by ==. I'd be stunned if there were any caching involved. The problem is that byLine() is using a mutable array, so the elements pointed to by the array that you just put in the associative array changed, which means that the hash for them is wrong, and == will fail when used to compare the array to what it was before.
 The advantage with splitter is that it is lazy and therefore more
 efficient.  split() is eager and allocates memory to hold the string
 fragments.

Yeah, that's what I thought would be the answer. Kudos to you guys for thinking of laziness out of the box. This is a major boon for D. You know, there's something this touches on which I was curious about. If D defaults to 'safety first', and with some work you can get down-to-the-metal, why doesn't the language default to immutable variables, with an explicit modifier for mutable ones? C compatibility?

C compatability would be one reason. Familiarity would be another. Also, it would be _really_ annoying to have to mark variables mutable all over the place as you would inevitably have to do. The way that const and immutable are designed in D, to some extent, you can pretty much ignore them if you don't want to use them, which some folks like Andrei deem important. Making immutable the default would force it on everyone. - Jonathan M Davis
Dec 20 2010
prev sibling parent "Lars T. Kyllingstad" <public kyllingen.NOSPAMnet> writes:
On Mon, 20 Dec 2010 18:44:12 +0000, doubleagent wrote:

 Are you 100% sure that you are running this version

I have to be. There are no other versions of phobos on this box and 'which dmd' points to the correct binary.
  dictionary[word.idup] = newId;

That fixes it.
 The 'word' array is mutable and reused by byLine() on each iteration. 
 By doing the above you use an immutable copy of it as the key instead.

I REALLY don't understand this explanation. Why does the mutability of 'word' matter when the associative array 'dictionary' assigns keys by value...it's got to assign them by value, right? Otherwise we would only get one entry in 'dictionary' and the key would be constantly changing.

This could be related to bug 2954, for which a fix will be released in the next version of DMD. http://d.puremagic.com/issues/show_bug.cgi?id=2954 -Lars
Dec 20 2010
prev sibling next sibling parent Jonathan M Davis <jmdavisProg gmx.com> writes:
On Monday, December 20, 2010 16:45:20 doubleagent wrote:
 Okay. I don't know what the actual code looks like

Here. import std.stdio, std.string; void main() { uint[string] dictionary; // v[k], so string->uint foreach (line; stdin.byLine()) { // break sentence into words // Add each word in the sentence to the vocabulary foreach (word; splitter(strip(line))) { if (word in dictionary) continue; // nothing to do auto newId = dictionary.length; dictionary[word] = newId; writefln("%s\t%s", newId, word); } } }
 ...

Okay, suppose you're right. The behavior is still incorrect because the associative array has allowed two identical keys...identical because the only difference between two strings which I care about are the contents of their character arrays.

Array comparison cares about the contents of the array. It may shortcut comparisons if lengths differ or if they point to the same point in memory and have the same length, but array comparison is all about comparing their elements. In this case, you'd have two arrays/strings which point to the same point in memory but have different lengths. Because their lengths differ, they'd be deemed unequal. If you managed to try and put a string in the associative array which has the same length as one that you already inserted, then they'll be considered equal, since their lengths are identical and they point to same point in memory, so in that case, I would expect the original value to be replaced with the new one. But other than that, the keys will be considered unequal in spite of the fact that they point to the same place in memory. The real problem here is that associative arrays currently allow non-immutable keys. Once that's fixed, then it won't be a problem anymore.
 Also, it
 would be _really_ annoying to have to mark variables mutable all over the
 place as you would inevitably have to do.

Obviously your other points are valid, but I haven't found this to be true (Clojure is pure joy). Maybe you're right because D is a systems language and mutability needs to be preferred, however after only a day or two of exposure to this language that assumption also appears to be wrong. Take a look at Walter's first attempted patch to bug 2954: 13 lines altered to explicitly include immutable, and 4 altered to treat variables as const: http://www.dsource.org/projects/dmd/changeset/749 But I'm willing to admit that my exposure is limited, and that particular example is a little biased.

Most programmers don't use const even in languages that have it. And with many programmers programming primarily in languages like Java or C# which don't really have const (IIRC, C# has more of a const than Java, but it's still pretty limited), many, many programmers never use const and see no value in it. So, for most programmers, mutable variables will be the norm, and they'll likely only use const or immutable if they have to. There are plenty of C++ programmers who will seek to use const (and possibly immutable) heavily, but they're definitely not the norm. And, of course, there are plenty of other languages out there with const or immutable types of one sort or another (particularly most functional languages), but those aren't the types of languages that most programmers use. The result is that most beginning D programmers will be looking for mutable to be the norm, and forcing const and/or immutable on them could be seriously off- putting. Now, most code which is going to actually use const and immutable is likely to be a fair mix of mutable, const, and immutable - especially if you don't try to make everything immutable at the cost of efficiency like you'd typically get in a functional language. That being the case, regardless of whether mutable, const, or immutable is the default, you're going to have to mark a fair number of variables as something other than the default. So, making const or immutable the default would likely not save any typing, and it would annoy a _lot_ of programmers. So, the overall gain of making const or immutable the default is pretty minimal if not outright negative. Personally, I use const and immutable a lot, but I still wouldn't want const or immutable to be the default. - Jonathan M Davis
Dec 20 2010
prev sibling next sibling parent Stanislav Blinov <blinov loniir.ru> writes:
20.12.2010 22:06, Steven Schveighoffer пишет:
 On Mon, 20 Dec 2010 14:05:56 -0500, Steven Schveighoffer 
 <schveiguy yahoo.com> wrote:

 On Mon, 20 Dec 2010 11:13:34 -0500, Stanislav Blinov 
 <blinov loniir.ru> wrote:

 And lastly, hasn't this by chance been your first post? AFAIR, the 
 first message is being moderated so it doesn't get to the public at 
 once.

BTW, this message board is not moderated.

I should clarify, it's retroactively moderated :) That is, if spam appears, it's allowed to go through, but then removed once discovered.

... Your mail to 'Digitalmars-d-learn' with the subject Re: hijacking a class's members Is being held until the list moderator can review it for approval. The reason it is being held: Post to moderated list Either the message will get posted to the list, or you will receive notification of the moderator's decision. If you would like to cancel this posting, please visit the following URL: ... I should note that I post via mailing list, so maybe this is the catch.
Dec 21 2010
prev sibling next sibling parent Stanislav Blinov <blinov loniir.ru> writes:
21.12.2010 19:55, spir пишет:
 On Tue, 21 Dec 2010 11:49:42 -0500
 "Steven Schveighoffer"<schveiguy yahoo.com>  wrote:

 Hm... I always use a newsgroup client, so maybe.  But in any case, I've
 never known anyone to have been blocked from posting, and the newsgroup
 interface does not have any moderation on it.  I'd be surprised if anyone
 with the ability to moderate spends any time moderating the newsgroup.


But I did get that moderation message and then waited almost a day to see my message in the list. But this happened only to the first message in each list.
Dec 21 2010
prev sibling parent reply Jonathan M Davis <jmdavisProg gmx.com> writes:
On Tuesday, December 21, 2010 09:36:20 Stanislav Blinov wrote:
 21.12.2010 19:55, spir =D0=BF=D0=B8=D1=88=D0=B5=D1=82:
 On Tue, 21 Dec 2010 11:49:42 -0500
=20
 "Steven Schveighoffer"<schveiguy yahoo.com>  wrote:
 Hm... I always use a newsgroup client, so maybe.  But in any case, I've
 never known anyone to have been blocked from posting, and the newsgroup
 interface does not have any moderation on it.  I'd be surprised if
 anyone with the ability to moderate spends any time moderating the
 newsgroup.

Mailing list neither (never got any moderation message).

With newsgroups, I never got the moderation warning either. But I did get that moderation message and then waited almost a day to see my message in the list. But this happened only to the first message in each list.

The first message sent to the list has to be okayed by Brad. That way, he h= as a=20 way to stop spam bots. When he sees that you at least appear to be a real=20 person, he lets your first e-mail through and then changes whatever setting= s he=20 has to to make it so that the list then just accepts your e-mails. But sinc= e he=20 has to do it personally, there can be a delay between when you send your fi= rst=20 message and when it arrives. I believe that that occurs once per list that = you=20 sign up for. The only other time that I've seen moderation messages are when I've sent=20 messages that are too large (because of attachments with code), at which po= int=20 Brad has to approve it. In general though, it's preferred that you post a l= ink=20 to code rather than attach it (which I didn't know at the time). You typically shouldn't be seeing moderator messages. =2D Jonathan M Davis
Dec 21 2010
next sibling parent doubleagent <doubleagent03 gmail.com> writes:
 In general though, it's preferred that you post a link to code rather than
attach it

I'll try to remember that.
Dec 21 2010
prev sibling parent Stanislav Blinov <stanislav.blinov gmail.com> writes:
On 12/21/2010 10:51 PM, Jonathan M Davis wrote:

 With newsgroups, I never got the moderation warning either.
 But I did get that moderation message and then waited almost a day to
 see my message in the list. But this happened only to the first message
 in each list.

The first message sent to the list has to be okayed by Brad. That way, he has a way to stop spam bots. When he sees that you at least appear to be a real person, he lets your first e-mail through and then changes whatever settings he has to to make it so that the list then just accepts your e-mails. But since he has to do it personally, there can be a delay between when you send your first message and when it arrives. I believe that that occurs once per list that you sign up for. The only other time that I've seen moderation messages are when I've sent messages that are too large (because of attachments with code), at which point Brad has to approve it. In general though, it's preferred that you post a link to code rather than attach it (which I didn't know at the time). You typically shouldn't be seeing moderator messages.

Thanks for clarification. I already started to wonder if it was just me :)
Dec 22 2010