Nethack! (was): AdaGames

Nethack! (was): AdaGames

[Kent Paul Dolan]

"Enrico A." <muaddib@digibank.it> wrote:

 > Ciao! 

 >     in your opinion what kind of game can show the power of Ada ?
 > a sport game (soccer, nhl), strategic game (like command&conquer),
 > flight (Ace combat,Ms flight simulator), rps (Doom, Quake, Halo),
 > Adventure (Zak McKracken:))), Day of the tentacle), rpg (Baldur's
 > gate) etc ?

Several years ago by now I promoted porting Nethack to Ada as a way to
attract college students to the Ada language.  The proposal fell on deaf
ears.

I'd like to see the conceptual richness and widely distributed
development model, both perfect for students, of Nethack ported to a
full 3D graphics live action dungeon crawl game, but it's way past my
skill set to accomplish, or even organize.

xanthian.


-- 
Posted via Mailgate.ORG Server - http://www.Mailgate.ORG

Re: Nethack! (was): AdaGames

[Ted Dennison]

"Kent Paul Dolan" <xanthian@well.com> wrote in message news:<fa07dbfec5dad2d0a41625ebfeda3720.48257@mygate.mailgate.org>...
> Several years ago by now I promoted porting Nethack to Ada as a way to
> attract college students to the Ada language.  The proposal fell on deaf
> ears.

As Nethack is fairly simple, its probably something a single person
could handle. So rather than "promoting" it, why not just do it
yourself?

-- 
T.E.D.
Home     -  mailto:dennison@telepath.com (Yahoo: Ted_Dennison)
Homepage -  http://www.telepath.com/dennison/Ted/TED.html

Re: Nethack! (was): AdaGames

[Juanma Barranquero]

On 29 Mar 2002 06:13:44 -0800, dennison@telepath.com (Ted Dennison)
wrote:
>As Nethack is fairly simple, its probably something a single person
>could handle.

"Fairly simple" as Ada projects go, certainly (< 200K SLOCs).
Certainly is not simple as a Roguelike, in both meanings: it is not
small, and it is not a simple game.

