Punctuation as noise

ruby-talk
1

I’ve been thinking for a day or so about
signal vs. noise, in source code and
perhaps in other contexts (ahem!!).

This is just a crazy theory of mine, so
flame away if you like.

I personally find that the more "littered"
a program is with punctuation and symbols,
the less I like to look at it. (Yes, it’s
possible to have too little of that, but
that’s rare in programming languages.)

For example, the parentheses in a C "if"
statement annoy me. The terminating semicolon
in many languages is slightly annoying. The
frequent colons in Python bother me. And let’s
not even get into Perl.

As a very crude way of measuring this, I decided
to count alphanumerics vs. symbols in code
(counting whitespace as neither – an arbitrary
decision on my part).

I cranked out a quick bit of ugly code (see
below). Obviously it’s crude – e.g., it doesn’t
take note of strings or comments (and it’s not
clear what it should do if it did).

I’d be curious to see people’s results on a large
corpus of code (Ruby, Perl, etc.).

So far I haven’t tried it much, as I just wrote it
half an hour ago.

I have noticed an odd effect already, though. The
symbol/alpha ratio is fairly low (1-2) for smaller
programs and larger (4-6) for larger programs. I’ve
tried it on sources ranging from 10 lines to 2000
lines.

Cheers,
Hal

···

–
Hal Fulton
hal9000@hypermetrics.com

noise = 0
alpha = 0
punc = “’” + ',./`-=[];~!@#$%^&*()_+{}|:"<>?'
punc = punc.split "“
white = " \t\n”.split “”
$stdin.each_byte do |x|
case x.chr
when *punc
noise += 1
when *white
# ignore
else
alpha += 1
end
end

ratio = alpha/noise.to_f
puts “Signal/noise: #{alpha}/#{noise} = #{’%4.1f’ % ratio}”

2

I have noticed an odd effect already, though. The
symbol/alpha ratio is fairly low (1-2) for smaller
programs and larger (4-6) for larger programs. I’ve
tried it on sources ranging from 10 lines to 2000
lines.

In my scrpts directory, I have a half dozen each very small ruby and perl
scripts. For the ruby stuff I got s:n of 2.4. For the perl stuff 2.7.

Note: I use some old-habit stuff from perl and c, so I might slip in a
semicolon on EOL and I definitely avoid “poetry” mode at all costs
(including not using parens around if conditions), as it’s Vogon poetry to
my eyes, so my ruby probably isn’t idiomatic ruby; or at least not as RUBY
idiomatic ruby as is yours.

3

I’d be curious to see people’s results on a large
corpus of code (Ruby, Perl, etc.).

On 27K lines of integration test code (Ruby), I get:
Signal/noise: 458705/119801 = 3.8

On 10K lines of C++ extension code that the above tests test:
Signal/noise: 163676/40803 = 4.0

On 1.3K lines of unit test code (C++), I get:
Signal/noise: 28549/8335 = 3.4

On 544 lines of unit test code (Perl), I get:
Signal/noise: 9365/4350 = 2.2

On 4K lines of vim scripts that I regularly use, I get:
Signal/noise: 500/73 = 6.8

On the 63K lines of Ruby code that come with 1.8:
Signal/noise: 912431/218858 = 4.2

On the 60K lines of C extension code that comes with 1.8:
Signal/noise: 823062/251038 = 3.3

On the 71K lines of C code that make up the Ruby 1.8 interpreter:
Signal/noise: 904042/313624 = 2.9

I have noticed an odd effect already, though. The
symbol/alpha ratio is fairly low (1-2) for smaller
programs and larger (4-6) for larger programs. I’ve
tried it on sources ranging from 10 lines to 2000
lines.

This is probably the result I would expect. If I’m writing a throwaway
script, I don’t care what it looks like, so long as it works.

BTW, I played golf with your script and got:

noise = 0
alpha = 0
punc = ‘',./`=\;~!@#$%^&*()_+{}|:"<>?-’
white = " \t\r\n"
while buf = $stdin.read(512) do
punc_count = buf.count(punc)
white_count = buf.count(white)
noise += punc_count
alpha += buf.size - white_count - punc_count
end

ratio = alpha/noise.to_f
puts “Signal/noise: #{alpha}/#{noise} = #{‘%4.1f’ % ratio}”

It runs significantly faster this way.

Paul

···

On Thu, Aug 21, 2003 at 02:49:19AM +0900, Hal E. Fulton wrote:

4

“Hal E. Fulton” hal9000@hypermetrics.com writes:

