Sub: Minutes of your RT Conference.

>From Steno: Jennifer Marlowe

Date: 01/28/88   Time: 22:22EST
Attendees:
[[Dennis] D.RUFFER]
[[Kevin] APPERT]
[[CARLTON] C.RUBIO]
[[jwoehr] JAX]

Minutes:
<APPERT> is here.
<D.RUFFER> hello kevin
<[Kevin] APPERT> hi, Dennis
<[Dennis] D.RUFFER> what's on the agenda tonight?
<[Kevin] APPERT> Kinda Quiet
<[Dennis] D.RUFFER> nobody else has shown up yet
<[Kevin] APPERT> we do something at the sunnyvale...
<[Kevin] APPERT> meetings called "Proust Summarizing"...
<[Kevin] APPERT> after the monty python bit...
<[Kevin] APPERT> everybody gets up and does a short ...
<[Kevin] APPERT> description of what they use Forth for...
<[Kevin] APPERT> (kinda like the intros on GEnie
<[Kevin] APPERT> ga
<[Dennis] D.RUFFER> ok
<[Dennis] D.RUFFER> usually, finding something to get everybody talking...
<[Dennis] D.RUFFER> has not been a problem....
<[Dennis] D.RUFFER> but tonight, it seems kind of dead...
<[Dennis] D.RUFFER> what do you do with Forth?
<[Dennis] D.RUFFER> ga
<[Kevin] APPERT> doif nobody shows up...
<[Kevin] APPERT> in 15 min or so, will call it a wash.  I build
<[Kevin] APPERT> space instruments at work
<[Kevin] APPERT> and use forth mostly for an assembly language ...
<[Kevin] APPERT> progrramming environment...
<[Kevin] APPERT> sure beats expensive, slow micro development systems...
<[Kevin] APPERT> Forth takes the place of the assembler, the debugger, the 
<[Kevin] APPERT> emulator
<[Kevin] APPERT> and all that stuff...
<[Kevin] APPERT> There is a host machine (with terminal, disk drives etc)...
<[Kevin] APPERT> and a target.   The target usually starts out as a...
<[Kevin] APPERT> cheap, single board computer off the shelf...
<[Kevin] APPERT> with a monitor rom and the other things you usually find on
<[Kevin] APPERT> an evaluation board...
<[Kevin] APPERT> You can get buy with just the monitor rom on the target...
<[Kevin] APPERT> and Forth types in your code to the "substitute" command on the
<[Kevin] APPERT> rom.  You can then procede to get your code up, or get Forth 
<[Kevin] APPERT> up on
<[Kevin] APPERT> the target and use that to get your final product out the door.
<[Kevin] APPERT>  The
<[Kevin] APPERT> thing I'm working on (off and on) at the moment is a debugger 
<[Kevin] APPERT> for the
<[Kevin] APPERT> nsc800 (z80 instruction set) like Charles Curley's great
<[Kevin] APPERT> one for the 8088.  It single steps, traps and does all sorts of
<[Kevin] APPERT> spiffy stuff.  you have all the power of Forth to decide what
<[Kevin] APPERT> things you want to look at --- any data, address combination or
<[Kevin] APPERT> sequence of combinations are fair game.
<[Kevin] APPERT> The microwave just dinged.  back in a sec.  ga
<[Dennis] D.RUFFER> micrwave? Does that mean your eating?
<[Kevin] APPERT> < not eating yet, waiting for done (5 more min)
<[Kevin] APPERT> :)
<[Kevin] APPERT> ga
<[Dennis] D.RUFFER> ok :-)
<[Dennis] D.RUFFER> your' working on nsc800...
<[Dennis] D.RUFFER> is pretty close to mine on 8080/85s...
<[Dennis] D.RUFFER> we make automtive test equipment....
<[Dennis] D.RUFFER> like the big brown boxes hanging from the ceilings...
<[Dennis] D.RUFFER> of most Firestone stores...
<[Dennis] D.RUFFER> we make our own cpu boards, so...
<[Dennis] D.RUFFER> we got rid of the monitor PROM a long time ago...
<[Dennis] D.RUFFER> it sounds like we talk with them the same tho...
<[Dennis] D.RUFFER> through an RS-232 port...
<[Dennis] D.RUFFER> I've developed a "target interpreter"...
<[Dennis] D.RUFFER> that allows me to interactively test any Forth...
<[Dennis] D.RUFFER> word in the target dictionary...
<[Dennis] D.RUFFER> at one time I had the capability to single step...
<[Dennis] D.RUFFER> but it slowed down NEXT too much, and I took it out...
<[Dennis] D.RUFFER> Otherwise it works pretty good at debugging...
<[Dennis] D.RUFFER> if your interested, I can go through....
<[Dennis] D.RUFFER> the basics of the protocol.
<[Dennis] D.RUFFER> ga
<[Kevin] APPERT> what we develop is machine code as final product.
<[Kevin] APPERT> we don't fly Forth (*yet*)
<[Kevin] APPERT> the mechanisim for stopping or stepping is a break
<[Kevin] APPERT> and that doesn't slow anything down until you hit it.
<[Kevin] APPERT> to trigger, or single step, it's verry slow, of course.
<[Kevin] APPERT> sure. why don't you hum a few bars of your protocol. ga
<[Dennis] D.RUFFER> ok
<[Dennis] D.RUFFER> I start by defining a few commands...
<[Dennis] D.RUFFER> fetch and store to a memory address
<[Dennis] D.RUFFER> fetch and store to stack...
<[Dennis] D.RUFFER> and the same with I/O ports...
<[Dennis] D.RUFFER> then one last command is to execute an address...
<[Dennis] D.RUFFER> the memory access stuff, allows me to look at and change 
<[Dennis] D.RUFFER> memory
<[Dennis] D.RUFFER> the same with the port commands...
<[Dennis] D.RUFFER> execution is defined to just do an EXECUTE...
<[Dennis] D.RUFFER> but would be easy to change to do a JMP...
<[Dennis] D.RUFFER> that with the stack commands, allows me to...
<[Dennis] D.RUFFER> define a simple interpreter...
<[Dennis] D.RUFFER> first the protocol, is something simple...
<[Dennis] D.RUFFER> that works on a hardware cludge that doesn't allow
<[Dennis] D.RUFFER> received bytes to be overwritten...
<[Dennis] D.RUFFER> that low level isn't important, but the bytes I send are...
<[Dennis] D.RUFFER> the command is 1 byte (acknowledged)...
<[Dennis] D.RUFFER> then there will be multiple bytes...
<[Dennis] D.RUFFER> depending on the command...
<[Dennis] D.RUFFER> Oh, and I almost forgot that I have...
<[Dennis] D.RUFFER> memory block transfers (with check sum)...
<[Dennis] D.RUFFER> to speed up downloads to program RAM...
<[Dennis] D.RUFFER> The RAM is just development stuff to replaced by
<[Dennis] D.RUFFER> EPROM in the product...
<[Dennis] D.RUFFER> ok, so I just cross compile the application...
<[Dennis] D.RUFFER> and while I still have the compile headers in memory...
<[Dennis] D.RUFFER> I download the target memory from the compile space
<[Dennis] D.RUFFER> (usually high memory on a PC)...
<[Dennis] D.RUFFER> and enter my little interpreter...
<[Dennis] D.RUFFER> in "T-GO" mode, words that you type...
<[Dennis] D.RUFFER> are first looked up in the "TARGET" dictionary...
<[Dennis] D.RUFFER> if found there, they are passed to the target for execution.
<[Dennis] D.RUFFER> if they are in the resident Forth, they are executed 
<[Dennis] D.RUFFER> locally...
<[Dennis] D.RUFFER> If the word is a number, it is passed to the target stack...
<[Dennis] D.RUFFER> I think that is the gist of it (off the top of my head)...
<[Dennis] D.RUFFER> don't know how it would work for "pure assembler"....
<[Dennis] D.RUFFER> but just thought it might give you some ideas.
<[Dennis] D.RUFFER> ga
<[Kevin] APPERT> you'd probably want...
<[Kevin] APPERT> to treat it like jsr...
<[Kevin] APPERT> threaded Forth...
<[Kevin] APPERT> which is what most of my assy lang.
<[Kevin] APPERT> looks like anyway.  This doesn't
<[Kevin] APPERT> get you single stepping or any
<[Kevin] APPERT> of that neet stuff, but the next step is
<[Kevin] APPERT> to add in breakpoints...
<[Kevin] APPERT> then a disassembler...
<[Kevin] APPERT> then the single stepper.
<[Kevin] APPERT> do you have a requirement
<[Kevin] APPERT> that host=target processor
<[Kevin] APPERT> ? ga
<[Dennis] D.RUFFER> no I don't
<[Dennis] D.RUFFER> we started a long long time ago with...
<[Dennis] D.RUFFER> a polyForth cross compiler...
<[Dennis] D.RUFFER> and I've been "maintaining it along" up to our...
<[Dennis] D.RUFFER> current F83 dev sys on IBM PCs...
<[Dennis] D.RUFFER>
<[Dennis] D.RUFFER> you wouldn't need jsr's...
<[Dennis] D.RUFFER> there is always a "common exit" point...
<[Dennis] D.RUFFER> that you could just jump back to...
<[Dennis] D.RUFFER> after the "word" has executed...
<[Dennis] D.RUFFER> you have to send back an acknowledgment...
<[Dennis] D.RUFFER> to the "host" processor...
<[Dennis] D.RUFFER> the breakpoints are just "software interrupts"...
<[Dennis] D.RUFFER> that are patched into the code...
<[Dennis] D.RUFFER> they would jump to a "breakpoint" interrupt...
<[Dennis] D.RUFFER> that would make the appropriate responses...
<[Dennis] D.RUFFER> to the host.
<[Dennis] D.RUFFER> Seems possible, but I haven't had the need...
<[Dennis] D.RUFFER> to take it that far.
<[Dennis] D.RUFFER> we also have "hardare logic analyzers"
<[Dennis] D.RUFFER> we "clip on" our NWIS Logic Analyzer...
<[Dennis] D.RUFFER> and look at the assembler...
<[Dennis] D.RUFFER> so what you need, I have hardware for.
<[Dennis] D.RUFFER> ga
<[Kevin] APPERT> we have an arium (good , cheep)...
<[Kevin] APPERT> logic analyzer for that.  Is it desireable to have an analog
<[Kevin] APPERT> to NEXT in your code?
<[Kevin] APPERT> or does it come out later?
<[Kevin] APPERT> ga
<C.RUBIO> is here.
<[Dennis] D.RUFFER> ok
<[Kevin] APPERT> hi C, use /name for your first name
<C.RUBIO> HI/NAME
<C.RUBIO> SORRY
<C.RUBIO> MY NAME IS CARLTON
<[Dennis] D.RUFFER> the NEXT is not neccessary...hello carlton
<[Kevin] APPERT> type /name Carlton
<[Dennis] D.RUFFER> type the /name at the beginning of the line
<[Dennis] D.RUFFER> we use a sort of protocol
<[Dennis] D.RUFFER> you type !! to get a word in...
<[Dennis] D.RUFFER> then you wait for a "ga" from one of us...
<[Dennis] D.RUFFER> when you are done, you type "ga" to let...
<[Dennis] D.RUFFER> us know and I will hand it off ...
<[Dennis] D.RUFFER> to the next person...
<[Dennis] D.RUFFER> we were talking (Kevin and I) about targeting...
<[Dennis] D.RUFFER> (debugging) turnkey applications...
<[Dennis] D.RUFFER> I guess you would call them that...
<[Dennis] D.RUFFER> nsc800, Z-80 and 8080/5 type stuff...
<[Dennis] D.RUFFER> shall we continue?   ga
<[CARLTON] C.RUBIO> !! I WOULDNT BE MUCH IN THE CONVERSATION AS I AM ...
<[CARLTON] C.RUBIO> NEW TO THE FORTH WORLD ( AND MY PROCESSOR EXPERIENCE IS 
<[CARLTON] C.RUBIO> MAINLY WITH TI 9900 SERIES )
<[CARLTON] C.RUBIO> GA
<[Dennis] D.RUFFER> ok
<[CARLTON] C.RUBIO> !!
<[Dennis] D.RUFFER> ga carlton
<[CARLTON] C.RUBIO> I AM INVOLVED WITH TURNKEY APPLICAT...
<[CARLTON] C.RUBIO> IONS HOWEVER IN THE 9900 WORLD SO PLEASE DONT STOP ON MY 
<[CARLTON] C.RUBIO> ACCOUNT
<[Dennis] D.RUFFER> ok
<[Dennis] D.RUFFER> please type "ga" when your done....
<[CARLTON] C.RUBIO> ga
<[Dennis] D.RUFFER> then were were we?
<[Dennis] D.RUFFER> oh yes
<[Kevin] APPERT> !!
<[Dennis] D.RUFFER> Next does not have to be in an assembler...
<[Dennis] D.RUFFER> application, and the "interpreter" does not need it...
<[Dennis] D.RUFFER> all the "interpreter" knows, is addresses...
<[Dennis] D.RUFFER> it executes something and the results...
<[Dennis] D.RUFFER> are put on it's own stack...
<[Dennis] D.RUFFER> the interpreter does a "stack check" on the target...
<[Dennis] D.RUFFER> but it is up to other words...
<[Dennis] D.RUFFER> to interpret the results...
<[Dennis] D.RUFFER> ok Kevin?
<[Dennis] D.RUFFER> ga
<[Kevin] APPERT> but to get back from your code...
<[Kevin] APPERT> you either have to jump at the end (different from...
<[Kevin] APPERT> how it will really be...)
<[Kevin] APPERT> or you hit a RET, and pop back to the monitor
<[Kevin] APPERT> or maybe I misunderstood you? ga
<[Dennis] D.RUFFER> ok
<[Dennis] D.RUFFER> this does take a small bit of code...
<[Dennis] D.RUFFER> in the target to know what the interpreter...
<[Dennis] D.RUFFER> is trying to do...
<[Dennis] D.RUFFER> I use a vector table with entries...
<[Dennis] D.RUFFER> for each command...
<[Dennis] D.RUFFER> I also have a routine that is fetching...
<[Dennis] D.RUFFER> the commands, like a monitor...
<[Dennis] D.RUFFER> it could do a subroutine call...
<[Dennis] D.RUFFER> and then the "common exit" could be a RET...
<[Dennis] D.RUFFER> that would fit better with assembler.
<[Dennis] D.RUFFER> ga
<[Kevin] APPERT> yea, that's what I was saying a little while ago.  This...
<JAX> is here.
<[Kevin] APPERT> allows you to call lower 'words' without changing them or 
<[Kevin] APPERT> finding yourself...
<[Kevin] APPERT> back in the monitor
<[Kevin] APPERT> what do you do with 9900 carlton?
<[CARLTON] C.RUBIO> !!
<[Kevin] APPERT> ga
<[Dennis] D.RUFFER> ga carlton
<[CARLTON] C.RUBIO> MMY COMPANY DEVELOPED A LIGHTING CONTROL BOARD BASED ON THE 
<[CARLTON] C.RUBIO> 9900 IN THE LATE ...
<[CARLTON] C.RUBIO> SEVENTIES SINCE THEN WE HAVE STAYED WITH THE TI 99000 
<[CARLTON] C.RUBIO> SERIES ...
<[CARLTON] C.RUBIO> TO MAINTAIN COMPATABILITY WITH OUR OLDER STUFF...
<[CARLTON] C.RUBIO> CURRENTLY WE ARE LOOKING TO THE FASTER PROCESSORS (68000, 
<[CARLTON] C.RUBIO> 80286 )...
<[CARLTON] C.RUBIO> ANYWAY I FOUND FORTH AND AM TRYING TO GET THE HANG OF IT SO 
<[CARLTON] C.RUBIO> THAT THE NEXT ...
<[CARLTON] C.RUBIO> GENERATION CONTROLLERS CAN BE PROGRAMMED IN IT INSTEAD OF 
<[CARLTON] C.RUBIO> ASSEMBLER ga
<[Kevin] APPERT> it's a good processor, like 9989 a lot.
<[Dennis] D.RUFFER> welcome jack and ga
<[Kevin] APPERT> ga
<[CARLTON] C.RUBIO> !!
<[jwoehr] JAX> hey, not to be an s*disturber, but this politeness stuff is 
<[jwoehr] JAX> expensive. Some
<[CARLTON] C.RUBIO> ITS A DATED PROCESSOR WITH A LOT OF GOOD ...
<[jwoehr] JAX> confs are a little free form, and it gets confoozin, but more 
<[jwoehr] JAX> gets tossed
<[jwoehr] JAX> about ... ga :-)
<[Dennis] D.RUFFER> ok
<[CARLTON] C.RUBIO> OK ga
<[Dennis] D.RUFFER> was that enough confooosion?  :-)
<[Kevin] APPERT> I understood.
<[jwoehr] JAX> that was pretty good but still legible! :-)
<[Dennis] D.RUFFER> I've had more complaints about that type...
<[Dennis] D.RUFFER> of conference that like this...
<[jwoehr] JAX> We just gotta be polite to each other. We're friends
<[CARLTON] C.RUBIO> SOUNDS GOOD to me
<[Dennis] D.RUFFER> I really don't care since it's this late..  :-)
<[jwoehr] JAX> Did a node of Genie go off line tonite?
<[Dennis] D.RUFFER> which one?
<[Kevin] APPERT> how do you tell?
<[Kevin] APPERT> why would you care?
<[CARLTON] C.RUBIO> what applications have you guys used forth in
<[Dennis] D.RUFFER> type "port" at prompt
<[jwoehr] JAX> seven --- other conf was comlainning
<[jwoehr] JAX> real-time
<[Dennis] D.RUFFER> could be jack, call cust serv, they can check...
<[Kevin] APPERT> < Ibuilds space instruments
<[CARLTON] C.RUBIO> fascinating can you elaborate
<[Kevin] APPERT> use Forth for Ground support and to put the code in the flight 
<[Kevin] APPERT> box
<[CARLTON] C.RUBIO> how do you make forth rommable ???
<[Kevin] APPERT> we build sattalite payload stuff mostly
<[jwoehr] JAX> Metacompile, CRUBIO
<[Kevin] APPERT> 1) (easy way) move the rom into ram
<[CARLTON] C.RUBIO> i am new to this
<[Kevin] APPERT> 2) put everything which changes in RAM
<[Dennis] D.RUFFER> buy a vendors "cross compiler"
<[Kevin] APPERT> FORTH inc's polyFORTH is good
<[jwoehr] JAX> Forth is in the romFree cross compiler === F83LP metacompiler. 
<[jwoehr] JAX> CHTING for examples
<[Kevin] APPERT> you can buy training...
<[CARLTON] C.RUBIO> whats chting
<[Kevin] APPERT> but it's all expensive
<[jwoehr] JAX> Good question
<[Kevin] APPERT> DR. C.H. TING
<[Kevin] APPERT> world renowned Forthnick
<[jwoehr] JAX> The voice of f83lp
<[CARLTON] C.RUBIO> oh sorry  I am not good with names
<[jwoehr] JAX> And a heckuva nice guy!
<[jwoehr] JAX> " Not puffed up"
<[Kevin] APPERT> author of numerous articles and a couple of books
<[CARLTON] C.RUBIO> is a forth type real world program as fast as an assembler
<[jwoehr] JAX> Among which is FOrth Notes Volume 2.
<[Kevin] APPERT> and editor of the "more about nc4000" series
<[jwoehr] JAX> Forth is mostly assembler. Some forths are faster than others
<[Kevin] APPERT> only where it has to be...
<[Kevin] APPERT> you don't waste your time speeding up things which
<[Kevin] APPERT> can afford to run slow...
<[jwoehr] JAX> But since you can access assembler
<[Kevin] APPERT> the most important thing in Forth
<[Kevin] APPERT> is the speed with which you generate the software which
<[Kevin] APPERT> solves your problem.
<[jwoehr] JAX> AMen
<[Kevin] APPERT> you first get it working in high level...]
<[CARLTON] C.RUBIO> i found that to be true in my first experiments with forth
<[Kevin] APPERT> and if that isn't fast enough...
<[jwoehr] JAX> Forth is a way for two guys to do what it takes three C progs to 
<[jwoehr] JAX> do
<[CARLTON] C.RUBIO> !!
<[Kevin] APPERT> you go back and code the inner loops in assy.
<[Dennis] D.RUFFER> only 3 :-)
<[Dennis] D.RUFFER> ga carlton
<[CARLTON] C.RUBIO> thats what i wanted to hear
<[CARLTON] C.RUBIO> GA
<[Kevin] APPERT> Forth is a great assy lang debugger
<[CARLTON] C.RUBIO> WHOA
<[jwoehr] JAX> Watch your language! :-)
<[CARLTON] C.RUBIO> MY FORTH ...
<[Kevin] APPERT> and you call CODE words (assy lang) just like any forth word
<[jwoehr] JAX> it's like an interpretive UNIX that lives in 64 K
<[CARLTON] C.RUBIO> WILL NOT LET ME DEBUG CODE WORDS SO HOW CAN IT BE A GOOD 
<[CARLTON] C.RUBIO> ASSY DEBUGGER
<[jwoehr] JAX> If it dont yet, make it do it.
<[Kevin] APPERT> ^^^^^^^^^^fat forth = 64 K
<[Kevin] APPERT> can you execute a code word?
<[jwoehr] JAX> fat forth? JForth recommmended development image 125K
<[CARLTON] C.RUBIO> OKAY FOR YOU BUT WHERE DID YOU GET THE DEBUGGER
<[jwoehr] JAX> Write it
<[Dennis] D.RUFFER> ah the "power" of Forth
<[CARLTON] C.RUBIO> CAN WE GO BACK TO THE OLD WAY OF SPEAKING ???
<[CARLTON] C.RUBIO> THIS IS CONFOOZING
<[Dennis] D.RUFFER> ok with me
<[Kevin] APPERT> debug =ok by me
<[Kevin] APPERT> !!
<[jwoehr] JAX> Put sysWga
<[Dennis] D.RUFFER> i thought so tooo
<[Dennis] D.RUFFER> ga kevin
<[CARLTON] C.RUBIO> !!
<[CARLTON] C.RUBIO> OK TO A NEEWCOMER ...
<[Kevin] APPERT> simple debug = execute code word, then examine results
<[CARLTON] C.RUBIO> I HGA
<[Kevin] APPERT> most any forth with an assembler will do this...
<[Kevin] APPERT> you break your problem into  word-sized chunks...
<[Kevin] APPERT> and debug the pieces. ga carlton
<[CARLTON] C.RUBIO> !!
<[Kevin] APPERT> yes, you . go ahead carlton
<[CARLTON] C.RUBIO> I read in forth dim aabout a assy debugger but the way it
<[CARLTON] C.RUBIO> was written was to confusing for me to figure out ...
<[jwoehr] JAX> 300 baud
<[CARLTON] C.RUBIO> I think it may have been written in a different forth ( i 
<[CARLTON] C.RUBIO> use masterforth on an ...
<[CARLTON] C.RUBIO> apple and E.L forth on a TI 990/101 board ) ...
<[CARLTON] C.RUBIO> and still coudnt figure it   gA
<[jwoehr] JAX> Dig it ... break it up ...
<[jwoehr] JAX> into a series of operations
<[jwoehr] JAX> that you wish to perfom ..
<[jwoehr] JAX> And code it. It is easier to do it ...
<[jwoehr] JAX> that way than to figger out other peaople's code ...
<[jwoehr] JAX> tho doing that too can be verry ejjicational.
<[jwoehr] JAX> ga
<[CARLTON] C.RUBIO> AHA GA
<[Kevin] APPERT> you just have to
<[Kevin] APPERT> be sure not to code anything...
<[Kevin] APPERT> thats larger than you can look at, and see
<[Kevin] APPERT> why it isn't working.  when you do that you'll
<[Kevin] APPERT> find it works most times anyway.
<[Kevin] APPERT> ga
<[CARLTON] C.RUBIO> !!
<[jwoehr] JAX> Really, ...
<[Dennis] D.RUFFER> ]Iok
<[jwoehr] JAX> By the time ...
<[Dennis] D.RUFFER> ga carlton
<[CARLTON] C.RUBIO> THAnks guys ga
<[jwoehr] JAX> ... you are looking for the debugger entry in the manual ...
<[jwoehr] JAX> chances are 50 - 50 ...
<[jwoehr] JAX> that it's in the hardware. Logic is first resort. Debugger is 
<[jwoehr] JAX> last. ga
<[Dennis] D.RUFFER> ok
<[Dennis] D.RUFFER> well it's gettin late folks...
<[Kevin] APPERT> !!
<[Dennis] D.RUFFER> shall we call it a night?
<[Dennis] D.RUFFER> ga kevin
<[Kevin] APPERT> thanks for your patience....
<[Kevin] APPERT> with us anarchists...
<[Kevin] APPERT> maybe Jax will start up another 'bar'
<[Kevin] APPERT> on another night, more free form.  I
<[Kevin] APPERT> will be there. good night all ga
<[Dennis] D.RUFFER> ok
<[CARLTON] C.RUBIO> !! thanks for all the info people i will stop by again
<[Dennis] D.RUFFER> whenever you want to Kevin...
<[Dennis] D.RUFFER> we can do this, or you can...
<[Dennis] D.RUFFER> anytime you can get people to come in...
<[Dennis] D.RUFFER> any last comments?   ga
<[CARLTON] C.RUBIO> none here
<[jwoehr] JAX> : bye-bye ( ---) 2 0 do bye loop ;
<[Kevin] APPERT> :-)
<[CARLTON] C.RUBIO> cute
<[jwoehr] JAX> Next time.
<[jwoehr] JAX> has left.
<[Kevin] APPERT> has left.
<[Dennis] D.RUFFER> good night folks!
<[CARLTON] C.RUBIO> has left.
=== End of Steno notes. ===