Anyway I think it would be better to start a rogue from scratch in Ada
that try to port NetHack. I've been wishing to find the time to do it
(develop a new rogue in Ada, I mean) for years... :(

                                                               /Lektu

Re: Nethack! (was): AdaGames

[Ted Dennison]

Juanma Barranquero <lektu@terra.es> wrote in message news:<6g4gaugv9a85i56kvgcgmu4h2jkjprutec@4ax.com>...
> On 29 Mar 2002 06:13:44 -0800, dennison@telepath.com (Ted Dennison)
> wrote:
> >As Nethack is fairly simple, its probably something a single person
> >could handle.
> 
> "Fairly simple" as Ada projects go, certainly (< 200K SLOCs).
> Certainly is not simple as a Roguelike, in both meanings: it is not
> small, and it is not a simple game.

Seeing as I had a version running on a 256K Amiga 17 years ago, I'd
say *considerably* less than 200K SLOCS.

Also "farily simple" compared to its spiritual successor today,
DiabloII.

It would certainly be very little work to get a basic rev of it up and
running, which is what one needs to get a Free Software project
rolling.

-- 
T.E.D.
Home     -  mailto:dennison@telepath.com (Yahoo: Ted_Dennison)
Homepage -  http://www.telepath.com/dennison/Ted/TED.html

Re: Nethack! (was): AdaGames

[Ralph Moeritz]

Juanma Barranquero wrote:
 
> Anyway I think it would be better to start a rogue from scratch in
> Ada that try to port NetHack. I've been wishing to find the time to
> do it (develop a new rogue in Ada, I mean) for years... :(

I was going to write a roguelike in Ada, I think it's the most 
convenient language. I decided on C instead though because there wasn't 
any source code to learn from in Ada.

-- 
Ralph Moeritz

Re: Nethack! (was): AdaGames

[Juanma Barranquero]

On 1 Apr 2002 07:04:08 -0800, dennison@telepath.com (Ted Dennison)
wrote:

>Seeing as I had a version running on a 256K Amiga 17 years ago, I'd
>say *considerably* less than 200K SLOCS.

I haven't got that line count out of thin air. I used "wc -l" on the
sources, and I didn't count the source of all ports, only /src,
/include and the Windows-specific directories (and only of .c and .h
files, not auxiliary ones). Rest assured current NetHack is not as
lightweight as the Rogue/Hack/NetHack releases of 17 years ago...
Pre-build binaries' sizes are: Non-windowing, 1728 KB; windowing, 2052
KB.

>Also "farily simple" compared to its spiritual successor today,
>DiabloII.

On the contrary: gamers who routinely play Diablo/DiabloII *and*
NetHack are usually pretty clear in stating that NetHack is a lot more
complex and interesting. Obviously, is not as visually appealing as
those two, but gameplay is more developed.

>It would certainly be very little work to get a basic rev of it up and
>running, which is what one needs to get a Free Software project
>rolling.

Not that I want to start any kind of flame war here, but I think
you're *not* talking about the current state of development of
NetHack. Porting the 3.4.0 NetHack (straight from www.nethack.org) to
Ada is not "very little work" for any practical definition of the
words. I don't know what do you mean by "a basic rev of it", because
even simplifying NetHack would be a daunting task right now.

                                                         /Lektu

Re: Nethack! (was): AdaGames

[Juanma Barranquero]

On 1 Apr 2002 18:05:19 GMT, Ralph Moeritz <ralph@work.co.za> wrote:

>I decided on C instead though because there wasn't 
>any source code to learn from in Ada.

Oh, well, if I get someday to start mine I won't use any previous
source code to learn, I want to make my own mistakes ;)

Moreover, most roguelike sources are reportedly very confusing and
excedingly short on comments. The exception is Moria, but I don't like
Moria-like rogues :(

                                                               /Lektu

Re: Nethack! (was): AdaGames

[Preben Randhol]

On Tue, 02 Apr 2002 11:27:52 +0200, Juanma Barranquero wrote:
> On 1 Apr 2002 07:04:08 -0800, dennison@telepath.com (Ted Dennison)
> wrote:
> 
>>Seeing as I had a version running on a 256K Amiga 17 years ago, I'd
>>say *considerably* less than 200K SLOCS.
> 
> I haven't got that line count out of thin air. I used "wc -l" on the
> sources, and I didn't count the source of all ports, only /src,
> /include and the Windows-specific directories (and only of .c and .h
> files, not auxiliary ones). Rest assured current NetHack is not as
> lightweight as the Rogue/Hack/NetHack releases of 17 years ago...
> Pre-build binaries' sizes are: Non-windowing, 1728 KB; windowing, 2052
> KB.

Did you find the source here? 
http://cvs.gnome.org/bonsai/rview.cgi?cvsroot=/cvs/gnome&dir=nethack

-- 
Preben Randhol         �For me, Ada95 puts back the joy in programming.�

Re: Nethack! (was): AdaGames

[Ted Dennison]

Juanma Barranquero <lektu@terra.es> wrote in message news:<entiau0hu5ood9gtg5hkfds6vbtnut1qjk@4ax.com>...
> On 1 Apr 2002 07:04:08 -0800, dennison@telepath.com (Ted Dennison)
> wrote:
> 
> >Seeing as I had a version running on a 256K Amiga 17 years ago, I'd
> >say *considerably* less than 200K SLOCS.
> 
> I haven't got that line count out of thin air. I used "wc -l" on the
> sources, and I didn't count the source of all ports, only /src,

Interesting. I usually use "grep -c ";"" for SLOC counting. "wc -l"
just counts newlines, which adds loads of whitespace and comment lines
to the count. Perhaps for a typical C program (and nethack in
particular) it won't make much difference. But for my typical Ada
program, the "wc" method would more than double the count (I'm usually
at about %50 comments, and that doesn't even count the blank lines.)

-- 
T.E.D.
Home     -  mailto:dennison@telepath.com (Yahoo: Ted_Dennison)
Homepage -  http://www.telepath.com/dennison/Ted/TED.html

Re: Nethack! (was): AdaGames

[Juanma Barranquero]

On Tue, 2 Apr 2002 14:54:23 +0000 (UTC), Preben Randhol
<randhol+abuse@pvv.org> wrote:

>Did you find the source here? 
>http://cvs.gnome.org/bonsai/rview.cgi?cvsroot=/cvs/gnome&dir=nethack

From NetHack 3.4.0? I did find it on www.nethack.org.

                                               /Lektu

Re: Nethack! (was): AdaGames

[Juanma Barranquero]

On 2 Apr 2002 10:30:14 -0800, dennison@telepath.com (Ted Dennison)
wrote:

>Interesting. I usually use "grep -c ";"" for SLOC counting. "wc -l"
>just counts newlines, which adds loads of whitespace and comment lines
>to the count.

<sigh> I somewhat suspected this was going to end in a discussion
about the line-counting method used... Using yours, no doubt more
accurate, they're still about 85K.

>But for my typical Ada
>program, the "wc" method would more than double the count (I'm usually
>at about %50 comments, and that doesn't even count the blank lines.)

Well, your original argument was that porting NetHack to Ada was easy,
and even if the sources are 85K SLOCs it is still a very large project
for just one programmer to undertake as a hobby. I think you're
severily underestimating NetHack's size and complexity.

                                                               /Lektu

Re: Nethack! (was): AdaGames

[Preben Randhol]

On 2 Apr 2002 10:30:14 -0800, Ted Dennison wrote:
> Juanma Barranquero <lektu@terra.es> wrote in message news:<entiau0hu5ood9gtg5hkfds6vbtnut1qjk@4ax.com>...
> 
> Interesting. I usually use "grep -c ";"" for SLOC counting. "wc -l"

shouldn't it be: grep -ce ";$" so you don't get all the semicolons in
the definitions of functions/procedures?

-- 
Preben Randhol         �For me, Ada95 puts back the joy in programming.�

Re: Nethack! (was): AdaGames

[Ted Dennison]

Juanma Barranquero <lektu@terra.es> wrote in message news:<d59lauoth400po2r2ketc02mcms91bbk61@4ax.com>...
> On 2 Apr 2002 10:30:14 -0800, dennison@telepath.com (Ted Dennison)
> wrote:
> 
> >Interesting. I usually use "grep -c ";"" for SLOC counting. "wc -l"
> >just counts newlines, which adds loads of whitespace and comment lines
> >to the count.
> 
> <sigh> I somewhat suspected this was going to end in a discussion
> about the line-counting method used... Using yours, no doubt more

I know. I wouldn't have brought it up, except that:
o  An intellectually dishonest person (*not* you of course) could
hardly have found a better way to create themselves huge SLOC counts.
Since you were honest enough to report your method, I figured you'd
care about such perceptions.
o  If that is how you are counting, I have no clue what your numbers
mean, because they bear no relation to numbers I am used to looking
at.

> Well, your original argument was that porting NetHack to Ada was easy,
> and even if the sources are 85K SLOCs it is still a very large project
> for just one programmer to undertake as a hobby. I think you're
> severily underestimating NetHack's size and complexity.

Looking over this thread, I suspect we are talking about two different
things. I won't argue that hand-porting all the existing C code for
the current version of nethack would be a lot of work. However, making
a simple hack-like game that runs would be fairly easy. The way
OpenSource (Bazaar) projects work (I'm using the ESR terminology,
because he's the one who came up with the Cathedral & Bazaar theory),
you don't try to do the whole thing in one go (Cathedral-style). You
make something small that is interesting and runs, release it, then
incrementally improve it. The better it gets, the more people who use
it. The more people who use it, the more who will want to help improve
it. The more it gets improved, the more people use it. etc. So
ideally, things snowball on their own from a relatively small initial
individual investment.

Sure, this process won't net you *the* Nethack. But trying to
hand-port it won't either. By the time you could get done with it, the
C codebase would have moved on.


-- 
T.E.D.
Home     -  mailto:dennison@telepath.com (Yahoo: Ted_Dennison)
Homepage -  http://www.telepath.com/dennison/Ted/TED.html

Re: Nethack! (was): AdaGames

[Marin David Condic]

And, of course, why bother? A C program translated directly into Ada doesn't
really buy you much. Its still the same program with the same features. What
is more interesting is to examine what the program does and possibly utilize
that as a basis for developing a new & more interesting program.

MDC
--
Marin David Condic
Senior Software Engineer
Pace Micro Technology Americas    www.pacemicro.com
Enabling the digital revolution
e-Mail:    marin.condic@pacemicro.com


"Ted Dennison" <dennison@telepath.com> wrote in message
news:4519e058.0204030706.7bd0ed6c@posting.google.com...
>
> Sure, this process won't net you *the* Nethack. But trying to
> hand-port it won't either. By the time you could get done with it, the
> C codebase would have moved on.
>

Re: Nethack! (was): AdaGames

[Ted Dennison]

Preben Randhol <randhol+abuse@pvv.org> wrote in message news:<slrnaaljn7.22e.randhol+abuse@kiuk0156.chembio.ntnu.no>...
> On 2 Apr 2002 10:30:14 -0800, Ted Dennison wrote:
> > Juanma Barranquero <lektu@terra.es> wrote in message news:<entiau0hu5ood9gtg5hkfds6vbtnut1qjk@4ax.com>...
> > 
> > Interesting. I usually use "grep -c ";"" for SLOC counting. "wc -l"
> 
> shouldn't it be: grep -ce ";$" so you don't get all the semicolons in
> the definitions of functions/procedures?

For me no, for two reasons:

  1) It can be argued that defining the interface elemets for
subprograms is work on the same scale as any other ";"-ed line.
  2) ";$" (semi's at the end of the line, for those who don't speak
sed) doesn't get rid of them all anyway. In my code, it wouldn't be
likely to get rid of *any*, as I always put only one formal parameter
definition on a line.
  3) "-c" only counts the *lines* where it appears, not the number of
appearances. Thus even if ";$" *did* skip some single-line parameter
definitions, the resulting count would end up nearly the same.

Generally, I think SLOC is a stupid metric, so tons of effort should
*not* be spent in calculating it or figuring out the perfect way to
calculate it. For that reason, I wouldn't really blink at someone who
uses your method, or most any other method. But methods that count
both comments *and* blank lines are just a bit *too* slack. :-)

-- 
T.E.D.
Home     -  mailto:dennison@telepath.com (Yahoo: Ted_Dennison)
Homepage -  http://www.telepath.com/dennison/Ted/TED.html

Re: Nethack! (was): AdaGames

[Marin David Condic]

I once ran a comparison between raw SLOC, semicolons and Halstead bits on a
large body of Ada code. The correlation between them was so close as to make
the method of counting pretty much irrelavent. The secret is to pick your
metric and then be *consistent* in applying it and use it only in monitoring
internal things within a project. ("SLOCs modified in this release", for
example)

You can't really use any of them to compare what goes on in one
language/project with another anyway. The best it tells you is some gross
level of difference between the size of one thing and another. You might be
able to say "This project has a whole lot more code to look at than that
project" and that's about the extent of its relevance.

MDC
--
Marin David Condic
Senior Software Engineer
Pace Micro Technology Americas    www.pacemicro.com
Enabling the digital revolution
e-Mail:    marin.condic@pacemicro.com


"Ted Dennison" <dennison@telepath.com> wrote in message
news:4519e058.0204030750.78a30287@posting.google.com...
>
> Generally, I think SLOC is a stupid metric, so tons of effort should
> *not* be spent in calculating it or figuring out the perfect way to
> calculate it. For that reason, I wouldn't really blink at someone who
> uses your method, or most any other method. But methods that count
> both comments *and* blank lines are just a bit *too* slack. :-)
>