For example, the parentheses in a C “if”
statement annoy me. The terminating semicolon
in many languages is slightly annoying. The
frequent colons in Python bother me. And let’s
not even get into Perl.

One of the hardest things for me to get used to in Ruby still is the
lack of braces and semicolons. Without braces, I’m always nervous
about where my statments are beginning and ending (ruby-mode.el
doesn’t seem to let me use {forward,backward}-sexp to move around
blocks), and without semicolons (or statment delimiter of choice), I’m
always a bit nervous about where a statement is ending.

It’s not hard to write a test or two to verify my assumptions, but I
still feel a bit uneasy about it. Silly, I know, but no sillier
than your being annoyed by them, I’m sure. :slight_smile:

I ran your program over my test harness code, and my Perl code is
about 2:1, where my Ruby is more like 3-4:1. I honestly don’t know
why.

-=Eric

···

–
Come to think of it, there are already a million monkeys on a million
typewriters, and Usenet is NOTHING like Shakespeare.
– Blair Houghton.

5

Hal Fulton wrote:

I cranked out a quick bit of ugly code (see
below). Obviously it’s crude – e.g., it doesn’t
take note of strings or comments (and it’s not
clear what it should do if it did).

I did something like this a while back when a Java programmer complained
about all that “line noise” in Ruby. I pointed out that Java used much
more puncuation than the typical Ruby program and wrote the following
program to demonstrate…

#!/usr/bin/env ruby
ARGV.each { |fn|
noise = open(fn) { |file| file.read }.gsub(/[A-Za-z0-9_ \t\n]/m, “”)
puts “#{fn} (#{noise.size}): #{noise}”
}

Runnnig this over a set of programs written in different languages
gives…

animal.cc (83):
#<>{:()=;};:{:();};::(){::<<“";}:{:();};::(){::<<”";}(){*={,};(=;<;++)->();;}
Animal.java (67):
{{();}{(){…(“”);}}{(){…(“”);}}(){={(),()};(=;<.;++).();}}
animal.pl (41): ;{{};}{“";};{{};}{”";};$(->,->){$->();}
animal.py (23): :():“”:():“”[(),()]:.()
animal.rb (10): “”“”[.,.].

Onestepback.org is down at the moment, but I’ll post the code for all
the animal programs there when it comes back online.

···

On Wed, 2003-08-20 at 13:49, Hal E. Fulton wrote:

–
– Jim Weirich jweirich@one.net http://onestepback.org

“Beware of bugs in the above code; I have only proved it correct,
not tried it.” – Donald Knuth (in a memo to Peter van Emde Boas)

6

As a very crude way of measuring this, I decided
to count alphanumerics vs. symbols in code
(counting whitespace as neither – an arbitrary
decision on my part).

You’re not distinguishing between ‘meaningful’ and ‘punctuative’
symbols (roughly, symbols that would be replaced by words and symbols
that could be replaced by whitespace). For instance, compare:

\x → x + 1 – Haskell
lambda {|x| x + 1} # Ruby

sign :: Int → String – Haskell
sign x

x > 0 = “+”
x < 0 = “-”
otherwise = “”

def sign(x) # Ruby (nonpunctuative)
if x > 0
“+”
elsif x < 0
“-”
else
“0”
end
end

def sign(x) # Ruby (punctuative (punctional?))
(x > 0) ? “+” :
(x < 0) ? “-” : “0”
end

martin

···

Hal E. Fulton hal9000@hypermetrics.com wrote:

7

“Hal E. Fulton” hal9000@hypermetrics.com wrote in message news:03b301c36744$828b2520$0300a8c0@austin.rr.com…

I’ve been thinking for a day or so about
signal vs. noise, in source code and
perhaps in other contexts (ahem!!).

This is just a crazy theory of mine, so
flame away if you like.

I personally find that the more “littered”
a program is with punctuation and symbols,
the less I like to look at it. (Yes, it’s
possible to have too little of that, but
that’s rare in programming languages.)

I think you would be pleased with FORTH language. In forth there is
only two kinds of syntactic elements - whitespaces which separates
words consisting of series of non-whitespaces. No punctuation, no
keywords, no reserved words. Everything what in other programing
languages is expressed using special syntactic elements in forth is
achived by appropriate sequences of ‘words’ in Reverse Polish
Notation. Every dot, star or semicolon have no other purpose as
execution of piece of code!

Unfortunately forth code is rather hard to read for programers used to
“normal” languages.

