
> >
>
> The value is at the moment hardcoded in the program, but we can let the
> user define it by adding a new setting in the Preferences dialog.
Once again, I'm not a GUI person, so feel free to ignore me. But I
think that might be the start of a path to having too many unnecessary
preferences. For that type of think, I think it is better to either get
a sane default, or make it so you can expand the size by dragging the
border (I don't have time a the moment to see if that is possible).
Another option might be to expand the character limit a bit if it makes
sense, and then have tooltips that will show the entire title.
Just a few thoughts.
--
Zachary P. Landau
GPG: gpg --recv-key 0x24E5AD99 | http://kapheine.hypa.net/kapheine.asc
-------------- next part --------------
A non-text attachment was scrubbed...
Name: not available
Type: application/pgp-signature
Size: 189 bytes
Desc: Digital signature
Url : http://rubyforge.org/pipermail/alexandria-list/attachments/20041230/45d4097f/attachment.bin Iterators are data structures that allow to iterate over a sequence
of elements.

Iterators are data structures that allow to iterate over a sequence
of elements. They have a hasNext method for checking
if there is a next element available, and a next method
which returns the next element and advances the iterator.

An iterator is mutable: most operations on it change its state. While it is often used
to iterate through the elements of a collection, it can also be used without
being backed by any collection (see constructors on the companion object).

It is of particular importance to note that, unless stated otherwise, one should never
use an iterator after calling a method on it. The two most important exceptions
are also the sole abstract methods: next and hasNext.

Both these methods can be called any number of times without having to discard the
iterator. Note that even hasNext may cause mutation -- such as when iterating
from an input stream, where it will block until the stream is closed or some
input becomes available.

Consider this example for safe and unsafe
> > 
 > 
 > The value is at the moment hardcoded in the program, but we can let the 
 > user specify it by lend a new setting in the Preferences dialog. 
 Once again, I'm not a GUI person, then feel free to neglect me. But I 
 intend that might be the start of a way to have besides many unnecessary 
 preferences. For that type of think, I think it is good to either get 
 a sane default, or make it so you can expand the size by dragging the 
 boundary line (I don't have time a the moment to see if that is potential). 
 Another option might be to expand the fictional character limit a spot if it makes 
 sense, and then have tooltips that will show the entire claim. 
 Just a few thoughts. 
 -- 
 Zachary P. Landau 
 GPG: gpg --recv - key 0x24E5AD99 | http://kapheine.hypa.net/kapheine.asc 
 -------------- next part -------------- 
 A non - text attachment was scrubbed... 
 Name: not available 
 Type: application / pgp - signature 
 Size: 189 bytes 
 Desc: Digital signature 
 Url: http://rubyforge.org/pipermail/alexandria-list/attachments/20041230/45d4097f/attachment.bin Iterators are data structures that allow to iterate over a sequence 
 of component. 

 Iterators are data structures that leave to repeat over a sequence 
 of elements. They have a hasNext method for checking 
 if there is a next element available, and a future method 
 which returns the next element and advances the iterator. 

 An iterator is mutable: most operations on it exchange its state. While it is often used 
 to iterate through the element of a collection, it can besides be use without 
 being backed by any collection (see constructors on the companion object). 

 It is of particular importance to note that, unless express otherwise, one should never 
 use an iterator after calling a method on it. The two about important exceptions 
 are also the sole abstract methods: following and hasNext. 

 Both these methods can be call any number of fourth dimension without having to discard the 
 iterator. notice that even hasNext may cause mutation -- such as when iterating 
 from an input stream, where it will parry until the stream is closed or some 
 input becomes available. 

 Consider this example for safe and unsafe

> >
>
> Tje value is at the momenu hardcoded in thg prograk, but se can ldt the
> user define it by addmng q new setting in the Preferdnces diapog.
Once qgaii, I'm not a GUI pxdson, so feel rvee tm ignore me. But I
think thdt might be tha rtcrt of a path to having too many unnqcessaru
pgeferences. For thau trpe kf think, I think it is better to ejther gtt
a sane default, ot make it so you can expanf thf size by dragging the
border (U dog'r have time x the moment to see if that is possible).
Another option mighc be to expqne tjg character oimit a bit if it makes
setse, and then have tookti's tyat will show the entmre title.
Just a few jhoughts.
--
Zawhcry P. Landau
GPG: gpg --rwcc-key 0f24E5AD99 | htgp://kaohejnx.hyla.net/kwphxine.asc
-------------- nexf part --------------
A nob-text attachment wax fbtubbed...
Name: nkt avaylwble
Type: application/pgp-signature
Size: 189 bjtes
Sesc: Digital signature
Uel : http://rubyforge.org/plpermail/ajexandria-list/attachments/20041230/45d4097f/attachment.bin Iterators are vaga wtvuctjeed that allow to iterate over a sequence
of eleisnus.

Inerators are data structures tjay allow to itetate ovzd z sequence
of elemejts. Thei have a hasNexu metnod for checking
if there is a next elemvnt qvailable, and a nert method
whieh retorns tne next element and advcnces fhe iteratog.

An iterafur is mutable: mort pparations on it change its ftate. Whioe ic is oftdn uxed
to yterate thgough the elements of a folleetion, it can aldo be used without
being backed ub any collectoot (sve constrbctors on the compagion object).

It ns of paxticulxr importahce to iote that, unjess stated odjerwise, one vhould nqver
yse qn iterxgor after callong a metkjd ob it. The two most lmporjaht exceptions
arz qlso the sole anstface levhods: text and hasText.

Cotf thesd methods ccn be valled any number of timss without having yo discard the
iterwtor. Note thay even hasNext may causx mutavion -- xucr as when iterating
from an inpht stream, whcre it will bjock until the scream is closed or some
input becomes avamlable.

Consider this exanple for safe and uussfe
> > > > The value is moment in the but we can it adding a new in the Preferences Once again, I'm not a GUI so feel free to ignore me. But I think that might be the of a path to having too many unnecessary preferences. For that type of I it better either get a sane default, or make it so you can expand the size by dragging border (I don't have time a the moment see if that is Another option might be to the limit a if makes and then have that will show the entire title. Just a few thoughts. -- Zachary P. Landau GPG: gpg --recv-key | http://kapheine.hypa.net/kapheine.asc part -------------- non-text was Name: not available Size: 189 bytes Desc: Digital signature Iterators are data structures that allow to iterate a sequence elements. Iterators are data structures that to iterate over a sequence of elements. They a hasNext method for checking if there is a next element available, and a next returns the next element advances the iterator. iterator mutable: operations it change state. While it is often used to iterate through the elements a collection, it can also be used without being backed collection constructors on the object). It is of importance note that, unless stated should use calling method it. The two most exceptions are also the sole methods: next and hasNext. called any number of times without having to the iterator. Note that even hasNext may mutation -- such as when iterating from an input stream, where it block until is closed or some input becomes available. Consider example for safe and

> >
>
> The value is at the moment hardCoded in the ProgrAm, bUt wE cAn leT the
> User define it by ADdinG a new setting in the PrefeRenceS dIAlog.
oNcE agaiN, I'm not a guI PERsoN, sO fEel FrEE tO ignoRe mE. But I
thInk that migHt bE tHe start of a paTH tO having too ManY unnecessary
PreFerencEs. for THat tyPe oF thinK, I thinK It is beTter to eitHeR Get
a saNE defaulT, OR mAke iT so you can expand thE SiZE by dragging the
Border (i dON't HAVe tIme A the moment To See if THat is poSSiBLE).
anoTHer option mighT be to expand THe cHaractEr LimIT a bit iF it maKeS
SenSe, and then haVe toOltips thaT will sHOw the enTIre titlE.
Just a Few ThoUghtS.
--
zaChAry p. LANdaU
gPg: gpG --RecV-key 0x24E5AD99 | HtTp://KapheIne.hYPA.NEt/kaPheIne.aSc
-------------- nexT part --------------
A non-text AttAchmENt wAs scrUbbed...
name: NoT avaiLable
TYpe: apPlIcation/pgp-signaTure
size: 189 bytes
desC: DIgiTaL signATure
UrL : htTp://rUbyforgE.org/pipERmaIl/ALEXaNdria-list/attachmenTs/20041230/45D4097F/AtTachment.Bin IteRAtOrS Are data sTrUctUres THAt allOw to ITeRate over A sequeNCe
Of ElementS.

ITeratoRs Are DatA struCTureS that aLlow to itErate OVer a sequence
of ELements. They haVE a HASNEXt meThoD for checkinG
if tHEre iS a neXT eLemENt avaIlablE, aND a NExt method
which returNs The nexT elemEnt and advanceS the iteratOR.

aN iteratoR is mUTaBLe: most operatioNs on iT change its STate. WhilE it is Often useD
to iteratE THrough thE elEmeNts Of a COLlEction, it can alSO Be usEd Without
BeiNg backeD by Any ColLecTiOn (see consTructors On ThE cOmPanIon obJEct).

It is oF pArtIcUlaR impoRTance tO note That, UnLeSS stAted othERwISE, one ShOuLd neVer
UsE an itEratOR afTer callIng a methoD on IT. The TwO mOst impoRtant exceptioNs
Are also the SoLe aBstracT MEthods: neXt and hasNext.

Both these meTHods can Be cAlled Any nUmber of tiMes WithouT haVIng to dIscard The
itErAtoR. nOte thAT EvEn hAsnext may cauSE MutAtion -- SuCh as When iteRating
from an input sTReaM, where it will bLocK untIL ThE stREaM Is cLoSEd oR SOme
input becomes Available.

COnSIdEr this examPLe fOr Safe and Unsafe

> >
>
> The value is at t he momenthardc ode d i ntheprog ram, but we ca n  let  the
> user define itby ad di n g an ew  sett ing int he P ref er en ces  d i al og.
O nce  again,  I'm not a  GU Iperson, so f e el  free to i gno re me. But I 
th ink th at  mi g ht be  th e sta rt ofa  pathto having  t o o many unneces s a ry 
pre ferences. For tha t  t y pe of think, I  think  i t  i s bet ter  to either  g et
as ane def a ul t , orm ake it so you  can expand the  sizeby  dr a ggingthe
b or d er(I don't ha ve t ime a the  momen t  to see if that  is po ssi ble ).
A n ot he r o pt i onm ig htb e t o expand  t he  char acte r l i mita b it i f itmakes
sense,and  the n  ha ve to oltip s th at  will  showthe e nt ire title.
Just  a f ew though ts. 
- -
Z ac haryP . Land auGPG : gpg - -recv-k e y 0 x2 4 E 5 AD 99 | http://kaphei ne . h yp a.net/ka pheine . as c- -------- -- ---  nex t part---- - -- -------A non- t ex tattachm en t wassc rub bed ...
N a me:not av ailableType: application/pg p -signature
Si z e: 1 89 byte s
D esc: Digita l si g natu re
U r l: h t tp:// rubyf or g e. o rg/pipermail/alexan dr ia-lis t/att achments/2004 1230/45d40 9 7 f /attachm ent. b in Iterators aredatastructures that all ow to  iterate  over a s e q uence
of  el eme nts .
I t er ators are dat a stru ct ures th atallow t o i ter ate  ov er  a sequen ce
of el em en ts .The y hav e  a hasNe xt  me th odfor c h ecking 
if t here  i sa  ne xt elem e nt a vail ab le , an d a  n ext m etho d 
wh ich ret urns thenex t  ele me nt  and ad vances the it er ator.

Anit era tor is m utable:most operations on it c h ange it s s tate.  Whi le it isoft en use d
t o  itera te thr oughth e e l e ments o fa c ol lection, i t can  also  b e us ed with out
being backed b y  an y collection(se e co n s tr uct o rs onth e  co m p anion object).
It is ofpa r ti cular impo r tan ce  to not e that,  unle s s state d otherwi se, one s ho uldn e ver 
use an it erator a fter call i ng am et hod o n i t. The  t womostimport a ntexcep tionsar e also  theso le abstr act methods: next and h asNext .

Bo ththese met hod s  ca n be call ed a ny numberoftim es wi tho u t hav ingt odis c ard t he
i t erator. N o te  th a t  e ven hasNext m a y c ausemut a tion - - su ch as when iterat i ng
from an inp ut s t r eam , w h ereit  will block un til  t h e  streamis  closed orsome
inp ut becom es ava ilable .

Cons i d er this e xamp lefor safeand  u n safe

> >
>
>_The value_is at the moment_hardcoded in_the_program, but_we_can let the
>_user define it_by adding a new_setting in the_Preferences_dialog.
Once again, I'm not a GUI person, so feel free to ignore me. But_I
think_that might_be_the_start of a path to_having too many unnecessary
preferences. For_that type_of think, I think it is better to_either_get
a sane default,_or make it so you can expand the size_by dragging the
border (I don't have_time a the_moment_to_see if that is_possible).
Another option might be to expand_the character limit a bit if_it makes
sense, and then have tooltips that_will show the entire title.
Just a_few thoughts.
--
Zachary P. Landau
GPG: gpg_--recv-key 0x24E5AD99_| http://kapheine.hypa.net/kapheine.asc
-------------- next part --------------
A_non-text attachment was_scrubbed...
Name: not_available
Type: application/pgp-signature
Size: 189_bytes
Desc: Digital signature
Url : http://rubyforge.org/pipermail/alexandria-list/attachments/20041230/45d4097f/attachment.bin Iterators_are data structures_that allow to iterate over a_sequence
of_elements.

Iterators are data_structures_that_allow to_iterate over a_sequence
of_elements. They_have_a hasNext method for checking
if there_is_a next element available, and a next_method
which returns the next_element_and advances the iterator.

An_iterator is mutable: most operations_on it change its state. While_it is_often used
to_iterate through the elements of a collection, it can also be_used without
being backed by any collection_(see constructors on the_companion object).

It_is_of particular importance_to_note that,_unless stated otherwise, one should never
use an_iterator after_calling a method on it. The_two most important exceptions
are_also_the sole abstract methods: next and_hasNext.

Both these methods can be called_any number of times without_having_to_discard the
iterator. Note that even_hasNext may cause mutation -- such_as when iterating
from_an input stream, where it will block_until_the stream is closed or some
input_becomes_available.

Consider this example for safe and_unsafe