Re: Nethack! (was): AdaGames

[Bobby D. Bryant]

On Wed, 03 Apr 2002 09:50:45 -0600, Ted Dennison wrote:

>   2) ";$" (semi's at the end of the line, for those who don't speak
> sed) doesn't get rid of them all anyway. In my code, it wouldn't be
> likely to get rid of *any*, as I always put only one formal parameter
> definition on a line.

Also, it misses ;s that are followed by comments.


Somewhere along the way I picked up a perl script by one Christopher
Moore, which reports (pseudo) SLOC, comment lines, blank lines, the
total, and the number of subrountines.  If you give it a wildcard
argument it reports those counts per-sourcefile and totals them at the
bottom.

A Web search turns it up at Adapower,
http://www.adapower.com/reuse/sloc.html, though I use a minorly hacked
version that reports in nice on-screen columns rather than as a
comma-delimeted list.

FWIW, I like to count comment lines as well as lines of code, since they
represent a commitment of effort toward the solution of the problem.

Bobby Bryant
Austin, Texas

Re: Nethack! (was): AdaGames

[Jean-Pierre Rosen]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 743 bytes --]


"Ted Dennison" <dennison@telepath.com> a �crit dans le message news:
> Generally, I think SLOC is a stupid metric, so tons of effort should
> *not* be spent in calculating it or figuring out the perfect way to
> calculate it. For that reason, I wouldn't really blink at someone who
> uses your method, or most any other method. But methods that count
> both comments *and* blank lines are just a bit *too* slack. :-)
>
Depends why you are counting...
For example, when doing a code review, I certainly count (and charge) for comment lines.
They often take longer to review than code...