Simplicity of syntax makes forth very fast - it’s parser simply
recognizes words separated by whitespaces and “executes” them. I think
that this is reason of your concern: simplicity of language’s syntax
makes interpreter’s work easier - so execution of code can be faster.

(For quick overview of forth look at
Forth (programming language) - Wikipedia)

···

–

Best regards
RNicz

8

I have noticed an odd effect already, though. The
symbol/alpha ratio is fairly low (1-2) for smaller
programs and larger (4-6) for larger programs. I’ve
tried it on sources ranging from 10 lines to 2000
lines.

In my scrpts directory, I have a half dozen each very small ruby and perl
scripts. For the ruby stuff I got s:n of 2.4. For the perl stuff 2.7.

That’s interesting and surprising to me. Not only are they very
comparable, but Ruby actually has a smaller value.Wonder if they’d
diverge more on larger sources?

By the way, when I said symbol/alpha ratio, I really meant alpha/symbol
ratio (as the code reflects). Thus (to me) a higher number is a
prettier chunk of code.

Note: I use some old-habit stuff from perl and c, so I might slip in a
semicolon on EOL and I definitely avoid “poetry” mode at all costs
(including not using parens around if conditions), as it’s Vogon poetry to
my eyes, so my ruby probably isn’t idiomatic ruby; or at least not as RUBY
idiomatic ruby as is yours.

I use “poetry mode” frequently but not universally. And the absence of
parens on an if is (to my mind) not even considered poetry mode. It’s
just avoidance of superfluous parens around an expression, just as I
don’t say: x = (y + z)

My style deviates from the norm in many cases. Often I’m trying
to smooth those out. The Ruby Way contains numerous examples
of camelCase, as I hadn’t trained myself not to like it. It’s a
matter of opinion anyway; and we don’t HAVE to code exactly the
way Matz does. So I’m uncertain what “idiomatic Ruby” really is.

Anyway, I’d be curious as to other people’s results on this little
experiment.

Cheers,
Hal

···

----- Original Message -----
From: “Michael Campbell” michael_s_campbell@yahoo.com
To: “ruby-talk ML” ruby-talk@ruby-lang.org
Sent: Wednesday, August 20, 2003 1:50 PM
Subject: Re: Punctuation as noise

9

Hmm, I just noticed that the script counts _'s as puntuation, and thus
has a significant bias toward camelCase. I changed the script to count
them as whitespace instead, and here are the results:

On 27K lines of integration test code (Ruby), I get:
Signal/noise: 458705/119801 = 3.8
Signal/noise: 458705/90543 = 5.1

On 10K lines of C++ extension code that the above tests test:
Signal/noise: 163676/40803 = 4.0
Signal/noise: 163676/26609 = 6.2

On 1.3K lines of unit test code (C++), I get:
Signal/noise: 28549/8335 = 3.4
Signal/noise: 28549/6064 = 4.7

On 544 lines of unit test code (Perl), I get:
Signal/noise: 9365/4350 = 2.2
Signal/noise: 9365/3710 = 2.5

On 4K lines of vim scripts that I regularly use, I get:
Signal/noise: 500/73 = 6.8
Signal/noise: 107184/21843 = 4.9
(I think the original result I gave here was wrong)

On the 63K lines of Ruby code that come with 1.8:
Signal/noise: 912431/218858 = 4.2
Signal/noise: 912431/200519 = 4.6

On the 60K lines of C extension code that comes with 1.8:
Signal/noise: 823062/251038 = 3.3
Signal/noise: 823062/211752 = 3.9

On the 71K lines of C code that make up the Ruby 1.8 interpreter:
Signal/noise: 904042/313624 = 2.9
Signal/noise: 904042/266126 = 3.4

punc = ‘',./=[]\\;~!@#$%^&*()_+{}|:"<>?-' white = " \t\r\n" punc = '\',./=\;~!@#$%^&*()+{}|:"<>?-’
white = " \t\r\n_"

Paul

···

On Thu, Aug 21, 2003 at 04:32:42AM +0900, Paul Brannan wrote:

10

I have noticed an odd effect already, though. The
symbol/alpha ratio is fairly low (1-2) for smaller
programs and larger (4-6) for larger programs. I’ve
tried it on sources ranging from 10 lines to 2000
lines.

One thing I think I’ve noticed however is that the s:n code you posted takes
into account comments as “code”. For heavily commented source, this might
skew the s:n ratio, no?

11

I understand what idea you’re getting at, but I think this
script is too crude. It can be completely thrown off if
one script happens to use longer variable-names than
another, for instance. I tend to use longer names than
the average C programmer does. Also, when I’m writing a
script, the longer the script gets, the longer my variable
names are likely to get.