--
---------------------------------------------------------
           J-P. Rosen (rosen@adalog.fr)
Visit Adalog's web site at http://www.adalog.fr

Re: Nethack! (was): AdaGames

[tmoran]

> A C program translated directly into Ada doesn't really buy you much.
  Attempting the translation will often show up errors in the C program.

Re: Nethack! (was): AdaGames

[Kent Paul Dolan]

"Marin David Condic" <dont.bother.mcondic.auntie.spam@[acm.org> wrote:

> And, of course, why bother? A C program translated directly into Ada doesn't
> really buy you much. Its still the same program with the same features. What
> is more interesting is to examine what the program does and possibly utilize
> that as a basis for developing a new & more interesting program.

Which misses the point by a barn-width.  The goal is to imitate the
success cheesy text-graphics games (see also Empire) had in attracting
lots of the best and brightest programmers to choose to program in C,
back when Pascal was a lot easier to comprehend, and was the teaching
langauge of choice.

So _precisely_ re-implementing all the current intellectual endeavor
invested in Nethack is a fine way to re-implement what we really want to
re-implement -- an enthusiasm attractor.  The content doesn't matter
except that Nethack has already proved its worth and trying to reinvent
whatever made Nethack _work_ as an enthusiasm attractor is arguably a
much harder intellectual chore than "merely" re-implementing Nethack.

xanthian.

Since porting to Ada would put Nethack into a language where the kind of
generics invented in Nethack are naturally implemented as a part of the
language instead of welded into place with ad hoc structures and
concepts, for example, making new, glitzy, ego-satisfying extensions by
students doable by students with a wider range of abilities.


-- 
Posted via Mailgate.ORG Server - http://www.Mailgate.ORG

Re: Nethack! (was): AdaGames

[Kent Paul Dolan]

"tmoran" <tmoran@acm.org> wrote in message
news:rPQq8.1214$UW.702270680@newssvr13.news.prodigy.com...

> > A C program translated directly into Ada doesn't really buy you much.
>   Attempting the translation will often show up errors in the C program.

From reading though the code, what, a dozen years or more ago, inventing
Ada-fied ways to do some of the incredibly slick stuff C programmer
students invented for a language with fairly primitive programming
tools, and reimplementing them flawlessly in a pointerless language, is
going to force you to get thoroughly into bed with Ada, too.

xanthian.



-- 
Posted via Mailgate.ORG Server - http://www.Mailgate.ORG

Re: Nethack! (was): AdaGames

[Juanma Barranquero]

On 3 Apr 2002 07:06:34 -0800, dennison@telepath.com (Ted Dennison)
wrote:

>Since you were honest enough to report your method, I figured you'd
>care about such perceptions.

Yes. I was lazy in my initial count, but that was because I didn't
think important if the result were 100K or 200K or whatever. I just
wanted to show that NetHack is not a "hack" of a few thousand lines,
easy to port to another language as a student project.

>o  If that is how you are counting, I have no clue what your numbers
>mean, because they bear no relation to numbers I am used to looking
>at.

As I've said, using your method count is about 85K.

>Looking over this thread, I suspect we are talking about two different
>things. I won't argue that hand-porting all the existing C code for
>the current version of nethack would be a lot of work. However, making
>a simple hack-like game that runs would be fairly easy.

Well, we violently agree here. What prompted me to intervene in this
conversation was precisely that:

>> Several years ago by now I promoted porting Nethack to Ada as a way to
>> attract college students to the Ada language.  The proposal fell on deaf
>> ears.
>
>As Nethack is fairly simple, its probably something a single person
>could handle. So rather than "promoting" it, why not just do it
>yourself?

So I expect you can see how I understood that you were saying that
porting NetHack (not writing a Rogue/NetHack clone) to Ada was simple.
Now I see you're really saying that writing an Ada rogue would be
easy, or at least interesting. I think the same. Quoting from my first
message:

>Anyway I think it would be better to start a rogue from scratch in Ada
>that try to port NetHack. I've been wishing to find the time to do it
>(develop a new rogue in Ada, I mean) for years... :(

(Sorry for the self-quoting).

So now the only thing lacking is volunteers to write the FARG
(Full-Ada Roguelike Game) :)

                                                                /Lektu

Re: Nethack! (was): AdaGames

[Marin David Condic]

And, as I will attempt to observe again, none of this gets you a program
that is somehow or other substantially different from the original. :-)
Someone might do it as a learning exercise - but I could think of more
productive learning exercises. Someone might clean up some bugs along the
way - but will probably introduce new ones in the process. I just don't see
a lot of food-value in translating an existing program into another
language - unless, possibly, that other language no longer has a compiler
for current technology and you need a translation to something else just to
be able to compile it. (But that seems a bit of a stretch. How frequently
does that happen?)

Anyway, I'll suggest that its a *better* idea to look at something like
Nethack and implement a whole new program that perhaps is "inspired" by its
predecessor but does something new and different. A "Nethack in Ada" is not
likely to set either the Nethack or Ada world afire with newfound enthusiasm
and excitement. :-)

MDC
--
Marin David Condic
Senior Software Engineer
Pace Micro Technology Americas    www.pacemicro.com
Enabling the digital revolution
e-Mail:    marin.condic@pacemicro.com


"Kent Paul Dolan" <xanthian@well.com> wrote in message
news:598d46834b4ac2b4bffabdacf5ced656.48257@mygate.mailgate.org...
> "tmoran" <tmoran@acm.org> wrote in message
> news:rPQq8.1214$UW.702270680@newssvr13.news.prodigy.com...
>
> > > A C program translated directly into Ada doesn't really buy you much.
> >   Attempting the translation will often show up errors in the C program.
>
> From reading though the code, what, a dozen years or more ago, inventing
> Ada-fied ways to do some of the incredibly slick stuff C programmer
> students invented for a language with fairly primitive programming
> tools, and reimplementing them flawlessly in a pointerless language, is
> going to force you to get thoroughly into bed with Ada, too.
>

Re: Nethack! (was): AdaGames

[Ted Dennison]