One possible side-effect: If it takes me more lines of
code to implement a given task one language than another
language, then the “longer” language is likely to have
longer variable names, and thus score lower (aka “better”)
with this punctuation-scoring method.

The punctuation-scoring method would also favor languages
which use a lot of long keywords. I once worked with a
language which used long keywords by design. All reserved
words were more than letters, because it assumed that
programmers would prefer to pick shorter variable names.
So, it did things like use ‘whenever’ instead of ‘if’.

It also favors languages which force you to use words
for what most languages use punctuation for. I wonder
what kind of a score cobol would get using this method.
[at the other end of the scale, APL would not fare well
with this method, and for very very good reasons! :slight_smile: ]

So while this starts out sounding like an interesting
measurement, I think that as soon as you try to get
“hard numbers” (which look significant simply because
they are “objective values”), you’ll find that the
measurement is pretty close to meaningless.

···

Hal E. Fulton hal9000@hypermetrics.com wrote:

As a very crude way of measuring this, I decided
to count alphanumerics vs. symbols in code
(counting whitespace as neither – an arbitrary
decision on my part).

–
Garance Alistair Drosehn = gad@gilead.netel.rpi.edu
Senior Systems Programmer or gad@freebsd.org
Rensselaer Polytechnic Institute or drosih@rpi.edu

12
> One of the hardest things for me to get used to in Ruby still is the > lack of braces and semicolons. Without braces, I'm always nervous > about where my statments are beginning and ending (ruby-mode.el > doesn't seem to let me use {forward,backward}-sexp to move around > blocks), and without semicolons (or statment delimiter of choice), I'm > always a bit nervous about where a statement is ending.

Well, about semicolons, I dunno. Statement ends at the EOL, unless it
obviously doesn’t (you end with a , or + or something).

However, blocks have presented an issue. I have a theory about
character variety which I won’t go into depth here on (basically,
there’s a certain level of character variety that makes things easy to
read at a glance; too much or too few non-alphanumerics and you have
problems), but I’ve come up with a solution that works for blocks for
me:

class Foo
end #c:Foo

module A
end #M:A

I would have issues, where in a class definition more that a screen, I
wouldn’t always hit the right ‘end’, and end up adding the method
outside the class or the like. (Lots of module depth.) The issue went
away immediately as I started using block end tags. I use the
following:

#c:CLASS
#M:MODULE
#m:METHOD
#b:BLOCK      <-- rarely used

Of course, as you said, in C etc., the editor shows you what block you
came from. At least in the ruby emacs mode, this isn’t the case.

···

On Thu, 21 Aug 2003 09:52:08 +0900 Eric Schwartz emschwar@pobox.com wrote:

–
Ryan Pavlik rpav@users.sf.net

“Let super-dimensional physics take its course!” - 8BT

13

Hmm, I just noticed that the script counts _'s as puntuation, and thus
has a significant bias toward camelCase. I changed the script to count
them as whitespace instead, and here are the results:

Oh, thanks, have to regard that as a bug.

Hmm, if we cheated and considered @ alphanumeric, it would help
my theory even more. :slight_smile:

But my theory doesn’t appear to be really borne out anyway. I’m
sure a statistician would laugh.

I expected significant, noticeable differences between Ruby
and Perl and C and C++. Don’t really see those here.

Hal

···

----- Original Message -----
From: “Paul Brannan” pbrannan@atdesk.com
To: “ruby-talk ML” ruby-talk@ruby-lang.org
Sent: Wednesday, August 20, 2003 2:40 PM
Subject: Re: Punctuation as noise

On Thu, Aug 21, 2003 at 04:32:42AM +0900, Paul Brannan wrote:

On 27K lines of integration test code (Ruby), I get:
Signal/noise: 458705/119801 = 3.8
Signal/noise: 458705/90543 = 5.1

On 10K lines of C++ extension code that the above tests test:
Signal/noise: 163676/40803 = 4.0
Signal/noise: 163676/26609 = 6.2

On 1.3K lines of unit test code (C++), I get:
Signal/noise: 28549/8335 = 3.4
Signal/noise: 28549/6064 = 4.7

On 544 lines of unit test code (Perl), I get:
Signal/noise: 9365/4350 = 2.2
Signal/noise: 9365/3710 = 2.5

On 4K lines of vim scripts that I regularly use, I get:
Signal/noise: 500/73 = 6.8
Signal/noise: 107184/21843 = 4.9
(I think the original result I gave here was wrong)