"Bobby D. Bryant" <bdbryant@mail.utexas.edu> wrote in message news:<a8fd1v$jev$1@geraldo.cc.utexas.edu>...
> Somewhere along the way I picked up a perl script by one Christopher
> Moore, which reports (pseudo) SLOC, comment lines, blank lines, the
> total, and the number of subrountines.  If you give it a wildcard
> argument it reports those counts per-sourcefile and totals them at the
> bottom.

There's also a SLOC counter program written in Ada in OpenToken
(http://www.telepath.com/dennison/Ted/OpenToken/OpenToken.html ) that
gives a similar breakdown. Generally I'd just use grep -c ";" because
its easy to do and easy to remember and tell other people to do. But
I've had managers who insist on some snazzy tool, and that fits the
bill nicely.


-- 
T.E.D.
Home     -  mailto:dennison@telepath.com (Yahoo: Ted_Dennison)
Homepage -  http://www.telepath.com/dennison/Ted/TED.html

Re: Nethack! (was): AdaGames

[Marin David Condic]

If you really believe that all the Nethack enthusiasts will jump on board
the Ada wagon because their favorite game is now translated into Ada, I
wouldn't try to stop you from doing the translation. Its your time and
energy, after all. I'd just suggest that "new", "different", "improved" and
so on, are better marketing tools. Investing time and energy and creative
talent on "new and improved" seems like a better idea to me. "Been there.
Done that. Got the t-shirt." is my gut reaction to translating a program
from one language to another. Maybe other people have a different view, but
I'd suggest that this has yet to be demonstrated.

MDC
--
Marin David Condic
Senior Software Engineer
Pace Micro Technology Americas    www.pacemicro.com
Enabling the digital revolution
e-Mail:    marin.condic@pacemicro.com


"Kent Paul Dolan" <xanthian@well.com> wrote in message
news:5e5278f0957b5b5b7dbff004eb0704cf.48257@mygate.mailgate.org...
>
> Which misses the point by a barn-width.  The goal is to imitate the
> success cheesy text-graphics games (see also Empire) had in attracting
> lots of the best and brightest programmers to choose to program in C,
> back when Pascal was a lot easier to comprehend, and was the teaching
> langauge of choice.
>

Re: Nethack! (was): AdaGames

[Wes Groleau]

> I once ran a comparison between raw SLOC, semicolons and Halstead bits on a
> large body of Ada code. The correlation between them was so close as to make
> the method of counting pretty much irrelavent. The secret is to pick your

This is true as long as the programmers were not
thinking that there would be any reward or punishment
for a higher or lower count.  Take a well-written
module of a reasonable size in any language, and there
are usually ways to greatly change the metric without
changing behavior.

-- 
Wes Groleau
http://freepages.rootsweb.com/~wgroleau

Re: Nethack! (was): AdaGames

[Preben Randhol]

On 3 Apr 2002 07:50:45 -0800, Ted Dennison wrote:
> Preben Randhol <randhol+abuse@pvv.org> wrote in message news:<slrnaaljn7.22e.randhol+abuse@kiuk0156.chembio.ntnu.no>...
>> On 2 Apr 2002 10:30:14 -0800, Ted Dennison wrote:
>> > Interesting. I usually use "grep -c ";"" for SLOC counting. "wc -l"
>> 
>> shouldn't it be: grep -ce ";$" so you don't get all the semicolons in
>> the definitions of functions/procedures?
> 
> For me no, for two reasons:
> 
>   1) It can be argued that defining the interface elemets for
> subprograms is work on the same scale as any other ";"-ed line.
>   2) ";$" (semi's at the end of the line, for those who don't speak
> sed) doesn't get rid of them all anyway. In my code, it wouldn't be
> likely to get rid of *any*, as I always put only one formal parameter
> definition on a line.
>   3) "-c" only counts the *lines* where it appears, not the number of
> appearances. Thus even if ";$" *did* skip some single-line parameter
> definitions, the resulting count would end up nearly the same.

Yes and also you loose for:

   if sth then
   elsif sth then
   else
   end if;

This would be 1, but it should be 3 ? I'm not sure how a SLOC is
defined.

Preben

Re: Nethack! (was): AdaGames

[Ted Dennison]

Juanma Barranquero <lektu@terra.es> wrote in message news:<1ntnau8q4vfj5sj2srpa22kk71bntldhl2@4ax.com>...
> >Anyway I think it would be better to start a rogue from scratch in Ada
> >that try to port NetHack. I've been wishing to find the time to do it
> >(develop a new rogue in Ada, I mean) for years... :(
> 
> (Sorry for the self-quoting).
> 
> So now the only thing lacking is volunteers to write the FARG
> (Full-Ada Roguelike Game) :)

(I have the same point here, but I'll try a different tack this time.)

You are trying to put the cart before the horse. OpenSource projects
don't generally work like that. They have a natural lifecycle, which
starts with only a single individual. ESR goes over this in detail in
his writings at http://www.tuxedo.org/~esr/writings/ (particularly the
first two). The executive summary would go something like this:

1) One Motivated Individual (MI) writes something useful (perhaps
marginally) that works, and releases it.
2) Others try it out and like it. Some of them become MIs.
3) MIs improve the product a bit, and release their improvements.
4) goto 2.

Its silly to go looking for loads of MIs before you have a product. So
what AdaHack needs (assuming it needs anything) is the first MI to get
it started.

The initial point I was attempting to make was that its silly to go
out and try to recruit loads of people to do something like this. If
you want it done, go write something and release it!

-- 
T.E.D.
Home     -  mailto:dennison@telepath.com (Yahoo: Ted_Dennison)
Homepage -  http://www.telepath.com/dennison/Ted/TED.html

Re: Nethack! (was): AdaGames

[Marin David Condic]

Its hard to collect metrics without having at least *some* of the developers
feeling that they will be rewarded or punished on the basis of the data you
collect. Hence, there's always *some* incentive to cheat. However, at least
in the studies I was involved in, there was a lot of grumbling about
metrics, but I never saw any obvious attempts to inflate or otherwise doctor
the measurements of code size.

Whatever you use: SLOCs, Semicolons, Halstead Bits, Source Bytes, Object
Bytes, anything. They all have weaknesses & can be artificially controlled.
But what choices do we have? We need some means of at least roughly
approximating code size or we might as well give up on trying to measure &
understand what we do. (I've been told by just about all of the developers I
ever collected metrics from that this would be just fine with them. However
after years of doing it, we were definitely able to see improvements in our
processes.)

MDC
--
Marin David Condic
Senior Software Engineer
Pace Micro Technology Americas    www.pacemicro.com
Enabling the digital revolution
e-Mail:    marin.condic@pacemicro.com


"Wes Groleau" <wesgroleau@despammed.com> wrote in message
news:3CAC7AC6.A6DBDC32@despammed.com...

>
> This is true as long as the programmers were not
> thinking that there would be any reward or punishment
> for a higher or lower count.  Take a well-written
> module of a reasonable size in any language, and there
> are usually ways to greatly change the metric without
> changing behavior.
>

RE: Nethack! (was): AdaGames

[Mário Amado Alves]

>> I once ran a comparison between raw SLOC, semicolons and Halstead
bits 
>> on a large body of Ada code. The correlation between them was so
close 
>> as to make the method of counting pretty much irrelavent. The secret 
>> is to pick your

> This is true as long as the programmers were not
> thinking that there would be any reward or punishment
> for a higher or lower count.  Take a well-written
> module of a reasonable size in any language, and there
> are usually ways to greatly change the metric without
> changing behavior.

You're both right. I also did a study correlating program text metrics
and actual development cost in programmers*month. SLOC had the best
results, notably beating Halstead. It was a small project (10k SLOCs if
I remember correctly), but it was unbiased i.e. the programmers didn't
know about the metrics in advance.

Re: Nethack! (was): AdaGames

[Marin David Condic]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 1130 bytes --]

You're saying that SLOCs/month was a larger number than
Halstead-Bits/month?(id est, 1 programmer for 1 month produces 1 module that
measures at 1000 SLOC or 500 Halsteads?) I wouldn't be surprised, but that
wasn't what I meant. I meant that there was a really high correlation
between SLOC, Semicolons & Halsteads - you could pretty much write an
equation of the form: "Halsteads = (M * SLOCs) + B" and have it be pretty
darned close to being right on the money.

Or are you saying something different?

MDC
--
Marin David Condic
Senior Software Engineer
Pace Micro Technology Americas    www.pacemicro.com
Enabling the digital revolution
e-Mail:    marin.condic@pacemicro.com