On the 63K lines of Ruby code that come with 1.8:
Signal/noise: 912431/218858 = 4.2
Signal/noise: 912431/200519 = 4.6

On the 60K lines of C extension code that comes with 1.8:
Signal/noise: 823062/251038 = 3.3
Signal/noise: 823062/211752 = 3.9

On the 71K lines of C code that make up the Ruby 1.8 interpreter:
Signal/noise: 904042/313624 = 2.9
Signal/noise: 904042/266126 = 3.4

punc = ‘',./=[]\\;~!@#$%^&*()_+{}|:"<>?-' white = " \t\r\n" punc = '\',./=\;~!@#$%^&*()+{}|:"<>?-’
white = " \t\r\n_"

Paul

14

Another thing is that it doesn’t take into account variance. For
instance, with this code, “@@@@@@@@@” would be just as noisy as
“#@!^$(*&%”, and to me, variance has a lot to do with noise.

···

On Thu, 21 Aug 2003 05:01:30 +0900 “Michael Campbell” michael_s_campbell@yahoo.com wrote:

I have noticed an odd effect already, though. The
symbol/alpha ratio is fairly low (1-2) for smaller
programs and larger (4-6) for larger programs. I’ve
tried it on sources ranging from 10 lines to 2000
lines.

One thing I think I’ve noticed however is that the s:n code you posted takes
into account comments as “code”. For heavily commented source, this might
skew the s:n ratio, no?

–
Ryan Pavlik rpav@users.sf.net

“You mean super bouncy ball!” - 8BT

15

I have just made a small script which can measure signal2noise
alphanum / (total-blank). I am also interested in hearing what your
signal2noise ratio are ?

Try the script at the bottom of this posting.

···

On Thu, 21 Aug 2003 05:20:16 +0900, Hal E. Fulton wrote:

Anyway, I’d be curious as to other people’s results on this little
experiment.

–
Simon Strandgaard

noise.rb => 75%

ruby noise.rb noise.rb
alphas = 571
blanks = 156
others = 189
alpha/(alpha+others) = 0.751315789473684

readme’s => 85%

ruby noise.rb REA*
alphas = 1864
blanks = 540
others = 319
alpha/(alpha+others) = 0.853870819972515
ls -la REA*
-rw-r–r-- 1 neoneye neoneye 1634 10 Aug 23:51 README
-rw-r–r-- 1 neoneye neoneye 259 3 Jul 07:46 README.ADMIN
-rw-r–r-- 1 neoneye neoneye 830 19 Aug 00:54 README.CVS

signal2noise in my AEditor project source => 85%

wc -l .rb | grep total
3663 total
ruby noise.rb test.non_test/.rb
alphas = 54765
blanks = 16721
others = 9551
alpha/(alpha+others) = 0.851498849430935

signal2noise in my AEditor project unittests => 80%

wc -l .rb | grep total
4998 total
ruby noise.rb test.test/.rb
alphas = 99522
blanks = 21985
others = 24864
alpha/(alpha+others) = 0.800106121267667

signal2noise in a c++ project, .cpp => 79% .h => 86%

ruby noise.rb *.cpp
alphas = 51331
blanks = 13813
others = 13171
alpha/(alpha+others) = 0.795804781247093
ruby noise.rb *.h
alphas = 31507
blanks = 7416
others = 4806
alpha/(alpha+others) = 0.86765070360477

The noise.rb scrip is here:

expand -t2 noise.rb
def calc_history(res, file)
data = nil
File.open(file, “r”){|f| data = f.read}
ary = data.unpack(‘C*’)
ary.each{|i| res[i]+=1}
res
end

def count_freq(history, *matchs)
count = [0] * matchs.size
count_bad = 0
history.each_index{|ascii|
ok = false
matchs.each_index{|i|
if matchs[i].index(ascii) != nil
count[i] += history[ascii]
ok = true
end
}
count_bad += history[ascii] unless ok
}
count << count_bad
count
end

scan files

result = [0]*256
ARGV.each{|file| calc_history(result, file) }

count frequency

match_alphanum = (‘a’[0]…‘z’[0]).to_a + (‘A’[0]…‘Z’[0]).to_a + (‘0’[0]…‘9’[0]).to_a
match_blanks = [32, 13, 10, 9]
alphas, blanks, others = count_freq(result, match_alphanum, match_blanks)

output result