"M�rio Amado Alves" <maa@liacc.up.pt> wrote in message
news:mailman.1017939422.18187.comp.lang.ada@ada.eu.org...
>
> You're both right. I also did a study correlating program text metrics
> and actual development cost in programmers*month. SLOC had the best
> results, notably beating Halstead. It was a small project (10k SLOCs if
> I remember correctly), but it was unbiased i.e. the programmers didn't
> know about the metrics in advance.
>

Nethack! (was): AdaGames

[Alexandre E. Kopilovitch]

Wes Groleau <wesgroleau@despammed.com> wrote:
>Take a well-written
>module of a reasonable size in any language, and there
>are usually ways to greatly change the metric without
>changing behavior.
This is an interesting idea indeed - there should be automated tools for that.
I mean the tools specially designed for manipulation of those metrics, which
are in common use. Naturally, a measurment is the first step of a science/technology,
and the next step is a targetted manipulation.


Alexander Kopilovitch                      aek@vib.usr.pu.ru
Saint-Petersburg
Russia

Re: Nethack! (was): AdaGames

[Juanma Barranquero]

On 4 Apr 2002 08:46:28 -0800, dennison@telepath.com (Ted Dennison)
wrote:

>You are trying to put the cart before the horse.

No, not really, because I'm not trying to start an Ada roguelike
project. It wasn't me who suggested it, I just jumped in the thread to
talk about NetHack's size and quality :)

> ESR goes over this in detail in his writings at
> http://www.tuxedo.org/~esr/writings/

Also, I think I have less faith in ESR's writings and ideas that you
do... I like open source, but I'm not religious about it. I even go as
far as admiting I like some Microsoft products, and I'd rather work
and program with NT/2k/XP than any Unix/Linux.

>Its silly to go looking for loads of MIs before you have a product. So
>what AdaHack needs (assuming it needs anything) is the first MI to get
>it started.

Rest assured that if I ever think it worthwhile to start writing an
Ada roguelike, I'll start it myself, and perhaps even maintain it so.
One of the more succesful and original roguelikes around (and the only
one I'd put as high as NetHack on a quality basis), ADOM (www.adom.de)
is the work of just one person who's not released his code because he
does not like the idea of other people disrupting his vision.
Undoubtedly unfashionable at this time of politically-correct open
sourcing, but the game is *very* good...

                                                               /Lektu

Re: Nethack! (was): AdaGames

[Ted Dennison]

Wes Groleau <wesgroleau@despammed.com> wrote in message news:<3CAC7AC6.A6DBDC32@despammed.com>...
> > I once ran a comparison between raw SLOC, semicolons and Halstead bits on a
> > large body of Ada code. The correlation between them was so close as to make
> > the method of counting pretty much irrelavent. The secret is to pick your
> 
> This is true as long as the programmers were not
> thinking that there would be any reward or punishment
> for a higher or lower count.  Take a well-written
> module of a reasonable size in any language, and there
> are usually ways to greatly change the metric without
> changing behavior.

The first project I worked on out of school used "statement count"
(essentially ";"s, but declarations didn't count) for predicting code
size and tracking progress during development. When I noticed that
people were being harrassed based on how the metric came out every
week, I sort of rebelled (I know, you're thinking, "surely not *you*
Ted?"). For about a month I added and deleted "null;" statements to my
code every week to make the count for every unit come in conspicuously
*perfect*.

Then there was the week I decided to refactor several badly designed
units, and got a visit from a bemused team lead mock-castigating me
for making *negative* progress that week. :-)


-- 
T.E.D.
Home     -  mailto:dennison@telepath.com (Yahoo: Ted_Dennison)
Homepage -  http://www.telepath.com/dennison/Ted/TED.html

Re: Nethack! (was): AdaGames

[Marin David Condic]

"Ted Dennison" <dennison@telepath.com> wrote in message
news:4519e058.0204050643.30f2e516@posting.google.com...
>
> Then there was the week I decided to refactor several badly designed
> units, and got a visit from a bemused team lead mock-castigating me
> for making *negative* progress that week. :-)
>
>
Another Helpful Household Hint is to always insert spurious delay statements
in any new body of code. That way, when your users start complaining about
the performance that is beyond your control, you can at least immediately
take out the delay statements and say "Well I got you a 25% improvement with
some quick code changes - be patient and I'll keep working on the harder
problems..." Then, of course, you do nothing and wait for the next
generation of hardware to come along and fix your problems for you. :-)

MDC
--
Marin David Condic
Senior Software Engineer
Pace Micro Technology Americas    www.pacemicro.com
Enabling the digital revolution
e-Mail:    marin.condic@pacemicro.com