totals = alphas + others
ratio = alphas.to_f / totals.to_f
puts <<MSG
alphas = #{alphas}
blanks = #{blanks}
others = #{others}
alpha/(alpha+others) = #{ratio}
MSG

16

[snip]

So while this starts out sounding like an interesting
measurement, I think that as soon as you try to get
“hard numbers” (which look significant simply because
they are “objective values”), you’ll find that the
measurement is pretty close to meaningless.

Probably an accurate summary.

Hal

···

----- Original Message -----
From: “Garance A Drosihn” drosih@rpi.edu
To: “ruby-talk ML” ruby-talk@ruby-lang.org
Sent: Thursday, August 21, 2003 5:39 AM
Subject: Re: Punctuation as noise

–
Hal Fulton
hal9000@hypermetrics.com

17

I wrote an emacs lisp hack that acted like the highlight method of
match-paren. If I had a cursor on the beginning or end of the block, it
would automatically highlight the block for me.

But… it was not always perfect and sometimes stopped working–I never
figured out why.

Now that I’ve switched to vim I can just use %, which helps a lot (thanks
to Ned Konz for his matchit support).

But I still miss the visual feedback of the highlight. When it worked it
was very nice. When it intermittently stopped working I missed it. When
it went into an infinite loop I cursed it :slight_smile: (If I could write emacs
extensions in Ruby instead of elisp, I could’ve fixed it :slight_smile:

Certainly a forward-sexp should be easy to implement for a better elisp
hacker than myself–ruby-mode gives you the functions to determine if your
cursor is at the beginning or end of a block.

···

On Aug 22, Ryan Pavlik wrote:

On Thu, 21 Aug 2003 09:52:08 +0900 > Eric Schwartz emschwar@pobox.com wrote:

> One of the hardest things for me to get used to in Ruby still is the > lack of braces and semicolons. Without braces, I'm always nervous > about where my statments are beginning and ending (ruby-mode.el > doesn't seem to let me use {forward,backward}-sexp to move around > blocks), and without semicolons (or statment delimiter of choice), I'm > always a bit nervous about where a statement is ending.

Of course, as you said, in C etc., the editor shows you what block you
came from. At least in the ruby emacs mode, this isn’t the case.

–
---------------------------------------------- | --------------------------
Brett Williams |

Agilent Technologies brett_williams@agilent.com
18

A tool to do this automatically would be pretty handy; any ideas?

···

In article 20030821110003.3869e22a.rpav@users.sf.net, Ryan Pavlik wrote:

I would have issues, where in a class definition more that a screen, I
wouldn’t always hit the right ‘end’, and end up adding the method
outside the class or the like. (Lots of module depth.) The issue went
away immediately as I started using block end tags. I use the
following:

#c:CLASS
#M:MODULE
#m:METHOD
#b:BLOCK      <-- rarely used
19

thinking of translating ascii-historic into a signal2noise ratio:

There exists a grey area between alphanum and symbols.
Where some letters cause more noise than others… hmmm
If we consider looking at ruby-code, without any syntax hiliting, then
heredoc and comments is actually quite distibing.

This is just how I would prioritize such sig2noise-grey area.

top = much noise, low signal
bottom = low noise, much signal

@@
`` difficult to determine if its backquote or quote
‘’
$0 globals
// regex is not nice to the eye
\n
::
;
<<HERE we should ignore some lines

we should ignore to end of line

“”

{} do-end is easy to the eye
@
() parantesis is gentle
…
±/*= math is like our alphabet
_ underscore is quite harmless

···

On Thu, 21 Aug 2003 00:20:29 +0200, Simon Strandgaard wrote:

I have just made a small script which can measure signal2noise
alphanum / (total-blank). I am also interested in hearing what your
signal2noise ratio are ?

Try the script at the bottom of this posting.

–
Simon Strandgaard

20
> > > > #c:CLASS > > #M:MODULE > > #m:METHOD > > #b:BLOCK <-- rarely used > > A tool to do this automatically would be pretty handy; any ideas? > >

I’ve been pondering an emacs function or two that builds a complete
block template for me. I haven’t gotten to it yet, but that’s about
all the further I’ve thought. I suppose you could make a script that
put these in your code, too… if you do, please let me know. :wink:

···

On Fri, 22 Aug 2003 03:34:49 +0900 Jason Williams jason@jasonandali.org.uk wrote:

In article 20030821110003.3869e22a.rpav@users.sf.net, Ryan Pavlik wrote:

–
Ryan Pavlik rpav@mephle.com

“Well, I don’t like to brag, but I am a villain after all.” - 8BT