diff --git a/OLD.schmarrn.netdigest b/OLD.schmarrn.netdigest
new file mode 100644
index 0000000..eb6e8f8
--- /dev/null
+++ b/OLD.schmarrn.netdigest
@@ -0,0 +1,36852 @@
+Und da es sowieso zu spaet ist... (Ronda, 26. Jun 2003, 21:52:50):
+~#! on=Ronda ot=1056581853 og=muell
+... und ich mein Versprechen nicht halten konnte, nicht mehr de.alt.netdigest
+zu posten... gleich der naechste.
+
+Ronda
+
+Einreicher's Note: Umbruch angepasst)
+
+From: Thomas 'PointedEars' Lahn <PointedEars@web.de>
+Subject: Re: test formular / \"OR\"
+Newsgroups: de.alt.gruppenkasper
+Date: Sat, 21 Jun 2003 09:57:00 +0200
+Message-ID: <3EF40FCC.808@PointedEars.de>
+
+Birgit Nietsch wrote:
+
+> Diego Alfredo Unada schrieb:
+> [blubb]
+>
+> Im Uebrigen bin ich der Meinung, dass du diese sinnlosen
+> Zurueckfuppereien unterlassen solltest.
+
+<maus>
+
+Das hier, das ist der Herr Ketelaer. Der Herr Ketelaer ist
+Unternehmensberater und Programmierer. Schreibt er jedenfalls.
+
+Zumindest im deutschsprachigen Teil des weltweiten Nutznetzes ist der
+Herr Ketelaer aber ein Troll und nennt sich Diego Alfredo Unada oder
+kurz `dau'. Das steht fuer `duemmster anzunehmender User'. Das ist auch
+so richtig passend, denn der Herr Ketelaer kann offenbar nichts
+anderes, als sinnfreie freche Zeichenfolgen in das weltweite Nutznetz
+zu pusten. Das ist Datenmuell, fuer den es nichtmal einen Aufgeweichtes-
+Knaeckebrot-Award gibt. Macht aber nix, denn wenn das anders waere, waer'
+der Herr Ketelaer ja auch kein richtiger Troll mehr und sein jahrelang
+aufgebautes und sorgfaeltig gepfelgtes Image waere sofort im Eimer.
+Womoeglich wuerde man ihn sogar wieder ernst nehmen!
+
+Das Nutznetz ist uebrigens ein ekeltronisches Medium und funktioniert
+mit Computern. Das ist also etwas anderes als die fiesikalische Welt,
+die ihr schon kennt. Trotzdem haben beide miteinander zu tun, weil man
+es in beiden Welten mit echten Menschen zu tun hat. (Zumindest
+meistens, bei dem Herrn Desloovere ist man sich da noch nicht so ganz
+sicher. Doch dazu erzaehlen wir euch vielleicht spaeter nochmal was.)
+Der Herr Ketelaer hat aber wie so vieles auch das nicht verstanden,
+deswegen ist es ihm vollkommen egal, wenn viele Leute weltweit seine
+sinnfreien Zeichenfolgen lesen. Und dann wundert sich der Herr
+Ketelaer, dass er so unbeliebt ist.
+
+Doch anstatt einmal die Schuld bei sich selbst zu suchen, sind beim
+Herrn Ketelaer immer die anderen schuld. Einmal hat er sogar einen
+anderen Nutznetzteilnehmer beschuldigt, er haette seinen Kunden einen
+boesen ekeltronischen Brief geschrieben, so dass viele der Kunden den
+Herrn Ketelaer ploetzlich nicht mehr mochten. Der Herr Ketelaer muss
+seine Kunden fuer sehr dumm halten, weil er tatsaechlich glaubt, dass
+diese nicht selbst lesen und entscheiden koennen.
+
+Wahrscheinlich hat er deshalb auch nicht wirklich viele Freunde.
+Deswegen schreibt der Herr Ketelaer innerhalb eines Monats sehr sehr
+viel Text in der Nuss-Gruppe de.alt.gruppenkasper, kurz dag, obwohl
+es im weltweiten Nutznetz bestimmt noch andere Gruppen gibt, die fuer
+ihn interessant sein koennten. Er ist in dag sogar oft Postingsieger.
+Das bedeutet, dass er von allen am meisten geschrieben hat. Der Herr
+Klingforth schreibt das sogar regelmaessig auf
+(<http://klingforth.de/dag/>), wofuer man ihm dankbar sein muss.
+
+Der Herr Ketelaer aber findet es ganz toll, Erster zu sein und pappt
+sich dann ein schnoerkeliges Zeichen an den Spitznamen. Viele andere
+Netznutzer tangiert das jedoch maximal peripher, denn immerhin ist
+dag "der Schrottplatz am Ende des Universums, die letzte Tanke vor
+dem Abgrund, die Hoehle der Finsternis, [...] die Gruft" des
+deutschsprachigen Nutznetzes (frei nach Axel Woelke). Das liegt daran,
+weil der Herr Ketelaer den Unterschied zwischen Quantitaet und Qualitaet
+nicht verstanden hat. Vielleicht traut er sich ja deswegen nicht, in
+ernsthaften Gruppen zu mitzudiskutieren, denn dort liest man
+ueberwiegend qualitaetsbehaftete Beitraege.
+
+Leider hat der Herr Ketelaer auch immer noch nicht mitbekommen, dass
+in der Nuss-Gruppe de.comp.lang.javascript, kurz dcljs, zwar Quael-Kot,
+nicht jedoch seine hirnlosen ("Zurueckfupp"-)Exkremente das
+Diskussionsthema sind. Aus diesem Grund ist er mit all seinen
+Inkarnationen wahrscheinlich bereits in einer Menge Killfiles
+endgelagert. Macht aber nix, denn so koennen sich die regelmaessigen
+Leser von dcljs auf wertvollere Beitraege konzentrieren.
+
+Da sein ... aeh ... Geschriebenes also ohnehin nicht direkt zur
+Kenntnis genommen wird, koennte der Herr Ketelaer sich und anderen
+Netznutzern das Belaestigen ernsthafter Gruppen ersparen und somit
+nicht laenger wertvolle Bandbreite verschwenden, die nachfolgende
+Generationen -- also ihr -- noch dringend brauchen werden. Auch muesste
+er nicht jeden Artikel lesen und auf jeden Artikel antworten, der ihn
+betrifft. Dann waere der Herr Ketelaer aber kein Troll mehr und somit
+nach seiner eigenen Definition ein Schwaechling. Dass er damit aber
+vielmehr Staerke zeigen wuerde, daran denkt der Herr Ketelaer leider gar
+nicht.
+
+Und so gibt es noch einiges, was man aus den Artikeln des Herrn
+Ketelaer herauslesen kann. Leider ist die Zeit fuer heute aber schon
+rum, also geht das jetzt nicht mehr. Macht aber nix, denn es gibt ja
+auch noch was Wichtigeres als den Herrn Ketelaer und seine Probleme.
+Zum Beispiel den Herrn Bush und seine Probleme --->
+http://www.jwdt.com/~paysan/bush.html
+
+Und das naechste Mal erklaeren wir, wie ein Killfile funktioniert, dass
+es niemanden umbringt, wie es aber helfen kann, die im Nutznetz
+verbrachte Zeit sinnvoll zu reduzieren, indem man Artikel von DAUs
+aller Art einfach wegfiltert. Zumindest solange, bis diese wieder
+sinnvolle Zeichenfolgen von sich geben.
+
+
+Schoene Gruesse
+
+Euer Christoph von der Maus
+
+</maus>
+
+Dieter*[tm]
+
+-----------------------------------------------------------------------------
+
+
+
+Heja, nun darf ich wieder posten ;-) (Ronda, 26. Jun 2003, 23:08:48):
+Elizabeth sei Dank ;-))) (Aber das liest sie ja sicher nicht. Egal.)
+
+From: mathias.boelckow@gmx.net (Mathias Boelckow)
+Newsgroups: de.etc.bahn.misc
+Subject: Re: Preissystem der DB
+Date: Tue, 24 Jun 2003 14:37:54 GMT
+Message-ID: <3ef86038.24348371@news.cis.dfn.de>
+
+"Tom Poerschmann" <tom.poerschmann@s2001.tu-chemnitz.de> schrieb/wrote
+uns/us:
+
+>Ich bin auf der Suche nach einer einigermasen uebersichtlichen Darstellung
+>des Preissystemes der DB. Falls jemand eine Quelle dazu kennt, koennte er ja
+>das bitte posten oder mailen....
+
+Wenn Du fuendig wirst, bitte doch den Autor auch so eine Darstellung
+ueber die Relativitaetstheorie, Fehlermeldungen unter Windows und die
+Foerderrichtlinien der EU zu verfassen.
+
+Gruss, Mathias Boelckow
+
+-----------------------------------------------------------------------------
+
+
+
+Laufsocken (Deepblue, 27. Jun 2003, 19:47:42):
+From: Oliver Scheuch <usenet@oliver-scheuch.de>
+Newsgroups: de.rec.sport.laufen
+Subject: Re: Laufsocken
+Date: Thu, 26 Jun 2003 23:38:06 +0200
+Message-ID: <bdfp1l$jnq$1@news1.ewetel.de>
+
+Peter Droenbriegen wrote:
+>ichhabemirextraLaufsockengekauftundhabejetzteinProblem.
+> Ich bin mit den verdammten Dingern nicht schneller!! Kann ich an den Socken
+> noch was einstellen???
+
+Ich hab mir ne schicke Laufkappe gekauft, bin zwar damit auch nicht 
+schneller, sieht aber schneller aus ;-)
+Ausserdem muessen sich Laufsocken erst einlaufen, mach 1 Jahr lang 4 
+Laufeinheiten woechentlich mit Ihnen, Intervalltraining, 
+Wiederholungslaeufe, lange Dauerlaeufe, dann wirst du schneller!
+
+Ciao Oli
+
+-----------------------------------------------------------------------------
+
+
+
+fussball (Deepblue, 27. Jun 2003, 19:50:39):
+Subject: Re: Heute 10.000. St.Pauli-Dauerkarte - Rekord?
+From: Klaus Rasmussen <Rasmussen@fahr-zur-hoelle.org>
+Date: Thu, 26 Jun 2003 09:32:57 +0200
+Newsgroups: de.rec.sport.fussball
+Message-ID: <bdeeka.eo.1@news.klaus-rasmussen.de>
+
+Dirk Proesdorf schrieb:
+> Joachim A. Netz <a.netz@gmx.de> wrote:
+
+>> Achso: Der Kaeufer der 10.000 Karte soll uebrigens von Uwe Seeler, den
+>> wir bei St.Pauli liebevoll "Euch Uwe" nennen, ein Praesent ueberreicht
+>> bekommen. Kein Scherz! :)
+
+> 'ne HSV Dauerkarte?
+
+Ein Geschenk soll Freude bereiten.
+
+-----------------------------------------------------------------------------
+
+
+
+Eigentlich... (Ronda, 27. Jun 2003, 22:03:15):
+... gehoert das hier nicht nach Schmarrn. Sondern in eine ernste Rubrik. Aber
+wenn wir nun auch noch allgemein.netdigest und weitere einfordern, liest uns
+Elizabeth ja wieder. Also. Hier:
+
+... man beachte uebrigens auch die interessante Mailadresse...
+
+Ronda
+
+
+Subject: Re: Veroeffentlichen mittels FTP in FP2002
+From: "Matthias P. Wuerfl"
+<ich-frage-mich-ob-man-spam-verhindern-kann-einfach-nur-indem-man-eine-ganz-la
+nge-e-mail-adresse-fuer-seine-usenet-postings-benutzt@trullala.de>
+Date: Thu, 26 Jun 2003 22:14:31 +0200
+Message-ID: <bdfk70$loo$06$1@news.t-online.com>
+Newsgroups: de.alt.recovery.webauthor
+
+Christoph Paeper wrote:
+
+[Megahertz]
+
+> Okay, die Summe (3.699) haben andere zwar fast in einem Gehaeuse, aber
+sowohl
+> die Summe als auch der Durchschnitt dessen was bei mir rumsteht ist weniger
+> als ein Zehntel davon (350).
+
+OK, ich oute mich.
+
+Ich habe das mit den Megahertz angefangen, nicht weil ich dachte, ich 
+koennte gewinnen, sondern weil ich einfach wieder mal die Bestaetigung 
+wollte, dass es andere Leute gibt, die genauso denken wie ich.
+
+Ich bin manchmal sehr irritiert, wenn irgendwelche Otto-Normaluser mir 
+sagen, dass sie einen neuen 3GH-Computer haben, weil der alte "1,2er" es 
+leistungsmaessig nicht brachte. Ich neige dazu, auch unerfahrene User -- 
+zumindest teilweise -- fuer voll zu nehmen und messe ihren Aussagen 
+einen gewissen (nicht grossen -- aber immerhin) Wert bei. Dann werde ich 
+ganz unsicher, ob ich nicht vielleicht mit meiner Ausstattung etwas 
+hinter dem Mond bin oder so.
+
+Aber das Problem ist, dass eine Betriebssystemneuinstallation sehr 
+aufwaendig ist und die selten mit Hardwareneuanschaffungen 
+zusammenfaellt. Da ich mich nicht traue, die Platte mit dem alten System 
+in eine _ganz_ andere Kiste zu stellen haenge ich (eigentlich schon 
+ewig) auf 440BX [P2B-P3B-P3BF] fest. Mein Problem ist jetzt, dass es 
+nichts neues mehr gibt. Meine jetzige "Hauptworkstation" ist schon 
+gebraucht gekauft.
+
+Auf der anderen Seite denke ich mir dann wieder: Warum solte ich auch, 
+das Ding laeuft doch flott und ich wuesste nicht, was ich vermissen 
+wuerde. Im Gegensatz zu diesem Teil (und den ganzen anderen 
+Helfer-Computern) stehen die Otto-Normaluser ganz schoen doof da, ohne 
+gescheiten Router, Fileserver, mit nur einem Bildschirm, ohne 
+DHCP-Server, eSound-Server, DB-Server, Webserver, Mailserver, 
+Newsserver, etc. [1]
+
+Ich bekomme schon Mitleid, wenn auf einem System kein gescheites 
+FTP-Programm, kein gescheiter Text-Edior mit Syntax-Biltzing, kein 
+gescheiter Browser, usw. installiert ist. Ich bekomme schon die Krise, 
+wenn bei Windows die "versteckten Dateien" und die Dateierweiterungen 
+ausgeblendet werden, wenn ich im Explorer die "Details" nicht sehen kann 
+und Informationen durch Buntigkeit verdeckt werden. Dann beginnt (auch 
+auf Fremdcomputern - da bin ich gnadenlos) eine Umkonfigurierungs- und 
+Installationsorgie.
+
+Aber dann sagt mir wieder irgend so ein Otto Normaluser: "Das brenn' ich 
+dir auf DVD" und dann muss _ich_, der ich *professionell* den ganzen Tag 
+damit arbeite, sagen: "Sorry, ich habe kein DVD-Laufwerk". "Was, einen 
+Raum voller Computer und keiner mit DVD-Laufwerk dabei?" - "Nein".
+
+Irgendwie komme ich mir dann doof vor. Mir ist das peinlich. Ich habe 
+mir schon nur deswegen eine CD-Brenner gekauft. Ich glaube ich habe das 
+Ding noch nie gebraucht (ausser Privat, um CDs fuer Freunde zu brennen). 
+Naja, gut, ich habe ein MP3-Autoradio. Fuer das habe ich mir schon 2 
+MP3-CDs gebrannt, aber ansonsten finde ich wirklich, dass meine Daten 
+wunderbar auf der Festplatte aufgehoben sind. Ich wuesste nicht, weshalb 
+ich die auf irgendwelche Silbernen Scheibchen draufmachen sollte.
+
+Aus purem gesellschaflichem Zwang habe ich mir auch eine "Spindel" 
+gekauft. Das ist ein 50er-Pack leere CDs ohne Huellen. Keine Ahnung. Die 
+stehen halt jetzt hier rum und werden und werden nicht leer. Ich habe 
+schon Angst, dass die anfangen zu schimmeln oder so. Da habe ich mir 
+gedacht: "Ich brauche einen schnelleren Brenner!"
+
+So. Jetzt kann ich mit 52-facher Geschwindigkeit brennen. Hat jemand 
+eine Idee, was man mal brennen koennte? Mangels dieser P2P-Programme 
+(die ich nicht beherrsche und auf die ich irgendwie auch keine Lust 
+habe) kann ich mir nicht mal einen Videofilm ziehen oder so. Und selbst 
+wenn: Ich wuesste nicht, wie man dieses "VCD" macht, damit man das auch 
+im Fernseher angucken kann.
+
+Auf jeden Fall habe ich diese mitleidigen Blicke der anderen satt, wenn 
+es um die Hardwareausstattung geht. Da tut es gut, wenn man mal wieder 
+liesst, dass es Andere gibt, die haben _noch_ weniger und koennen auch 
+damit produktiv arbeiten. Das bestaerkt einen in der Annahme/Vermutung 
+dass dieser komische Megahertz-Wettbewerb und diese Featuritis nur 
+Marketing-Kram ist, um neue Computer absetzen zu koennen, obwohl jeder 
+weiss, dass 32 Bit eh auslaeufft und man warten sollte, bis man zu einem 
+Vernuenftigen Preis 64bit bekommt. War schon damals bei 16->32 so.
+
+Also vielen Dank fuer eure Megahertz-Listen, es koennen ruhig noch mehr 
+davon kommen.
+
+Gruesse, Matthias *plopp* *bieraufmach*
+
+[1] Demnaechst neu, auf dem 133er: Voicebox-Server und Faxserver
+
+
+-----------------------------------------------------------------------------
+
+
+
+Auf dass Deepblue... (Ronda, 29. Jun 2003, 00:12:43):
+... wieder brummelt, dass ich zu schnell poste. Aber das hier ist die
+Realitaet, Maenner. Seht es einfach ein:
+
+From: frank paulsen <frank.paulsen@gmx.net>
+Newsgroups: de.alt.sysadmin.recovery
+Subject: Re: Spass mit Snort
+Date: Thu, 26 Jun 2003 20:26:47 +0200
+Message-ID: <bdfdt7$314$1@ebel.dfakt.de>
+
+Eric Schaefer <eric@gixgax.de> writes:
+
+> * frank paulsen <frank.paulsen@gmx.net> wrote:
+>> genau wie bonbons, tempos und tampons vorwiegend zur ergaenzung
+>> weiblicher handtascheninhalte, bzw. um vermeiden zu koennen, in
+>> damenhandtaschen wuehlen zu muessen.
+>
+> Warum wuerdest Du Damenhandtaschen nach Tampons durchwuehlen?
+
+weil ich darum gebeten werde, und manchmal ein hoeflicher mensch bin?
+
+sorry, ich hab noch mal in den Newsgroups:-header geschaut:
+
+sieh mal, das ist so: da draussen, in diesem grossen blauen raum ohne
+klimaanlage, da gibt es so zweibeinige wesen unterschiedlicher form
+und unterschiedlichen geschlechts. 
+
+manchmal kommt es vor, dass ich einfach hier von den monitoren
+weggehe, weil gerade alles funktioniert, oder ich keine lust mehr
+habe, oder weil ich meine, sowas wie leidlich geregelte arbeitszeiten
+einhalten zu wollen.
+
+nun ist das nicht so witzig, ganz allein durch grosse blaue raeume
+ohne klimaanlage zu stapfen, und so ergibt es sich manchmal, dass
+mann sich mit einer auswahl dieser zweibeinigen wesen trifft und
+irgendwas gemeinsam unternimmt.
+
+ich meine jetzt nicht sowas wie eine 'LAN-Party', mehr so ganz
+seltsame dinge 'gemeinsam die freizeit verbringen' oder so. da gibt es
+ganz witzige spielchen, die komplett ohne strom und ohne netz
+funktionieren. google mal ein bischen rum, das haben schon mehrere
+festgestellt. 
+
+ja, und von zeit zu zeit sitzt mann halt naeher an einer
+damenhandtasche als die dazugehoerige dame, oder mann ist beifahrer,
+oder frau hat sich gerade die fingernaegel schwarz lackiert und
+wartet, dass der lack trocknet und gebuegelt werden kann. 
+
+wie frau da so sitzt, und uebers buegeln oder autofahren nachdenkt,
+faellt ihr ploetzlich ein, dass sie ja eigentlich gerade _jetzt_ einen
+tampon braeuchte, weil frauen naemlich immer ganz viele dinge
+gleichzeitig bedenken, auch wenn mann das nicht immer in der form
+nachvollziehen kann.
+
+oha, jetzt beginnt der schwierige teil, der geht dann ungefaehr so:
+"Fraaank, kannst du mal nachsehen, ob ich noch 'nen Tampon in der
+Tasche habe?" oder "Arggh. Gib mal schnell nen Tampon aus der Tasche".
+
+jetzt kann man natuerlich darueber zu reflektieren beginnen, ob man
+tatsaechlich genau jetzt so viel ueber die im anderen koerper
+ablaufenden prozesse erfahren wollte, man kann schreiend den raum
+verlassen oder man kann glotzen wie ein oelgoetze.
+
+nur plonken kann man nicht, 'skip message' funktioniert auch
+nicht, und nen wartungsvertrag hat man im allgemeinen auch nicht
+abgeschlossen, obwohl das eigentlich schon an grobe fahrlaessigkeit
+grenzt.
+
+anyway, mann steht jetzt vor der alternative, entweder in der
+damenhandtasche nach einem tampon zu suchen, oder einfach in die
+kleine innentasche links unten zu greifen und einen tampon, am besten
+noch in passender groesse und mit passend gefaerbtem baendchen, aus
+platzgruenden jedoch immer ohne einfuehrhilfe, zu holen und der dame
+zu ueberreichen.
+
+jetzt kennst du natuerlich keine damenhandtaschen, also muss ich etwas
+ausholen: es gibt ganz grob zwei oberkategorien von damenhandtaschen,
+die kleinen und die grossen.
+
+die kleinen enthalten in den seltensten faellen das gerade gesuchte,
+haben dafuer aber einen komplizierten verschluss, den man anfasst und
+dann fliegt alles in der gegend herum, oder er geht nicht auf, oder
+das gesuchte befindet sich hinter irgendwelchen reissverschluessen,
+oder es klebt ein bonbon dran.
+
+die grossen sind innen viel groesser als aussen, und enthalten einen
+kompletten hausstand, typischerweise aber auch nicht das gesuchte, was
+man entweder nach ungefaehr einstuendiger suche erkennt, oder ganz
+schnell, weil grosse damenhandtaschen naemlich typischerweise
+ueberhaupt keinen verschluss haben, oder dieser wegen seiner
+kompliziertheit nicht benutzt wird, so dass schon beim aufheben der
+tasche ein kompletter hausstand auf dem fussboden herumfliegt. leider
+finden sich in grossen damenhandtaschen immer auch dinge, die man
+garantiert nicht anfassen moechte, z.B. pieksige nagelfeilen oder
+offene kajalstifte oder aufspringende puderdosen oder zweihundert
+angeschaerfte blechteile, die jeder vernuenftige fuer angelhaken
+halten wuerde, die aber eigentlich nur gerade nicht angebrachte
+sogenannte schmuckstuecke sind, die sich fest in die haut verbeissen
+und oft die suche nach einem pflaster ausloesen, was dann schon
+an rekursion grenzt.
+
+ja, und deshalb versuche ich die hauefigst nachgefragten sachen selbst
+vorzuhalten, so wie jeder sysadmin seine eigene toolsammlung hat.
+
+nur meine nagefeile, die ist kuerzlich in irgendeiner damenhandtasche
+verschwunden und wurde nicht wieder gefunden.
+
+-----------------------------------------------------------------------------
+
+
+
+Ja, Ronda? (Deepblue, 29. Jun 2003, 20:36:19):
+From: Mathias Schindler <schindler@presroi.de>
+Newsgroups: de.soc.drogen
+Subject: Re: Alkohol versus Cannabis. Eine juristische Aufarbeitung
+Date: Sun, 22 Jun 2003 19:47:27 +0200
+Message-ID: <bd4pvm$u5a$07$1@news.t-online.com>
+
+Michael Holzt wrote:
+
+[Das Wesen von de.soc.drogen]
+
+> (wir sind alles nur Theoretiker!), 
+
+Dieser Eindruck wird ab und zu auch von einigen in de.talk.liebesakt 
+vermittelt. Das darf nicht mit Foren verwechselt werden, deren 
+Praktikabilitaet zumindest fraglich ist. de.rec.suizid, de.org.taliban, 
+de.etc.bahn.glueckliche-kunden
+
+
+-----------------------------------------------------------------------------
+
+
+
+Duschen bei Gewitter (Deepblue, 29. Jun 2003, 20:37:08):
+Subject: Re: Duschen bei Gewitter
+From: Lars Dannenberg <lars.dannenberg@t-online.de>
+Newsgroups: de.alt.folklore.urban-legends
+Date: Fri, 27 Jun 2003 17:52:15 +0200
+Message-ID: <Xns93A7B5CA53CClarsdtonline@62.153.159.134>
+
+Gernot Griese <news@esslingen-neckar.de> wrote:
+
+
+> BTW: in den USA gibt es elektrisch beheizte WC-Schuesseln. Vielleicht 
+> koennte da mal jemand in 1600 Pennsylvania Avenue NW, Washington, DC 
+> 20500 etwas manipulieren... 
+
+Das waere fein. Da bekommt die Bezeichnung "Elektrischer Stuhl" gleich
+eine ganz andere Bedeutung...
+
+
+Lars
+
+-----------------------------------------------------------------------------
+
+
+
+Fuer Deepblue... (Ronda, 29. Jun 2003, 23:36:56):
+... ja, auch Du mein Sohn darfst hier posten. Wie jeder andere auch. Aber wir
+beiden haben unterschiedliche Vorstellungen davon, was wir hier posten wollen.
+Auch das ist gut mein Sohn...
+
+Ronda *Hmpf. Ich hab in meiner Kindheit doch zu oft "Oh Gott, Herr Pfarrer"
+geschaut*
+
+Ps: Pisa sucks. Unsere Schueler haben dabei garantiert geschummelt.
+
+From:  Hans-Georg Bickel <hgbusenetmuell@gmx.de>
+Newsgroups:  de.rec.tv.lindenstrasse
+Subject: Re: Spoiler: Folge 922. vom 03.08.2003
+Message-ID: <bdi7fu$sa1sp$4@ID-108823.news.dfncis.de>
+Date: Fri, 27 Jun 2003 21:53:47 +0200
+
+Cornelia Kroes <nachrichten.2.crazycat@spamgourmet.com> wrote:
+
+>>Du kennst den Unterschied zwischen Singular und Plural?  
+>Nee, kenne beides nicht, wasn das? Kann man das essen? ;-)
+
+Oh Gott, und sowas wird auf die Jugend losgelassen! Also gut:
+
+Das -># ist ein Keks. Und das -># ist noch ein Keks. Und weil
+Kekse so gut schmecken, isst man meistens nicht nur einen #
+sondern 2 ## oder ## oder auch ganz viele ###############, aber
+dann muss man aufpassen, dass man kein Bauchweh bekommt.
+
+Wenn man sagt: 1 Keks #, dann nennt man das die Einzahl. Logisch,
+denn es ist ja nur 1 Keks da. Hat man 1 # und noch einen # und
+noch einen # oder gleich eine ganze Tuete, dann sagt man 'Kekse',
+egal ob man 2,3 oder ganz viele davon hat. Das ist dann die
+Mehrzahl.
+
+Man muss also nicht erst zaehlen, wie viele Kekse man hat, bevor
+man etwas sagt. Das ist doch praktisch!
+
+Die Einzahl nennt man auch 'Singular' und die Mehrzahl 'Plural'.
+Das ist lateinisch. So haben die alten Roemer gesprochen. Und
+frueher, als Ihr, Eure Eltern, Eure Grosseltern und auch Eure
+Urgrosseltern noch lange nicht auf der Welt waren, da hat man fast
+ueberall lateinisch gesprochen. Das war so verbreitet wie heute
+Englisch. Natuerlich hat man auch auf den Universitaeten lateinisch
+gesprochen und der kluge Mensch, der damals erkannt hat, dass 1
+Keks etwas anderes ist als viele Kekse, auch.
+
+Das hat man bis heute beibehalten. Und weil frueher gaaanz viele
+Leute in Universitaeten irgend etwas herausgefunden haben, gibt es
+bis heute noch viele lateinische Namen, obwohl die Sprache selbst
+kaum noch jemand spricht. Komisch, ist aber so.
+
+Und ob man Singular und Plural mitessen kann, wenn man einen oder
+ganz viele Kekse knabbert, das zeigen wir Euch gleich. Nach der
+naechsten Maus.
+
+HG
+
+-----------------------------------------------------------------------------
+
+
+
+Eigentlich gehoert das nach Puiz, aber wir sind ja hier... (Ronda,  2. Jul 2003, 01:13:21):
+From: "Matthias P. Wuerfl"
+<ich-frage-mich-ob-man-spam-verhindern-kann-einfach-nur-indem-man-eine-ganz-la
+nge-e-mail-adresse-fuer-seine-usenet-postings-benutzt@trullala.de>
+Newsgroups: de.alt.recovery.webauthor
+Subject: Re: Indizierung verhindern
+Date: Tue, 01 Jul 2003 12:55:06 +0200
+Message-ID: <bdrpa8$lbr$04$1@news.t-online.com>
+
+Christian Peper wrote:
+
+[...Fussnoten...]
+
+Du [1] bist [2] ein [3] Depp
+
+Gruesse, Matthias
+
+
+[0] entziffern, meine hingegen versteht
+[1] verstehst [4] komplizierte Fussnoten [5]
+[2] [6] nicht [7]
+[3] durschnittlich begabter [8]d[12]r
+[4] es sehr gut,
+[5] zu machen,
+[6] aber
+[7] so gut [10] kann
+[8] noch [9] je
+[9] in [11] Zeit [0] nicht
+[10] wie ich, denn Deine
+[11] kuerzester
+[12] e
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Eigentlich gehoert das nach Puiz, aber wir sind ja hier... (Grimmborn,  2. Jul 2003, 09:35:03):
+~#! rn=Ronda rt=1057101201 rg=schmarrn.netdigest
+~#! tid=1057101201
+Da fehlt ein "ein", z.B. am Ende von [7].
+
+GdA
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Eigentlich gehoert das nach Puiz, aber wir sind ja hier... (Croft,  2. Jul 2003, 09:38:33):
+~#! rn=Grimmborn rt=1057131303 rg=schmarrn.netdigest
+~#! tid=1057101201
+Wieso? Das steht doch hinter der Verwendung von [2].  Bist du noch nicht
+richtig wach?
+
+Croft
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Eigentlich gehoert das nach Puiz, aber wir sind ja hier... (Grimmborn,  2. Jul 2003, 09:47:15):
+~#! rn=Croft rt=1057131513 rg=schmarrn.netdigest
+~#! tid=1057101201
+Argh. Man sollte sich nicht *nur* auf die Fussnoten konzentrieren...
+
+GdA
+
+-----------------------------------------------------------------------------
+
+
+
+Navigationssystem... (Foobar,  3. Jul 2003, 20:34:17):
+From: Joerg Puetz <jp@cs.tu-berlin.de>
+Newsgroups: de.alt.fan.aldi
+Subject: Re: Rueckgabe Aldi...
+Date: Tue, 01 Jul 2003 10:44:45 +0200
+Message-ID: <tdi2gvkpircmdfjeiiqdedlk2inq291cls@4ax.com>
+
+
+"Dirk Schneider" <spam_scd602@gmx.de> wrote:
+
+> Bastian Poettner schrieb:
+> 
+> > Am 21.06.03 habe ich mir bei einem Aldi in Norddeutschland das
+> > Aldi-Navigationssystem gekauft. Bereits nach wenigen Tagen war klar,
+> > dass das Ding Muell ist und ich beschloss deshalb es zu Aldi zurueck zu
+> > bringen.
+> 
+> Warum ist es Muell? Wundert mich sowieso, dass hier noch kaum einer
+> zu dem Thema was schreibt.
+
+Sind alle noch unterwegs, weil sie sich verfahren haben.
+
+-----------------------------------------------------------------------------
+
+
+
+[de.sci.chemie] Re: 1,639 g/l (Nonne,  4. Jul 2003, 08:30:10):
+"Martin Kokelmann" <kokm@hrz.tu-chemnitz.de> schrieb:
+
+>Hallo,
+>beim stoechiometrischen Rechnen ist mir die obige Zahl aufgefallen.
+>Wo kommt die her?
+>Sie muss etwas mit Molvolumen zu tun haben.
+
+Hallo,
+beim Durchblaettern meines alten Mathebuchs ist mir folgende Zahl
+aufgefallen:
+   3
+Wo kommt die her?
+Sie muss etwas mit der Mathematik zu tun haben.
+Koenne es sein dass es noch mehr 3en gibt? Was, wenn die sich
+zusammenrotten und angreifen. Hilft es vielleicht, wenn ich das
+Mathebuch wegschliesse oder verbrenne?
+Ich sollte mich besser verstecken. Und einen Vorrat an 5en mitnehmen,
+vielleicht kann man sich damit gegen die 3en verteidigen...
+Wenn Ihr eine Zeit lang nichts von mir hoert, bin ich auf einem
+Selbstverteidigungskursus gegen 3en.
+Ach du Schei...! Da kommt schon eine! Eine RIESIGE DREIIIII. 
+UND DA NOCH WELCHE....AAAARGHHH!
+
+SCNR
+Dirk :-)))
+
+Nonne, kringelt sich.
+
+-----------------------------------------------------------------------------
+
+
+
+[de.alt.sysadmin.recovery] Re: DHISS: Disintegrierende Hardware Im Sommer Syndrom (Deepblue,  4. Jul 2003, 23:07:16):
+From: Carsten Wenzel <cw200203@freenet.de>
+Newsgroups: de.alt.sysadmin.recovery
+Subject: Re: DHISS: Disintegrierende Hardware Im Sommer Syndrom
+Date: Tue, 01 Jul 2003 09:21:36 +0200
+
+Rik Steenwinkel schrieb:
+> On Sun, 29 Jun 2003 19:57:14 UTC, toje@hummingbird.datentrampelpfad.de 
+> (Torsten Jerzembeck) wrote:
+> 
+> 
+[...]
+> 
+> Da gegenueber war das fahren mit einen Mietwagen etwas besser 'passend'. 
+> Nur rechts einsteigen und linkshandig Gangwechseln fuehlt auf anfang 
+> etwas oede, und ich hatte mehrmals die flsache 'Spiegel-reflex': 
+> links-nieder, rechts-hoch, statt links-hoch, rechts-nieder.
+> 
+Bekannter (Auslandsmonteur) hat die Fahrversuche mit einem
+Rechtslenker-Auto in UK nach dem ersten Fahrversuch aufgegeben.
+Er meinte: "Jedesmal, wenn ich schalten wollte, ging die Fahrertuer auf..."
+
+"Die spinnen, die..."
+
+MfG Carsten
+
+-----------------------------------------------------------------------------
+
+
+
+[de.talk.romance] Re: Heiratsantrag (Deepblue,  4. Jul 2003, 23:09:54):
+From: David Kastrup <dak@gnu.org>
+Newsgroups: de.talk.romance
+Subject: Re: Heiratsantrag
+Date: 02 Jul 2003 14:30:08 +0200
+Message-ID: <x53chpglgv.fsf@lola.goethe.zz>
+
+"Andreas Kiel" <andreas_gk@gmx.net> writes:
+
+> hoffe ich bin hier richtig mit meinem anliegen. Will meiner Freundin
+> gerne einen heiratsantrag machen, suche aber noch ne
+> witzige/niveauvolle variante, um nicht so plump "Willst Du mich
+> heiraten fragen zu muessen?".
+>
+> Bin fuer jeden sinnvollen Hinweis/Tipp oder Anregung dankbar.gruss
+> andreas
+
+He, das ist die Usenetgruppe mit "Romance" im Titel, und jeder weiss,
+was eine Ehe aus Romanze macht.Dufragstjaauchnichtin
+de.talk.lebensfreude nach der witzigsten Methode, Selbstmord zu
+begehen.
+
+
+-----------------------------------------------------------------------------
+
+
+
+de.alt.sysadmin.recovery (Zook,  7. Jul 2003, 18:24:44):
+
+From: Andreas Riedel <andreas.riedel@hrz.tu-chemnitz.de>
+Newsgroups: de.alt.sysadmin.recovery
+Subject: Re: Canossa V
+Date: 1 Jul 2003 23:03:17 GMT
+
+Andreas Krey schrieb:
+> Die Frage ist nur, was reinheitsgebotswidrig ins Koelsch kommt.
+> Rheinwasser?
+
+Geruechten zufolge wird Koelsch mit Hilfe eines Pferdes aus Alt
+produziert.
+
+Das klingt plausibel. Wenn ich Alt haette und ein Pferd, wuerde ich auch
+Koelsch produzieren. Es sei denn, ich mag das Pferd...
+
+Gruss
+Andreas
+
+--
+Those who desire to give up Freedom in order to gain Security,
+will not have, nor do they deserve, either one. (T. Jefferson)
+
+-----------------------------------------------------------------------------
+
+
+
+spline.fli4l.geschnatter (Amaryllis,  7. Jul 2003, 19:38:47):
+From: Gero Zahn <gero@gerozahn.de>
+Newsgroups: spline.fli4l.geschnatter
+Subject: Re: Du sollst nicht
+Date: Mon, 07 Jul 2003 08:19:05 +0200
+Message-ID: <beb3cc$rut$1@bla.spline.inf.fu-berlin.de>
+
+Ralph D. Kaerner wrote:
+> Wisst ihr, wofuer ich Gott an dieser Stelle danke? Fuer eine Freundin,
+> deren erster Satz war: "ich buegele Dir, was immer Du gebuegelt haben
+> willst, aber zwinge mich nicht, zu waschen, es sei denn, Du hast viel
+> Geld."
+> Also bediene ich hier die Waschmaschine, und das kriege ich verdammt
+> gut hin. Ich gebe allerdings zu, dass das Aufhaengen und Abnehmen von
+> Waesche fuer mich wiederum eine Strafarbeit darstellt. Da wasche ich
+> lieber so lange das Geschirr ab.
+
+Ha!! :) Dafuer bin ich der Spuelmaschineneinraeummeister. Dafuer gilt 
+(fuer die Mathematiker und Informatiker unter uns) per totaler 
+Induktion: "_EIN_ weiteres Teil geht immer noch rein." Das ganze gilt 
+natuerlich nicht ohne Ruecksicht auf Verluste: Die Sachen kommen 
+selbstverstaendlich sauber und am Stueck wieder raus.
+
+Ehrlich: Wenn meine Frau meint, die Spuelmaschine sei voll, und die 4-5 
+Teile wuerden noch flugs von Hand gespuelt, weil sie eh nicht mehr 
+reinpassen ... und wenn ich dann kopfschuettelnd vor der Maschine stehe, 
+ihre "kunstvolle" Anordnung komplett revidiere, die 5 Teile problemlos 
+noch reinraeume -- und noch 2 vergessene Tassen dazu ... Nachdem das 
+regelmaessig vorkam, hat sie spontan eingesehen, dass _ich_ die 
+Spuelmaschine fuer anstellenswert definiere und niemand sonst.
+
+... Aber die Informatiker unter uns wissen ja, dass alle relevanten 
+Optimierungsprobleme (Rucksack, TSP, 3SAT (nicht der TV-Sender!) etc.) 
+und eben auch "Spuelmaschineeinraeumen" polynomiell aufeinander 
+reduzierbar und damit NP-vollstaendig sind. ;))
+
+
+-----------------------------------------------------------------------------
+
+
+
+hamster.de.misc (Deepblue,  8. Jul 2003, 20:38:58):
+From: Frank 'Kelshon' Schmidt <Balton_Wyt@gmx.net>
+Subject: Re: Auf X-Newsreader filtern?
+Newsgroups: hamster.de.misc
+Date:Sat, 05 Jul 2003 10:38:54 +0200
+Message-ID: <030705.103854.hdm.53@grail.kelshon.de>
+
+Wolfgang Bauer <obisdorf@utanet.at> :
+
+> Gravierende Beispiele von gestern und vorgestern-
+[Demo-Postings]
+
+Ich weiss nicht, ob ich bei dieser Demonstration "User heute" lachen
+oder weinen soll.
+
+Es war Anfang der 90er Jahre, als ich mich mit einem Freund darueber
+unterhielt, "wie schoen es waere, wenn der PC verbreiteter waere. Die
+$PRODUKTE waeren viel billiger."
+Zwar waren wir uns einig, dass "bei Zugang der Masse zu diesem Medium"
+der Durchschnitts-User ueber weniger Interesse am Medium verfuegen
+wuerde, und, klar, ueber weniger Fachwissen.
+
+"Internet" kannten wir damals noch nicht, wir trieben uns im BTX
+herum.
+Es war die Zeit, da 386er auf den Markt kamen und so langsam
+erschwinglich wurden.
+Die Zeit, da ich tierisch stolz war, dass mein Rechner ueber 8 MB RAM
+verfuegte; damit war man "King" ...
+
+Es war die Zeit, da ich bei Umfragen in Zeitschriften bei der Frage,
+"Wie schaetzen sie ihr Computer-Wissen ein?" zaghaft ein Kreuz bei
+"Anfaenger" machte, und mich dann nach einer Weile endlich traute,
+"Fortgeschrittener Anfaenger" anzukreuzen.
+Mit viel Bedenken traute ich mich das.
+
+Wenn ich heute - was selten genug vorkommt - so eine Umfrage mitmache,
+ist das anders. Vehement und ohne Bedenken wird "Profi" angekreuzt
+(was die Art der Werbung erklaert, die ich im Briefkasten vorfinde.
+Obwohl Werbung von "PC Prax** an einen Profi, wirklich in der Anrede
+so gekennzeichnet! - etwas deplatziert zu sein scheint.
+Scheint.
+Eigentlich beweist sie ja nur, dass mein Kreuz nicht ueberheblich ist,
+sondern untertreibt. Es muesste - gemessen an dem, was diese Typen unter
+Profi verstehen - wohl eher bei "Super-Profi stehen. Aber das Feld
+gibt's nicht. Ausserdem wette ich, dass ich die Werbung der "PC Prax**"
+dann dennoch bekaeme ...)
+
+Ja, und wir waren uns einig, dass es toll sein wuerde, wenn die Presie
+endlich 'runtergingen, jawoll.
+"Weniger Wissen beim Durchschnitts-User?"
+Ach was - so schlimm wuerde das nicht werden.
+Geht ja gar nicht.
+Nie im Leben.
+
+Gott, waren wir naiv!
+
+Es bewahrheitete sich:
+"Verzage nicht, denn es koennte schlimmer kommen"
+Und ich verzagte nicht und ward froh .- und siehe, es kam schlimmer!
+
+Der heutige Durchschnitts-User scheint ein Wesen zu sein, das sich
+schon dann unter "PC-Kenner" einsortiert, wenn es den Einschalt-Knopf
+gefunden hat.
+Hm ...
+Irgendwie nachvollziehbar.
+Eigentlich kann ich es diesem "Wesen" ja gar nicht veruebeln.
+Es ist ja nur ein Opfer der Werbung, denn, mal ehrllich:
+Wuerden die Typen nicht so tun, als waere die Benutzung eines PC so
+einfach wie Ka***** - wer wuerde sich so'n Ding kaufen?
+
+Logo - nur "Compjuder-Idioten", solche Leute wie wir damals.
+Leute, die sich mit "komischen Dingern" befassten, von denen "kein
+normaler Mensch weiss, wozu sie gut sein sollen".
+Spinner eben; 
+Verrueckte.
+Verdienen konnte man an diesen Leuten nicht sehr viel, nur die Masse
+bringt den Umsatz.
+
+Kein Problem - man suggeriere den Leuten, dass selbst ein dressierter
+Schimpanse mit dem Geraet umgehen kann, und sie folgen dem Herdentrieb:
+Alle wollen eins, schliesslich will man "dazugehoeren".
+Natuerlich ein Goesseres/Besseres als der Nachbar.
+
+Schoene, neue Welt.
+PC (und alles, was dazu gehoert) hat ein Preisniveau erreicht, von dem
+wir damals getraeumt haben.
+Nur die damit einhergehenden Albtraeume haben wir nicht ahnen koennen
+(oder wollen?)
+
+Frank
+
+-----------------------------------------------------------------------------
+
+
+
+Popups - Endlich richtig erklaert. (Ronda, 10. Jul 2003, 01:30:43):
+Subject: Re: PopUps?
+Date: Tue, 08 Jul 2003 17:04:52 +0200
+From: Helmut Chang <news@tuivelsminne.at>
+Newsgroups: de.comm.infosystems.www.authoring.misc,de.alt.recovery.webauthor
+
+Jens Hibbeler schrieb:
+>Hi,
+>
+>ich moechte gerne wissen, wie man PopUps herstellt?
+
+Du brauchst:
+
+Material:
+6 quadratische Holzplatten
+2 Scharniere
+1 Hakenverschluss
+1 kraeftige Spiralfeder
+1 Boxhandschuh
+Schrott, um den Handschuh zu fuellen
+diverse Schrauben
+
+Werkzeug:
+Saege (evtl.)
+Schraubenzieher
+Bohrmaschine
+
+Nimm eine der Holzplatten und schraube die Spiralfeder darauf:
+
+     _______________________
+    /                      /
+   /                      /
+  /          X           /
+ /                      /
+/______________________/
+
+Fuelle den Boxhandschuh mit dem Schrott und befestige ihn an der Feder.
+Schraube nun vier weiter Holzplatten als Seitenwaende an, befestige die
+Scharniere an einer davon:
+
+
+     __\\____________\\_
+    /| ||            ||/|
+   / |      _____         / |
+  /  |    _/     \       /  |
+ /   |   / \____ /      /   |
+/____|___\__|___|______/    |
+|                      |    |
+|                      |    |
+|                      |    /
+|                      |   /
+|                      |  /
+|                      | /
+|______________________|/
+
+
+Befestige die letzte Platte als Deckel an den Scharnieren, befestige den
+Verschluss, verschliesse den Deckel mit selbigem:
+
+
+     _______________________
+    /                      /|
+   /                      / |
+  /                      /  |
+ /                      /   |
+/______________________/    |
+|           |          |    |
+|           O          |    |
+|                      |    /
+|                      |   /
+|                      |  /
+|                      | /
+|______________________|/
+
+
+Beuge dich darueber, oeffne den Verschluss... Poppt up und ist laestig,
+nicht wahr?
+
+gruss, heli
+
+f'up nach <darw />
+
+-----------------------------------------------------------------------------
+
+
+
+Rezept (Foobar, 11. Jul 2003, 23:46:36):
+[Submitter's Note: Im Ursprungsposting hatte jemand ein Rezept
+fuer Lachs geschickt, welcher in der Geschirrspuelmaschine
+zubereitet wird.]
+
+From: "Carlo Joesler" <reception@chesa-salis.ch>
+Newsgroups: de.rec.mampf
+References: <1103_1057169454@news.t-online.de>
+Subject: Re: Lachs im Geschirrspueler mit Koriandersauce 
+Date: Thu, 3 Jul 2003 15:54:52 +0200
+
+"Pedro"schrieb
+
+> Lachs im Geschirrspueler mit Koriandersauce
+
+Ermuntert durch Dein Rezept, und mangels Geschirrspuehler wollte ich auch
+kreativ sein: "Spaghetti in der Waschmaschine":  Spagetti in die
+Waschmaschine geben - den Waschmittelbehaelter mit Pamesan fuellen und
+Programm "stark beschmutzte Berufswaesche" laufen lassen.
+ellbogenschlag ist leider misslungen
+Guten Appetit
+Carlo
+
+
+-----------------------------------------------------------------------------
+
+
+
+de.comp.security.misc (Taranis, 11. Jul 2003, 23:49:14):
+Betreff: Re: Sackmann ueberfuehrt! Sicherheitsloch bei Sajoh!!!
+ Absender: Denis Jedig <dj@syneticon.de>
+ Datum: Thu, 10 Jul 2003 22:32:38 +0200
+ Newsgruppe: de.comp.security.misc
+
+ On 10 Jul 2003, you wrote in de.comp.security.misc:
+
+ > Your password must be at least 18770 characters and cannot repeat any
+ > of your previous 30689 passwords. Please type a different password.
+ > Type a password that meets these requirements in both text boxes.
+ > [M$] (Fix:
+ > http://support.microsoft.com/support/kb/articles/q276/3/04.ASP)
+
+Das ist noch gar nichts. Microsoft hat herausgefunden, dass die Erde
+sich eigentlich in eine andere Richtung drehen muesste und sucht noch
+nach einer Erklaerung fuer dieses Phaenomen:
+
+ ?-- http://support.microsoft.com/default.aspx?scid=kb;EN-US;q131109
+ | Explorapedia Nature: Earth Rotates in Wrong Direction
+ | [...]
+ | STATUS
+ | Microsoft has confirmed this to be a problem in Explorapedia, World
+ |of Nature, version 1.0. We are researching this problem and will post
+ | new information here in the Microsoft Knowledge Base as it becomes
+ | available.
+ `--
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Rezept (Huraxprax, 11. Jul 2003, 23:50:46):
+~#! rn=Foobar rt=1057959996 rg=schmarrn.netdigest
+~#! tid=1057959996
+> ellbogenschlag ist leider misslungen
+
+Uebst Du Ellbogenschlag an deinem Geschirrspuelapparat? Mal schauen wie lang
+der das noch durchhaelt.
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Rezept (Foobar, 11. Jul 2003, 23:52:30):
+~#! rn=Huraxprax rt=1057960246 rg=schmarrn.netdigest
+~#! tid=1057959996
+Sieh an, selbst mir passieren solche Fehler. :o) Substituiere "ellbogenschlag"
+durch "Es" und alles sollte in bester Ordnung sein.
+
+Foobar
+
+-----------------------------------------------------------------------------
+
+
+
+... (Foobar, 16. Jul 2003, 19:46:48):
+[SN: Eben in einem der bunten Fensterchen. Gespraechspartner weiss von 
+der Subission]
+
+Campari: weisst du was mich richtig gluecklich macht? grad hat der 
+mldonkey auf dem fileserver dem imap auf dem fli4l ne nachricht 
+uebermittelt, dass einer meiner downloads fertig ist
+
+Campari: nicht wg. dem download. sondern weil die beiden jetzt so schoen 
+zusammenarbeiten :-)
+
+MPCube: :-)
+
+Campari: ueberhaupt sind die linuxer ja voll die vernetzungsfreaks. fuer 
+den mldonkey gibt es auch ein plugin das nach fertigem download eine 
+nachricht an die linux-dbox2 schickt, die dann auf dem fernseher aufpoppt
+
+MPCube: :-)
+
+Campari: irgendwann kippt mir einer der rechner tiefnachts nen eimer 
+wasser ins gesicht um mir zu sagen dass ne defragmentierung fertig wurde 
+oder so was
+
+
+-----------------------------------------------------------------------------
+
+
+
+Objektorientierung mal anders... (Ronda, 21. Jul 2003, 19:32:54):
+... und nur bedingt jugendfrei. Trotzdem / deswegen schoen...
+
+Ronda
+
+From: Bodo Eggert <7eggert@nurfuerspam.de>
+Newsgroups: de.admin.net-abuse.mail
+Subject: Re: Spamtrap-Anleitung (Entwurf)
+Date: Thu, 17 Jul 2003 20:05:32 +0200
+Message-ID: <01l6fb.69m.ln@msgid.7eggert.dyndns.org>
+
+Daniel Rehbein <fromline@14020604.magik.de> wrote:
+> Stefan Briesenick wrote:
+
+>> bei prozeduraler Programmierung hast Du Funktionen (bumsen), denen Du
+>> Daten
+>> (anna) uebergeben kannst, mit denen sie dann was tun -> bumsen(anna)
+>>
+>> bei objectorientierter Programmierung hast Du Objekte (anna), mit denen Du
+>> etwas tun kannst/tun lassen kannst, sog. Methoden (bumsen) ->
+>> anna.bumsen()
+>>
+>> Ist zwar alles ein wenig komplexer, aber irgendwie kann man es doch darauf
+>> hin reduzieren... ;-)
+> 
+> Aha! Jetzt verstehe ich! Bei der Objektorientierung liegt also
+> die Frau oben.
+
+Nein, im ersten Fall bringt Anna das Kondom mit, waehrend im zweiten Fall
+Kondome vom Hotel gestellt werden.
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Objektorientierung mal anders... (Rochus, 21. Jul 2003, 19:37:22):
+~#! rn=Ronda rt=1058808774 rg=schmarrn.netdigest
+~#! tid=1058808774
+Objektorientirte Programmierung ist eh wie Sex im Teenager-Alter:
+1. Jeder denkt der andere macht es
+2. Keiner tut es wirklich
+3. Wenn es jemand macht, dann nicht richtig.
+
+  Rochus
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Objektorientierung mal anders... (Moonshine, 21. Jul 2003, 19:38:18):
+~#! rn=Rochus rt=1058809042 rg=schmarrn.netdigest
+~#! tid=1058808774
+Na Du musst aber eine interessante Jugend gehabt haben. ;-)
+
+Moonshine musste sich das 'haben' verkneifen. *wegrenn*
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Objektorientierung mal anders... (Troy, 22. Jul 2003, 09:12:18):
+~#! rn=Moonshine rt=1058809098 rg=schmarrn.netdigest
+~#! tid=1058808774
+...4. Wenn es jemand doch richtig macht,
+      verstehen es alle anderen nicht mehr.
+
+Troy
+
+-----------------------------------------------------------------------------
+
+
+
+Bravo Hits (Nonne, 24. Jul 2003, 08:58:17):
+Fuer den kleinen Lachanfall zu Hause heute mal die etwas anderen Antworten
+der Bravo. Ihr wisst schon, dieses Heftchen ueber Pop(p)stars und welche, die
+es werden wollen......
+
+
+Wachse ich nach dem Sex nicht mehr?
+RACHEL, 15:
+Ich habe seit einem halben Jahr einen Freund, und allmaehlich wollen wir auch
+miteinander schlafen. Doch da gibt es ein Problem, das mich sehr bedrueckt.
+Als ich naemlich mit meiner Freundin darueber sprach sagte sie, dass sich der
+Koerper nach dem ersten Mal nicht weiterentwickelt. Davor habe ich Angst,
+denn meine Figur ist noch sehr kindlich. Wenn das stimmt, wuerde es auch
+meine Mutter bemerken. Das will ich auf keinen Fall....
+
+Eine interessante Theorie, so stoppt man also den Alterungsprozess!
+
+
+Ich war noch nie so richtig high?
+CAROLINE, 17:
+Vor acht Monaten schlief ich zum erstenmal mit meinem Freund. Aber ich habe
+noch nie einen Orgasmus erlebt. Ich hatte zwar oft ein super Gefuehl, aber
+ich war noch nie so richtig high. Manche Maedchen schreien doch dabei,
+verlieren sogar sekundenlang das Bewusstsein. Oder ist das nicht die Norm?
+
+Bewusstlosigkeit beim Sex? - Aha, ich dachte immer die waeren dabei
+eingeschlafen. Danke Caroline!
+
+
+Mein Penis huepft auf und ab?
+MANUEL, 13:
+Ich habe was Komisches an mir entdeckt und weiss nicht, ob es in Ordnung ist.
+Vor kurzem habe ich versucht mich selbst zu befriedigen.Dabei huepfte mein
+Penis im steifen Zustand eine ganze Weile von selber auf und ab. Dann kam
+eine waessrige Fluessigkeit heraus. War das ein Samenerguss? Und wieso bewegt
+sich mein Penis selbst?
+
+Manuel, er nickt doch nur weil es ihm gefaellt!
+
+
+Zu jung fuer Petting?
+KATI, 14:
+Mein Freund (14) ist total suess und lieb. Wir sind sehr offen zueinander und
+reden ueber alles. Wir haben schon viel ausprobiert. Zum Beispiel beruehren
+wir uns ueberall. Manchmal liegen wir auch ausgezogen uebereinander und
+bewegen uns wie beim Geschlechtsverkehr. Das geht oft so lange, bis mein
+Freund einen Samenerguss bekommt. Ich habe manchmal ein bisschen Angst, denn
+ich habe ja auch schon meine Regel. Richtig tun wollen wir "es" erst so mit
+16 oder 17 Jahren. Jetzt wuerde uns interessieren, ob das okay oder in
+unserem Alter irgendwie schaedlich ist?
+
+Wirklich interessant, was die Jugend heut so in ihrer Freizeit tut.
+Richtig wuerde ich es an Eurer Stelle noch nicht tun, da hoert man auf zu
+wachsen, kann ohnmaechtig werden und kriegt einen krummen Ruecken. Haben Eure
+Eltern Euch das noch nicht erzaehlt??
+
+
+Kann ich mich an einem Glas mit AIDS anstecken?
+BIANCA, 12:
+Mich beschaeftigt eine Frage zum Thema AIDS. Die Jungs und Maedchen in meiner
+Klasse trinken manchmal aus dem selben Glas oder gleichen Flasche. Kann man
+sich dadurch nicht auch anstecken? Und wie ist das beim Kuessen?
+
+Liebe Bianca, Dein Brief hat mich ja schockiert.. Haben Deine Mitschueler
+echt alle AIDS? Bist Du etwa in einer Schule fuer Fruehreife? Sollte es bei
+Dir noch nicht zu spaet sein, wechsle
+die Schule!
+
+
+Es riecht nach Fisch?
+EVA, 15:
+Seit laengerer Zeit sind auf meinen Schamlippen so komische Pickel. Sie
+gleichen denen, die man manchmal auf der Zunge hat. Ist das was Krankhaftes?
+Wenn ich meine Tage habe, riecht das Menstruationsblut fuerchterlich nach
+Fisch. Hat das vielleicht mit diesem Ausschlag zu tun?
+Ausserdem sind meine beiden Schamlippen lang und schrumplig. Die linke ist
+sogar laenger als die rechte. Das sieht echt ecklig aus.
+
+Also das ist wirklich eklig, ich kann gar nix dazu sagen wuerg ...
+
+
+Meine Scheide sieht anders aus?
+KARIN, 13:
+Aus meiner Scheide haengen zwei dicke Hautlappen heraus. Ich kann mir nicht
+vorstellen, dass das normal ist. Bei meiner Freundin,die ich schon mal nackt
+gesehen habe, ist mir das nicht aufgefallen. Ich habe Angst, dass ich
+Probleme bekomme, wenn ich spaeter mal mit einem Jungen schlafen will.
+Tampons kriege ich auch nicht in meine Scheide. Ich habe
+es schon ein paarmal vergeblich versucht. Kann ein Arzt sowas operieren?
+
+Du solltest Dich mal mit Eva (15) in Verbindung setzen, vielleicht kann sie
+Dir ja helfen.
+Was das Tampon-Problem betrifft: Die kommen laengs rein und immer nur einer!
+
+
+Kondome in Sondergroessen?
+MANUELA, 15:
+Ich habe einen Freund, mit dem ich auch regelmaessig schlafe.Ich nehme die
+Pille, er zusaetzlich ein Kondom. Wir haben aber ein Problem dabei. Weil der
+Penis meines Freundes recht gross und dick ist, hat er Schmerzen beim
+Geschlechtsverkehr. Das Kondom ist naemlich zu eng und passt auch nicht in der
+Laenge. Es ist schon passiert, dass das Kondom geplatzt ist. Bei der Anwendung
+machen wir bestimmt nichts falsch. Gibt es Kondome in Sondergroessen?
+
+Das Kondom ist zu eng und zu kurz und platzt beim Gebrauch? Ja, das kenn ich
+ist man erstmal in dem Scheissding drin, faellt einem das Atmen schwer und
+kaum holt man mal tiefer Luft, platzt es. Ausserdem spannt es im Gesicht.
+Vielleicht sollte Dein Freund das naechste Mal erst mit den Fuessen in das
+Praeservativ (Anmerkung: das heisst auch Kondom) steigen und
+nicht wie sonst mit dem Kopf voran.
+
+
+Wie kann man den Hoehepunkt vortaeuschen?
+BEATE, 15:
+In meiner Clique reden die Maedchen viel ueber Sex. Kuerzlich haben sie sich
+darueber unterhalten, dass man einen Orgasmus vortaeuschen kann. Aber keine
+hat
+genau gewusst, wie man das macht. Koennen Sie es uns sagen?
+
+Also ich koennte da eher den maennlichen Lesern helfen, aber die Sache mit dem
+warmen Joghurt ist ja eigentlich ziemlich bekannt. Dir Beate kann ich nur
+sagen, wenn ihr irgendwann mal im Cliquen-Kreis die Vortaeuschung eines
+Orgasmus uebt, ruft mich an, da moecht' ich dabei sein!
+
+
+Sind zwei Kondome sicherer?
+SANDRA, 14:
+Ich bin sehr gespannt auf mein erstes Mal. Aber ich habe panische Angst vor
+einer ungewollten Schwangerschaft. Die Pille moechte ich noch nicht nehmen.
+Also bleibt das Kondom. Kann man nicht zwei oder drei Kondome
+uebereinanderziehen, damit nichts daneben geht? Meine Freundin sagt jedoch,
+dass dann der Penis nicht mehr in die Scheide passt. Stimmt das?
+
+Klar kann man mehrere Kondome uebereinanderziehen, wenn's regnet zieh ich
+auch zwei paar Gummistiefel uebereinander. Was Deine Freundin sagt stimmt,
+deswegen solltest Du nicht Opas Leinenkondome benutzen.
+
+
+Pickel am Penis durch Orgasmus?
+JAN, 13:
+Seit laengerer Zeit habe ich gelbliche Pickel am Penis. Wenn ich sie
+aufdruecke, kommt ein eitriges Zeug heraus, das eklig riecht. Kann das
+vielleicht davon kommen, weil ich fast taeglich onaniere? Ich kriege dann
+naemlich schon nach ein paar Sekunden einen Orgasmus. Ein Freund von mir
+sagt, das seien sogenannte Orgasmuspickel, ich muesse auf jeden Fall zum Arzt
+gehen. Davor habe ich aber schreckliche Angst.
+
+ORGASMUSPICKEL......* muhahahaha*
+
+
+Der Tampon ist in meiner Scheide verschwunden?
+NICOLE, 13:
+Seit einiger Zeit nehme ich Tampons.. Als ich den Tampon, den ich vor fuenf
+(!!!!!) Tagen eingefuehrt hatte, wieder herausholen wollte, ist das Band
+abgerissen. Ich bekomme den Tampon nicht mehr aus meiner Scheide heraus. Ich
+habe das Gefuehl, dass er sogar immer weiterhinein rutscht. Was soll ich tun?
+Ist es schaedlich, wenn der Tampon in meinem Koerper bleibt? Oder loest er
+sich
+irgendwann selbst auf?
+
+Ja, ja, genau so war es auch bei meinem Gewehr das ich bei der Bundeswehr
+reinigen wollte, ich zog am Faden und er riss. Der Reinigungsdocht blieb im
+Lauf. Mein Unteroffizier meinte es waere gefaehrlich, wenn der Docht im Lauf
+bliebe, deswegen hat er ihn ja dann auch rausgeholt. Ich kann Dir also nur
+das gleiche raten - Wende Dich an meinen Unteroffizier!
+
+
+War das ein Orgasmus?
+JANINE, 12:
+Mit meiner Freundin habe ich neulich ueber Selbstbefriedigung gesprochen. Zu
+Hause versuchte ich es nachzumachen, woran ich mich erinnerte. Ich hatte
+schnell so ein komisches Gefuehl in der Scheide. Als ich weitermachte, wurde
+dieses Gefuehl staerker, ich musste unwillkuerlich dabei stoehnen. Und auf
+einmal
+zuckte ich zusammen. Dann war alles vorbei. War das wirklich ein Orgasmus
+oder nur Einbildung?
+
+Also erstmal: Haettest Du Dir was zu Schreiben zu Deiner Freundin
+mitgenommen, haettest Du sicher noch mehr probieren koennen und
+zusammengezuckt bist Du nur, weil Du Dich erschrocken hast, als Papa in
+Deinem Zimmer stand. Aber mach Dir nichts draus, es ist ganz normal fuer ein
+Maedchen in Deinem Alter, sich in einer solchen Situation zu erschrecken.
+
+
+Tut es auch dem Jungen weh?
+LUKAS, 15:
+Ich habe noch keinen Geschlechtsverkehr gehabt und moechte deshalb wissen,
+wie das so ablaeuft. Tut es auch dem Jungen weh, wenn er zum erstenmal mit
+einem Maedchen schlaeft? Ist es schwer das Jungfernhaeutchen zu durchstossen?
+Soll der Junge besser versuchen, dem Maedchen zuerst mit den Fingern in die
+Scheide zu gehen? Wie ist das eigentlich, verwendet das Maedchen nach dem
+ersten Mal einen groesseren Tampon?
+
+Also, es braucht schon eine ganz schoene Kraftanstrengung das
+Jungfernhaeutchen zu durchstossen, wuerde Mann sonst stoehnen? Was willst Du
+mit
+den Fingern in der Scheide? - Das Jungfernhaeutchen erst suchen?
+Groessere Tampons nach dem ersten Sex?
+Nein, das Maedchen rollt sich dann die Binde...
+
+
+Ein Treffer in die Hoden?
+STEFAN, 14:
+Kuerzlich bekam ich beim Fussballspielen einen Treffer ganz dicht neben meine
+Hoden. Jetzt hab ich richtig Angst vor dem naechsten Spiel. Es muss doch
+hoellisch weh tun, wenn der Ball direkt die Hoden trifft. Kann man sich davor
+schuetzen?
+
+Du brauchst doch keine Angst haben, Stefan. Sollte Dich beim naechsten Spiel
+der Ball echt in die Hoden treffen, dann wirst du halt nicht Fussballer
+sondern kommst in den Knabenchor. Musiker sind eh besser bezahlt als
+Fussballer.
+
+
+Tampon als Verhuetungsmittel?
+JUDITH, 15:
+Mir ist was Schlimmes passiert. Ich habe mit meinem Freund waehrend meiner
+Tage geschlafen. Denn er sagte, der Tampon sei ein gutes Verhuetungsmittel,
+weil er das Sperma aufsaugt. Doch hinterher fand ich den Rueckholfaden des
+Tampons nicht mehr. Der Tampon ist noch immer in meiner Scheide! Ich weiss
+nicht was ich tun soll. Mein Freund sagt, ihn ginge das nichts an.
+
+Also, Dein Freund sollte mal das aufgeweichte Broetchen aus seinem Kopf
+nehmen! An dieser Stelle nocheinmal: Es scheint ja, das sowas mit den
+Tampons die nicht mehr raus wollen oefters passiert. Nicht das Ende mit dem
+Faden zuerst rein sondern andersherum. Am besten ihr knotet an das Ende des
+Fadens irgendwas (z.B. ein kleines Plueschtier) dann kann er nicht mehr
+verschwinden. Ansonsten kann ich wieder nur an meinen Unteroffizier
+verweisen.
+
+
+Wie lange halten Kondome?
+LILLI, 15:
+Meine Freundin und ich haben uns nur so aus Scherz ein Kondom gekauft. Wir
+wollten mal sehen, wie sich das anfuehlt. Koennen wir eigentlich die Kondome
+aufheben und sie vielleicht erst nach ungefaehr einem Jahr benutzen? Oder
+sind sie nach einer bestimmten Zeit nicht mehr sicher?
+
+Wenn ihr keine Loecher reingemacht habt (das ist wichtig!), sie wieder
+ordentlich zusammenrollt und in die Verpackung tut, koennt ihr sie aufheben
+und irgendwann benutzen. Das habt ihr aber nicht von mir gehoert!
+
+
+Platzt das Jungfernhaeutchen mit einem Knall?
+Markus, 14:
+Lieber Dr. Sommer, Ich moechte bald zum ersten Mal mit meiner Freundin
+schlafen. Meine Freundin hat mir gesagt, dass dabei das Jungfernhaeutchen
+platzt. Nun habe ich Angst, dass meine Eltern durch den Knall wach werden und
+uns erwischen!
+
+Ja ja... das erklaert auch die Risse in den meisten Hauswaenden....
+
+
+Nonne, lacht sich immer noch kringelig.
+
+-----------------------------------------------------------------------------
+
+
+
+USV oder nicht USV... (Ronda, 28. Jul 2003, 00:00:39):
+Message-ID: <3812552.dnQhQMxhiq@ncc74565.kaerner.net>
+Subject: Re: Wurm/Virus als Spammer
+Date: Wed, 23 Jul 2003 16:21:43 +0200
+From: "Ralph D. Kaerner" <ralph@kaerner.net>
+Newsgroups: de.alt.sysadmin.recovery
+
+Andreas Riedel wrote:
+> Entweder man stellt seinen Wecker vor dem Urlaub ab, oder man kauft
+> sich eine USV...
+
+in $bude in Essen hatte der Nachbar aufgrund der instabilen
+Hausversorgung nicht nur seinen am dsl haengenden "Server", sondern auch
+gleich den Wecker abgesichert, damit er morgens auf keinen Fall
+verschlaeft. Hielt ihn nicht davon ab, in Urlaub zu fahren, ohne das
+Ding abzustellen.
+
+Nunja... "auch eine USV geht irgendwann in die Knie" meinte der
+Polizist[1] und ging mit der Sicherung ein paar Stunden auf Streife.
+
+Ralph
+
+[1] Der Typ war wirklich recovery, von der Sorte erlebte ich bis jetzt
+nur wenige.
+
+-----------------------------------------------------------------------------
+
+
+
+Die beste Erklaerung... (Ronda, 28. Jul 2003, 00:07:37):
+... die ich je zu Drehstrom gelesen habe ;-)
+
+From: "Sebastian \"Schrottschere\" Suchanek" <spambin@suchanek.de>
+Newsgroups: de.rec.modelle.misc
+Subject: Re: ???Drehstrommotor??? - Elektrotechniker gesucht :)
+Date: Tue, 22 Jul 2003 20:03:31 +0200
+Message-ID: <bfk5ag.3vvjitf.1@suchanek.de>
+
+"Sebastian Siewert" <OGDTheonliest@gmx.de> spoke thusly:
+
+> Ich verzweifle gerade jaemmerlich am Prinzip des
+> Drehstrommotors. Kann mir jemand erklaeren wie der
+> funktioniert?
+
+<Sendung mit der Maus>
+
+Das ist ein Stromkabel.
+*Kabel_hoch_halt*
+Da sind drei Adern drin und eines davon nennt man "Phase".
+Klingt komisch, iss aber so.
+
+Die Phase ist dafuer zustaendig, den elektrischen Strom zum
+Verbraucher zu transportieren. Ein Verbraucher, das kann ein
+Gluehbirne sein, ein Computer, euer Fernseher oder Muttis Mixer.
+[Jeweils kurz die Gegenstaende einblenden]
+Zurueck fliesst der Strom dann ueber ueber den Neutralleiter. Das
+ist der blaue hier.
+*auf_Ader_zeig*
+
+Die dritte Ader, die so lustig gruen-gelb gestreift ist, die ist
+nur zu eurer Sicherheit da.
+
+Dass der Strom in einer Ader zum Verbraucher hinfliesst und in
+einer zweiten wieder zurueck, funktioniert z.B. bei Muttis Mixer
+ganz toll, weil der so klein ist.
+
+Aber was ist, wenn euer Papa im Keller mit seiner Kreissaege
+arbeiten will? Die ist viel groesser und braucht viel mehr Kraft.
+[Kreissaege zeigen]
+*am_Kopf_kratz*
+
+Also haben sich ein paar schlaue Leute Gedanken gemacht und
+haben sich ueberlegt, dass es bei solchen grossen Maschinen ja viel
+besser waere, wenn da nicht nur ein Leiter hinfuehrt, sondern
+gleich drei.
+Und damit nicht so viel Strom auf einmal in die Maschine fliesst
+und es dem viel Strom da drin nicht zu eng wird, laesst man den
+Strom immer abwechselnd fliessen. Zuerst in der einen Phase, dann
+in der zweiten Phase und dann in der dritten Phase. Und damit
+sich eine Phase nicht zu lange so anstrengen muss, wechseln die
+sich nicht langsam ab, sonder fuenfzig Mal in einer Sekunde. Das
+ist ganz, ganz schnell.
+
+Und warum man das jetzt "Drehstrom" nennt, erklaeren wir euch
+gleich - nach der naechsten Maus.
+
+[Maus-und-Elefant-Filmchen]
+
+Hier sind wir wieder mit dem "Drehstrom". Der "Drehstrom" heisst
+"Drehstrom", weil sich da 'was dreht. Logisch, oder?
+Aber was dreht sich da?
+*Kopf_kratz*
+
+Schauen wir uns mal den Motor von Papis Kreissaege aus der Naehe
+an:
+[Zoom auf Stator]
+Dieses viele Metall, dass da so orange glaenzt sind Kupferspulen.
+Und weil man das da drin so schlecht sieht, haben wir das hier
+nochmal extra aufgebaut.
+
+[Schnitt auf Experimentiertisch. Darauf stehen drei Spulen,
+sternfoermig im 120-Winkel angeordnet
+
+
+                       .-----.
+                       |O####|
+                       |#####|
+                       |#####|
+                       |####O|
+                       '-----'
+
+
+
+                 /-.            .-\
+                /O##-.        .-###\
+               /######/      \O#####\
+              /######/        \######\
+             /######/          \#####O\
+             -.####/            \####.-
+               -.O/              \#.-
+]
+
+Hier haben wir jetzt ein Kabel mit Drehstrom drin.
+*fuenfadriges_Kabel_hochhalt*
+
+Die drei Phasen sind diese drei Adern hier:
+*Auf_Schwarz,_Braun_und_Schwarz_zeig*
+
+Jetzt schliessen wir mal jede der drei Phasen an eine Spule an.
+*anstoepsel*
+
+Und damit der Strom auch wieder zurueckfliessen kann, schliessen
+wir die blaue Ader auch noch an. Das kennt Ihr ja schon vom
+Mixer.
+*Blaue_Ader_mit allen drei Spulen verbind*
+
+So, und jetzt passiert etwas lustiges: In und um jede Spule gibt
+es immer dann ein Magnetfeld, wenn da Strom durchfliesst. Ein
+Magnetfeld, das ist etwas, das ihr nicht sehen, hoeren, riechen,
+schmecken oder fuehlen koennt. Aber kennt es sicher trotzdem. Denn
+jeder Magnet hat auf ein Magnetfeld und das Magnetfeld sorgt
+z.B. dafuer, dass sich zwei Magnete gegenseitig anziehen oder dass
+ein Magnet Eisen anzieht.
+*Mit_Magnet_und_Naegel_spiel*
+
+Der Zeiger in einem Kompass ist auch ein Magnet. (Einen Kompass
+kennt Ihr sicher. Das hat euer Papi bestimmt dabei, wenn er mit
+Mutti und euch Wandern geht.) Das sieht man z.B., wenn man einen
+anderen Magneten aussen dranhaelt.
+*Mit_Magnet_um_Kompass_fahr* [die Nadel bewegt sich mit dem
+Magneten mit]
+
+Und was der Kompass mit den Spulen hier zu tun hat, das erzaehlen
+wir Euch gleich, nach der naechsten Maus.
+
+[Noch ein Maus- und Elefant-Filmchen]
+
+So, hier sind wir wieder mit den drei Spulen und einem Kompass.
+Dass der Zeiger dadrin magnetisch ist, habt ihr ja gerade
+gesehen. Und dass eine Spule ein Magnetfeld hat, haben wir Euch
+auch schon gesagt. Was passiert jetzt, wenn wir den Kompass
+mitten zwischen die Spulen stellen?
+*Kompass_zwischen_die_Spulen_stell* [Die Nadel beginnt wie wild
+zu rotieren]
+
+Seht Ihr: der Zeiger im Kompass dreht sich. Aber warum? Ganz
+einfach: Vorhin haben wir euch ja gesagt, dass der Strom immer
+abwechselnd durch die drei Spulen fliesst. Das machen wir jetzt
+'mal ganz langsam.
+*Heimlich_zwei_Spulen_abschalt*
+
+Seht Ihr, jetzt fliesst nur durch eine Spule Strom.
+*auf_Spule_deut*
+Die macht ein Magnetfeld, das die Kompassnadel anzieht.
+[Die Nadel zeigt auf die Spule]
+
+So, jetzt ist die naechste Phase und damit die naechste Spule
+dran.
+*auf_zweite_Spule_deut*
+*Heimlich_auf_zweite_Spule_umschalt*
+[Die Nadel zeigt auf die zweite Spule]
+
+Und als letztes kommt jetzt die dritte Phase mit der dritten
+Spule dran.
+*auf_dritte_Spule_deut*
+*Heimlich_auf_dritte_Spule_umschalt*
+[Die Nadel zeigt auf die dritte Spule]
+
+Und das geht jetzt immer so weiter, nur schneller. Erst eins,
+dann zwei, dann drei, dann wieder eins, zwei, drei, eins, zwei,
+drei...
+[Immer schneller werdender Zeitraffer]
+
+[Wieder auf normale Filmgeschwindigkeit, die Spulen wieder an
+Drehstrom]
+*Schweiss_abwisch*
+
+Und genau so funktioniert das auch in Papas Kreissaege. Auch da
+sind die Spulen drin
+[Nochmal leeren Stator zeigen]
+und auch darin dreht sich dann eine Art Magnet
+*Rotor_einsetz*
+
+Und weil der der Motor wegen drei Phasen so viel Kraft hat und
+weil sich der Magnet dadrin so schnell dreht, kann der Papa
+damit ganz toll dicke Brette schneiden.
+[Papa beim Saegen zeigen]
+
+</Sendung mit der Maus>
+
+> Und dann vielleicht noch wie die
+> Drehzahlsteuerung fuer diese Brushless-Motoren funktioniert.
+
+Tut's da auch eine einfache Erklaerung? :-)
+Zur Drehzahlsteuerung wird einfach die Frequenz geaendert.
+
+> Will aus Kostengruenden eine eigene Steuerung auf Basis
+> eines Hall-Gebers bauen.
+
+Ich denke nicht, dass Du realen Chancen hast, so einen Eigenbau
+mit vertretbaren zeitlichen und finanziellen Mittel zu
+verwirklichen.
+
+> Aber im Moment hakt es leider aus bei mir.
+> Ich hoffe mir kann jemand von euch auf die Spruenge helfen.
+
+
+HTH,
+
+Sebastian
+
+PS: Und wehe, das kommt jetzt nicht in den Netdigest! ;-)
+
+PPS: Die kleinen sachlichen Fehler moegen mir die Fachleute bitte
+     verzeihen. :-)
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Die beste Erklaerung... (Muadib, 28. Jul 2003, 00:10:56):
+~#! rn=Ronda rt=1059343657 rg=schmarrn.netdigest
+~#! tid=1059343657
+wow endlich hab ich das verstanden
+
+-----------------------------------------------------------------------------
+
+
+
+Fast de.alt.netdigest - deswegen hier... (Ronda, 28. Jul 2003, 00:11:47):
+Signatur in de,alt.soc.knigge:
+
+Wer ein Web-Interface fuer News benutzt der filmt auch seine Morgenzeitung
+ohne sie zu lesen und schaut sie sich abends im Fernseher an. :-)
+(Matthias Esken in news:de.newusers.questions)
+
+
+-----------------------------------------------------------------------------
+
+
+
+VW (Foobar,  2. Aug 2003, 19:06:32):
+Newsgroups: de.rec.motorrad
+Subject: Re: Quads-vierraedrige Motorraeder und Helmpflicht (etwas
+From: Ralf 'Garfield' Pysny <maerz03@rasender-killer.de>
+Date: Tue, 29 Jul 2003 08:58:17 +0200
+Message-ID: <3F261B09.3D0C800D@rasender-killer.de>
+
+
+
+Bernd Sluka schrieb:
+
+> In Deutschland gibt es nur sehr, sehr selten "40cm tiefe und sehr
+> matschige Pfuetzen" auf der Strasse.
+
+Wenn die Strassenerhaltung so weitergeht wie in den letzten Jahren, wird
+man aber bald mit sowas rechnen muessen :-(
+
+Ansonsten gilt fuer fast alle Fahrzeuge die gute Empfehlung, die VW vor
+Jahrzehnten an einen besonders hartnaeckigen Frager herausgegeben hat:
+"Der Kaefer ist wasserdicht. Trotzdem sollte man groessere Pfuetzen
+umfahren, besonders wenn sie auf der Landkarte mit einem Namen
+bezeichnet sind."
+
+
+Gruss, Garfield
+
+F'up ignorierend.
+
+-----------------------------------------------------------------------------
+
+
+
+Pager- vs. Kinder"herstellung" (Ronda,  3. Aug 2003, 23:28:53):
+Hm. Wer dabei irgendwie an die Mudparty denkt... darf die Gedanken behalten.
+Oder versuchen, einen Pager zu bauen. Oder so.
+
+Ronda *steht grad neben sich*
+
+Newsgroups: de.alt.folklore.urban-legends
+From: Volker Gringmuth <einklich@gmx.net>
+Subject: Re: IKEA Kindesraub UL
+Date: Tue, 29 Jul 2003 22:50:13 +0200
+Message-ID: <bg6tn4.3vg6opb.1@h1.einklich.net>
+
+Sebastian Posner (sposner@gmx.de) wrote:
+
+>>>>> Pager haben halt einen enormane Vorteil: Man kann sie
+>>>>> ausschalten.
+>>>> Kinder auch.  Bloss wieder an ist knifflig.
+>>> Muss man halt neue machen. Ist bei Kindern einfacher als bei
+>>> Pagern.
+>> Quatsch. Die taegliche Ausbringung pro Fertigungseinheit ist bei
+>> Pagern *wesentlich* hoeher (sicher einige hundert) als bei Kindern
+>> (0,00375[1]).
+>
+> Dafuer braucht man keine besondere Qualifikation fuer die MOntage
+> eines Kindes
+
+Fuer die Montage nicht, da der Installer in einer geeigneten
+Laufzeitumgebung selbstentpackend arbeitet - aber die anschliessende
+Systemkonfiguration ist bei Kindern eine aeusserst komplexe
+Angelegenheit, die sich nicht selten ueber Jahre hinzieht und absolut
+nicht mit der von Pagern zu vergleichen ist.
+
+> so dass die potentielle Kinderherstellungsarbeiterschar immens
+> groesser ist als die der potentiellen Pagerherstellerarbeiter
+
+..., die es aber bedauerlicherweise oftmals bei der blossen Montage der
+Hardware belaesst.
+
+In einem heute ueblichen Kinder-LAN, ob lockerer Gamepool oder eine
+dieser Seriously Challenged Hybrid Unities for Learning and Education,
+ist ein zweistelliger Prozentsatz von teilweise schwerwiegend
+fehlkonfigurierten Einheiten schon die Regel - die Performance des
+jeweiligen Systems leidet darunter gravierend.
+
+
+vG
+
+-----------------------------------------------------------------------------
+
+
+
+Praegnant. (Ronda,  5. Aug 2003, 02:58:33):
+[SN: Quoting leicht ergaenzt]
+
+Subject: Re: Stornierter Schroeder-Urlaub koennte 50 000  Euro kosten
+From: Matthias Kryn <usenet.kryn@planet-interkom.de>
+Message-ID: <3f1cf781$0$6781$9b4e6d93@newsread2.arcor-online.net>
+Date: Tue, 22 Jul 2003 10:36:23 +0200
+Newsgroups: arcor.misc
+
+> "Ulrich F. Heidenreich" <use.reply-to@spamfence.net> scripsit/wrote:
+>
+>> So streng wuerde ich das wiederum nicht sehen. Ich stolperte nur ganz
+>> einfach ueber die Inkontinenz (sp?), dass dieses Storno die Steuerzahler
+>> 50.000  kosten taete, eine stattdessen ausgefuehrte Urlaubsreise jedoch
+>> (implizit) nicht: [...]
+
+Inkonsistenz ist, wenns nicht so laeuft, wie mans gesagt hat, dass mans
+halten wuerde.
+
+Inkontinenz ist, wenns laeuft, obwohl mans lieber halten wuerde.
+
+Gruesse
+Matthias
+
+-----------------------------------------------------------------------------
+
+
+
+Zur Realnamen-Diskussion im Usenet... (Ronda,  5. Aug 2003, 03:05:52):
+... mal ein neuer Aspekt. Zur Info: die Webseite ist wohl
+http://home.arcor.de/mschierlm/de-autoren.htm
+
+Ronda
+
+Newsgroups: de.comp.software.shareware
+Re: 0 und 1 hoerbar machen
+From: "Jason Dark" <jason@dark.net>
+Subject: Re: 0 und 1 hoerbar machen
+Date: Donnerstag, 31. Juli 2003 15:23
+
+On Wed, 05 Mar 2003 22:28:59 +0100, Michael Schierl wrote:
+
+> warum "Nicks" (anstelle von Realnamen, nicht
+> zusaetzlich zu Realnamen) im Usenet von vielen abgelehnt werden.
+
+An Deiner Stelle waere ein Nick allerdings wirklich angebracht, denn dann
+wuerde man sich nicht so schnell auf Deine 'Homepage' verirren, und wuerde
+nicht erschrecken, wenn man sich die Kategorie 'Ueber uns' anschaut -lol-
+
+Also mal ganz ehrlich, manchmal ist es wirklich besser, wenn man anonym
+bleibt...
+-- 
+Jesus sprach "Es werde Licht"....
+
+-----------------------------------------------------------------------------
+
+
+
+Praezise Reaktion (Grimmborn,  7. Aug 2003, 12:34:12):
+From: Florian Diesch <epsilon@gmx.de> 
+Newsgroups: de.comp.os.unix.linux.misc 
+Subject: Re: autotransfer via scp? 
+Date: Mon, 4 Aug 2003 22:27:04 +0200 
+Message-ID: <o5s201-gj1.ln1@ID-152067.user.dfncis.de> 
+ 
+Christoph Kliemt <christoph.kliemt@entici.de> wrote: 
+> "M.Schulz" <Mike.Schulz@web.de> writes: 
+>> weis einer von euch ob es moeglich ist, z.Bsp. via cron Dateien via 
+>> scp ohne user-feedback auf eine andere Maschine zu kopieren? 
+> 
+> Es ist moeglich. 
+ 
+Er wollte wissen, ob es jemand weiss, nicht ob es moeglich ist. 
+Bitte lies doch zuerst die Beitraege, bevor du antwortest. 
+ 
+ 
+Florian 
+
+GdA
+
+-----------------------------------------------------------------------------
+
+
+
+Spam (Foobar,  7. Aug 2003, 19:11:21):
+[Anmerkung des Moderators: Also diesen Spam finde ich doch richtig
+lustig... :-)]
+
+Hallo  de-alt-netdigest,
+
+Ich habe dich letztens im Internet gesehen. Wir beide hatten
+uns kurz unterhallten und ich wollte das Gespraech gern
+weiter fuehren. Ich fand dich ja doch sehr nett. Du hast mich
+doch nicht vergessen? Du was machst du eigentlich am
+Wochenende? Ich koennte mit gut vorstellen, dass wir beide
+uns mal verabreden sollten. 
+[..]
+
+-----------------------------------------------------------------------------
+
+
+
+Kurz und praezise (Ronda, 10. Aug 2003, 00:31:51):
+From: moeller@cdc.informatik.tu-darmstadt.de (Bodo Moeller)
+Message-ID: <slrnbj7935.98b.moeller@cdc-ws13.cdc.informatik.tu-darmstadt.de>
+Date: Fri, 8 Aug 2003 13:23:49 +0000 (UTC)
+Newsgroups: de.etc.haushalt
+
+Ich habe einige Kleidungsstuecke, die laut Pflegeetikett nur bis 30 C
+waschbar sind. Kommen die Eiswuerfel in die Einspuelkammer oder direkt
+in die Waschtrommel?
+
+-----------------------------------------------------------------------------
+
+
+
+Oestereicher (Nonne, 11. Aug 2003, 09:58:04):
+Guess history tells it was a no good idea for Europe that the Germans
+vote for an Austrian even in bad times.
+
+Californians better don`t vote for Schwarzenegger!
+
+
+-----------------------------------------------------------------------------
+
+
+
+Strom (Foobar, 17. Aug 2003, 21:27:22):
+From: Michael 'Gutti' Gutberlet <mgutberlet@web.de>
+Subject: Re: Stromausfall in Nordamerika, wer kann davon profitieren?
+Newsgroups: de.etc.finanz.boerse.misc
+Date:Fri, 15 Aug 2003 21:00:46 +0200
+Message-ID: <gkx76753syd2$.x1byl3cxkddk.dlg@40tude.net>
+
+On Fri, 15 Aug 2003 17:00:05 +0200, Michael Halbig wrote:
+
+> Glaube kaum an den Baby-Boom, denn die meisten New Yorker sind ja im Verkehr
+> stecken geblieben...
+
+Diese Worte muss man sich auf der Zunge zergehen lassen ;-)
+
+SCNR
+Michael
+
+-----------------------------------------------------------------------------
+
+
+
+aus ger.ct (Nonne, 19. Aug 2003, 12:51:25):
+Eine Freundin hat Festplattenproblem: (Quoting aufs Wesentliche beschraenkt)
+
+Ist sie attraktiv? Die Freundin, mein ich. Das ist doch DIE Chance, auf 
+die viele Nerds jahrelang warten, wenn sie mal alle Rollerblader, 
+Kitesurfer und Freeclimber aus dem Bekanntenkreis des Maedels alt 
+aussehen lassen koenne! Haeng Deine Dienste bloss nicht zu tief auf...
+
+(Mein Chef meint immer, der groesste Fehler, den wir Aerzte gemacht haben, 
+war der Verzicht auf die Holzmaske und die Trommeln...)
+
+Nonne *kichernd*
+
+-----------------------------------------------------------------------------
+
+
+
+Die Zukunft der Musikindustrie (Foobar, 25. Aug 2003, 22:27:26):
+ Lang, nicht witzig, sondern traurig. Evtl 'q' druecken.
+ -----
+
+ From: Michael Tabel <mtabel@pironet-ndh.com>
+ Newsgroups: ger.ct
+ Subject: Die Zukunft der Musikindustrie
+ Date: Mon, 25 Aug 2003 13:34:59 +0200
+ Message-ID: <3F49F463.54429935@pironet-ndh.com>
+
+ Hallo,
+
+ erschlagt mich nicht wenn es schon mal hier drin gestanden haben sollte.
+ Ich fands lesewert und moecht es euch nicht vorenthalten :o)
+
+ Gruss
+
+ Michael
+
+
+ Die Zukunft der Musikindustrie
+
+ 2002: Als beste Kuenstler werden Madonna, Herbert Groenemeyer, Tom
+ Jones, Cher, und Santana ausgezeichnet. Zu den Top-Hits gehoeren
+ Westlife mit "Uptown Girl", die No Angels mit "All Cried Out", Kelly
+ Osbourne mit "Papa Don\'t Preach", Madonna mit "American Pie". Die
+ Musikindustrie erfaehrt zum ersten Mal nach einer langen Boomzeit
+ einen Umsatzrueckgang. Als Hauptursachen macht sie das in Mode
+ gekommene Kopieren von CDs und das Tauschen von Musikdateien im
+ Internet verantwortlich. Um den Kids klar zu machen, dass das Kopieren
+ von Musik letzendlich die Kuenstler schaedigt, startet die Industrie
+ die Kampagne "Copying Music is Killing Music".
+
+ 2003: Die Musikindustrie zeichnet Herbert Groenemeyer, Nena, Kim
+ Wilde, Ozzy Osbourne und Metallica als beste Kuenstler aus. Das Album
+ Nr. 1 ist Nena mit Remixen ihrer groessten Hits. In den Hitparaden
+ finden sich neben Alexander, Juliette und Daniel K. auch Jeanette
+ Biedermann mit "Rock my Life", das stark nach Roxette klingt.
+ Weiterhin gehoeren Lichtenfels mit "Sounds like a Melody", Outlandish
+ mit "Aicha", Kraftwerk mit "Tour de France 2003", KCPK mit "We will
+ Rock You" und Murphy Brown mit "Axel F 2003" und Culture Beat mit
+ "Mr. Vain Recall" zu den Tophits.
+
+ Die meisten CDs haben Kopierschutz. Seit August ist das Kopieren
+ kopiergeschuetzter CDs verboten, ebenso das Herunterladen von Musik
+ aus dem Internet. Der Umsatz der Musikindustrie geht um weitere 15%
+ zurueck, besonders betroffen Hit-Kompilationen mit 47%.
+
+ 2004: Die Musikindustrie zeichnet Herbert Groenemeyer, Marius
+ Mueller-Westernhagen, DJ Bobo, Marianne Faithfull und Pur aus. In den
+ Charts stehen das Hollywood Dance Project mit "Relax Reloaded",
+ Kajagoogoo mit "Too Shy 2004", Nena mit "Haus der 2004 Sonnen" und
+ Nico W aus "GZSZ" mit "Ich vermiss Dich wie die Hoelle" lange Zeit ganz
+ oben.
+
+ Mit Hilfe einer automatisierten Sauger-Suche kann die Musikindustrie
+ alle Nutzer von Tauschboersen ausfindig machen. Fuenf Millionen
+ Haushalte in Deutschland erhalten daraufhin Post des Muenchner Anwalts
+ G., der ultimativ die Unterzeichnung einer Unterlassungserklaerung
+ einfordert und die Erstattung von Auslagen ueber 583,74 Euro.
+
+ Die Tauschboersen brechen zusammen. Die Haelfte aller T-DSL-Anschluesse
+ wird gekuendigt. Der Umsatz der Musikindustrie geht um weitere 10%
+ zurueck.
+
+ 2005: Es werden Herbert Groenemeyer, Tom Jones, die Supremes, Suzi
+ Quatro und Elvis Presley als Kuenstler des Jahres ausgezeichnet, dazu
+ Status Quo mit dem Innovationspreis des Musiker-Managements. Die
+ Charts fuehren an Peter Maffay mit "So bist Du 2005", Roberto Blanco
+ mit "Ein bisschen Spass muss wieder mal sein" und Zarah Leander mit "Ich
+ weiss, auch 2005 wird ein Wunder gescheh\'n."
+
+ Der Umsatz der Musikindustrie schrumpft erneut um 50%.
+
+ Die Trend-Scouts entdecken, dass unter den Jugendlichen 60er- 70er-
+ 80er und 90er- Revivals in sind. Sie treffen sich zu FlowerPower-,
+ Disco-, New Wave- und Rave-Parties und hoeren die CDs ihrer Eltern.
+ Original-CDs und LPs der vergangenen vier Jahrzehnte werden verstaerkt
+ bei Ebay gehandelt. Es wird vermutet, dass die Kids die CD erwerben,
+ kopieren und dann weiterverkaufen. Das ist legal, da die alten CDs
+ keinen Kopierschutz haben und nur Originale angeboten werden.
+
+ 2006: Die Musikindustrie bringt ein neues Tontraegerformat heraus: Die
+ "Smart CD". Sie benoetigt spezielle Abspielgeraete mit
+ Internet-Anschluss. Die Smart-CDs lassen sich nur abspielen, nachdem
+ vorher eine Lizenz ueber das Internet gekauft wurde. Lizenzen gibt es
+ nur noch temporaer, es ist nicht mehr moeglich, ein Musikstueck "fuer
+ immer " zu erwerben. Dafuer werden die "Smart-CD"-Spieler im Bundle
+ mit einem Musik-Abo fuer einen Euro angeboten.
+
+ Als erfolgreichste Kuenstler werden Herbert Groenemeyer, die Scorpions,
+ Mark Oh, Oli P. und Peter Kraus ausgezeichnet. Die Charts werden
+ beherrscht durch Songs wie "Flugzeuge im Bauch Ultimate Edition" mit
+ Herbert Groenemeyer, Oli P. und Xavier Naidoo, "You Keep Me Hanging
+ On" mit den Supremes, Kim Wilde und Sinema sowie "Anyplace, anywhere,
+ whatever" von Nena, Kim Wilde und Jan Delay.
+
+ Aus Anlass der Fussball-WM wird mit grossem Marketing-Aufwand eine neue
+ Latino-Salsa-Welle propagiert, mit Carlos Santana und Richie Valens
+ ("La Bamba World Cup 2006 Mousse T. Remix") als Galionsfiguren.
+ Obwohl Brasilien zum sechsten Mal Weltmeister wird, hat die Welle nur
+ maessigen Erfolg.
+
+ Der Absatz der Musikindustrie sinkt weiter.
+
+ 2007: Mit Hinweis auf die vielen bedrohten Arbeitsplaetze setzt die
+ Musik-Lobby ein Gesetz durch, nachdem der Rueckruf einmal erteilter
+ Lizenzen moeglich ist. Prompt widerruft die Industrie alle bisher
+ erteilten Lizenzen auf nicht kopiergeschuetzte Tontraeger. Damit werden
+ alle aelteren CDs und alle LPs illegal, ebenso Plattenspieler und
+ CD-Spieler, die nicht dem "Smart CD" Standard entsprechen. Im
+ Austausch fuer ihre Original-CDs bietet die Industrie CD-Besitzern
+ eine Einjahreslizenz fuer die auf der CD vorhandene Musik an.
+
+ Nach einer erneuten Abmahnwelle der Kanzlei G. aus M. bricht der
+ Tontraegerhandel ueber eBay zusammen.
+
+ Auf die Veroeffentlichung von Charts und die Auszeichnung von
+ Kuenstlern wird verzichtet. Zunaechst einmal muessen die Lagerbestaende
+ an CDs abverkauft werden.
+
+ 2008: Musik wird in Deutschland nur noch im Radio oder bei Konzerten
+ gehoert. Das Radio verliert aber an Popularitaet, seit die Industrie
+ die Sender zwingt, nur noch neueste Produktionen zu spielen und ueber
+ diese drueberzusprechen, damit das Aufnehmen mit Tapedecks verhindert
+ wird. Konzerte sind fast unbezahlbar geworden, da das gesamte
+ Management von den Eintrittspreisen mitbezahlt werden muss.
+
+ Dagegen haeufen sich die sogenannten "Open Jams", spontane
+ Zusammenschluesse von Hobby-Musikern, die auf oeffentlichen Plaetzen mit
+ Gitarre, kleinem Schagzeug, Keyboard, Saxophon etc. Musik spielen und
+ von begeisterten Zuhoerern gefeiert werden.
+ 2009: Die Musiklobby setzt beim Gesetzgeber das Verbot oeffentlicher
+ und privater Performance urheberrechtlich geschuetzen Materials durch.
+ Musikinstrumente werden mit einer Urheber-Abgabe belegt, da man ja
+ eine Gitarre etwa zum Raub-Abspielen von Stones-Songs missbrauchen
+ kann. "Making music is killing music" lautet die begleitende
+ Kampagne, die den Leuten Unrechtsbewusstsein beibringen soll.
+
+ 2010: Um Arbeitsplaetze bei Musikern zu schuetzen, wird Musikunterricht
+ rationiert: Es duerfen nur noch so viele Nachwuchsmusiker ausgebildet
+ werden, wie der Markt braucht. Da dieser schneller schrumpft als die
+ Musiker wegsterben, bedeutet das faktisch ein Verbot des
+ Musikunterrichts. Hunderte Musikschulen werden geschlossen.
+
+ 2011: Sarah Connor versucht mit "Terminate Me" einen neuen, nicht
+ gecoverten Song herauszubringen, wird aber dafuer von den Anwaelten der
+ Musikrechteinhaber verklagt, die es nicht erlauben, dass neue Urheber
+ am kleiner werdenden Kuchen mitverdienen wollen. "Composing music is
+ killing music" heisst das Schlagwort der Inhaber alter Rechte. Sarah
+ Connor gewinnt den Rechtsstreit, wird aber kurz darauf unter
+ mysterioesen Umstaenden ermordet aufgefunden. Von nun an traut sich
+ niemand mehr, neue Songs zu schreiben.
+
+ 2012: Die Eltern des 6-jaehrigen Wolfgang Amadeus Moherb, des
+ "Jugend-musiziert"-Siegers, werden zu 150.000 Euro Schadenersatz an
+ die Musikindustrie verurteilt, weil sich herausgestellt hat, dass ihr
+ Kind erst seit eineinhalb Jahren musiziert, also nach dem
+ Inkrafttreten der Unterrichts-Rationierung. Seine Lehrerin, die
+ Violinistin Anne-Sophie Mutter, entzieht sich einer Gefaengnisstrafe
+ durch Flucht in den Irak, dem einzigen Land, das nicht unter
+ Kontrolle der westlichen Wertegemeinschaft und damit der
+ Musikindustrie ist.
+
+ 2020: Nahezu jede tonliche Aeusserung, darunter Motorgeraeusche,
+ Trittschall, Tuerschliessgeraeusche und gesprochenes Wort, sind unter
+ urheberrechtlichen Schutz gefallen. Eine Tuer zumachen darf quasi nur
+ noch, wer nachweisen kann, dass der dabei erzeugte Schall nicht dem
+ von Porsche patentierten aehnelt. Die einzigen lizenzfreien Worte sind
+ "der", "die", "das", "und" und "hallo". Die Gespraeche von
+ Menschen,
+ die sich das "Deutsche Sprache Abo" nicht leisten koennen, sind daher
+ fast unverstaendlich geworden. Ueberhaupt ist es sehr still geworden,
+ da fast jede Schallerzeugung das Risiko einer Abmahnung durch den
+ Muenchner Justizkonzern G. und Soehne mit sich birgt.
+
+ Die Anwaelte der Ton und Schall Industrie-Gemeinschaft machen Jagd auf
+ Park- und Waldbesitzer, die in ihren Anwesen das illegale Singen von
+ Voegeln dulden.
+
+ 2050: Europa und die USA sind in einem Handstreich vom Irak
+ eingenommen worden. Die Iraker brauchten nur einen einzigen Muezzin,
+ um die halbe Streitmacht der Westmaechte auszuschalten, die sich, an
+ Schall nicht mehr gewoehnt, mit zugehaltenen Ohren am Boden waelzte.
+ Die andere Haelfte und die zivile Bevoelkerung wurden dadurch gewonnen,
+ dass man ihnen Kinderlieder vorsang. Die Menschen fingen an zu weinen
+ und den Invasoren auf Knien zu danken, fuer diese neue und wunderbare
+ Gabe, die sie so lange vermisst hatten. Seither ist der Islam die
+ groesste Weltreligion und das Reich Allahs unter der weisen Herrschaft
+ des Kalifen von Washington schwingt sich auf zu neuer Bluete.
+
+ -- 
+ Submissionen fuer de.alt.netdigest bitte an
+ <de-alt-netdigest@moderators.dana.de> schicken.
+ Der Submitter ist fuer den Inhalt der Einreichung verantwortlich, 
+ nicht der Moderator der Newsgruppe.
+
+
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Die Zukunft der Musikindustrie (Cadrach, 29. Aug 2003, 10:57:37):
+~#! rn=Foobar rt=1061843246 rg=schmarrn.netdigest
+~#! tid=1061843246
+Solche Artikel sind eigentlich nur dann witzig, wenn Behauptungen entweder
+schluessig oder doch zumindest abstruss erklaert sind. Wieso ein Verbot von
+Tauschboersen, die Umsaetze der Musikindustrie sinken laesst ist mir ehrlich
+gesagt noch unklar (wobei ich auch ein starkes ansteigen fuer unwahrscheinlich
+halte).
+
+Cad*
+
+-----------------------------------------------------------------------------
+
+
+
+Kryptologen... (Ronda, 29. Aug 2003, 12:39:49):
+... lach ich jetzt - oder wein ich besser?
+
+Newsgroups: de.alt.sysadmin.recovery
+Subject: Passworte von Kryptologen
+From: Thomas Holenstein <Aug-2003.th@hex.ch>
+Date: 27 Aug 2003 16:40:31 +0200
+Message-ID: <8lz7k4z9na8.fsf@hex.ch>
+
+Hallo,
+
+TCC (Theory of Cryptography Conference) ist eine neue Konferenz im
+Bereich der Kryptographie.  Um ein Paper zu submitten kann man auf
+http://external.nj.nec.com/homepages/joe/tcc/ auch ein Passwort waehlen.
+
+Ich zitiere:
+
+ | However, if you leave it blank, you will allow anyone in the world to
+ | easily mess up your submission. Ideally then, you should pick a
+ | password that you and your coauthors can remember, but which cannot be
+ | guessed by anyone else; we recommend spelling your last name
+ | backwards.
+
+Tja...
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Kryptologen... (Foobar, 29. Aug 2003, 13:09:48):
+~#! rn=Ronda rt=1062153589 rg=schmarrn.netdigest
+~#! tid=1062153589
+Lachen, denn es handelt sich hier wohl um einen Gag unter 'Kryptologen'.
+
+Verfolgt man den Thread in der NG weiter liest man irgendwo, dass man sich
+nicht anmelden kann wenn man das Passwort wie beschrieben waehlt.
+
+Foobar
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Kryptologen... (Ronda, 29. Aug 2003, 13:12:41):
+~#! rn=Foobar rt=1062155388 rg=schmarrn.netdigest
+~#! tid=1062153589
+Mist. Und ich wollte grad ausprobieren, ob ich nen paar Accounts da knacken
+kann ;-)
+
+Ronda
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Kryptologen... (Vanion, 29. Aug 2003, 13:32:23):
+~#! rn=Ronda rt=1062153589 rg=schmarrn.netdigest
+~#! tid=1062153589
+Sind halt Theoretiker.
+
+Um einen Bekannten (Mathematiker) zu aergern, bat ich ihn mal, schnell einen
+Einkaufzettel anzusehen. Seine Reaktion war entsetzt: Da sind ja Zahlen drin!
+
+V*
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Kryptologen... (Zook, 29. Aug 2003, 13:44:12):
+~#! rn=Vanion rt=1062156743 rg=schmarrn.netdigest
+~#! tid=1062153589
+:hat selten Zahlen aufm Einkaufszettel.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Kryptologen... (Ronda, 29. Aug 2003, 13:45:36):
+~#! rn=Zook rt=1062157452 rg=schmarrn.netdigest
+~#! tid=1062153589
+Hmm... ich hab da grad nen "Einkaufszettel" gesehen, bei dem die Zahlen doch
+wichtig waren... aus dem Kopf:
+
+1.930 Kilo Kartoffeln
+4144 Rollen Toilettenpapier
+25 Kilo Knoblauch
+...
+
+Ronda
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: Kryptologen... (Grimmborn, 29. Aug 2003, 13:46:38):
+~#! rn=Ronda rt=1062157536 rg=schmarrn.netdigest
+~#! tid=1062153589
+Kann man daraus schliessen dass zur Verdauung von einem Kilo Kartoffeln ueber
+den Daumen zwei Toilettenpapierrollen noetig sind?
+
+GdA
+
+-----------------------------------------------------------------------------
+
+
+
+Kurz und nett. (Ronda, 29. Aug 2003, 14:07:23):
+[Submitter's Note: Artikel auf das wesentliche gekuerzt]
+
+From: Andreas Dau <dev.nul@andreasdau.de>
+Newsgroups: de.alt.sysadmin.recovery
+Subject: Re: Stats
+Date: Tue, 19 Aug 2003 16:47:40 +0200
+Message-ID: <1j5gxi9zf3dt3$.dlg@andreasdau.de>
+
+Felix von Leitner frankberkelte:
+> Wo migriert man denn von der c't aus hin?
+
+Wenn man's richtig gemacht hat zur "Yacht" ;-)
+
+cu,
+ada
+
+-----------------------------------------------------------------------------
+
+
+
+Die alten Griechen und die IT... (Ronda, 30. Aug 2003, 01:28:21):
+Message-ID: <v74mhb.3jh.ln@192.168.111.16>
+From: Ruprecht Wiskott <wiskott@gmx.de>
+Newsgroups: de.comp.security.firewall
+Subject: [OT]:Homer und IT, was:Trojaner
+Date: Sat, 16 Aug 2003 22:30:15 +0200
+
+
+Hallo erstmal, Erhard Schwenk schrieb:
+
+> Homer handelt also von IT-Sicherheit bzw. ist in diesem Kontext
+> relevant. Interessante These. Belege?
+
+IT=Informationstechnologie. Zu Homers Zeiten waren Gesaenge in Hexametern der
+"Stand der Technik" in der IT. Schlecht war das nicht, denn es hat die
+Zeiten ueberdauert und kann heute noch gelesen werden.
+Ob das, was heute als Stand der Technik in der IT angesehen wird, in 2000
+Jahren noch vorhanden und lesbar sein wird, wird sich weisen. Persoenlich
+habe ich da aber so meine Zweifel...
+
+Inwiefern sich die Ilias sich mit Sicherheitsfragen befasst, ist sicher
+Ansichtssache.
+Meiner Ansicht nach kann das nunmehr ueber 2000 Jahre alte Heldenepos aber
+auch fuer die heutige Zeit einige grundlegende Erkenntnisse vermitteln, die
+bei der Aufstellung eines tauglichen Sicherheitskonzeptes hilfreich sind.
+
+Zum einen zeigt der Beginn der Geschichte, was einem passiert, wenn man kein
+taugliches Sicherheitskonzept hat: Agamemnon wird die nur unzureichend
+geschuetzte Frau geklaut, was neben dem materiellen Schaden zu unmittelbarem
+Gesichtsverlust fuehrt. Es lohnt sich also, ueber Sicherheit nachzudenken,
+bevor ein Schaden eingetreten ist. Die Rueckeroberung der Frau war aeusserst
+aufwendig und zog sich ueber viele Jahre hin. Haette er eine ordentliche
+Firewall gehabt, waere ihm das nicht passiert.
+
+Im weiteren erfaehrt man, dass eine ordentlich gemachte Firewall durchaus
+einer 10 Jahre waehrenden Belagerung standhaelt. Damit kann die Mauer um
+Troja noch heute mancher Firewall als leuchtendes Vorbild dienen. Und das
+hier immer wieder zitierte Exempel, dass die List des Odysseus staerker war
+als das hervorragende und hervorragend verteidigte Bollwerk rund um Troja,
+sollte einem gebildeten Admin immer wieder wie ein Menetekel vor Augen
+fuehren, dass er sich nie zuruecklehnen kann, sondern dass er immer mit dem
+Listenreichen auf der anderen Seite rechnen muss.
+
+Die ebenfalls daraus zu entnehmende wesentliche Erkenntnis, dass ein Geschenk
+nicht immer etwas Gutes ist, hatte auch spaeter der Schoepfer des Satzes
+"Timeo Danaos et dona ferentes."
+(Ich fuerchte die Danaer, auch wenn sie Geschenke bringen.)
+Wenn ich dies den Usern einpraege, dass nicht jedes Versprechen z.B. eines
+superlangen Doedels eine Heilsbotschaft ist, habe ich schon ein wesentliches
+Stueck Sicherheit gewonnen und einen Teil meines Sicherheitskonzeptes
+umgesetzt.
+
+So kann uns auch die weit zurueckliegende Gechichte Dinge lehren, die damals
+wie heute offensichtlich nicht selbstverstaendlich und nur schwer zu
+vermitteln waren und sind.
+
+Genuegt dies, um die Ilias (und andere Werke der Antike), zumindest in der
+Essenz als ontopic in d.c.s.f. zu bewerten? ;-)
+
+Gruss
+Ruprecht
+
+-----------------------------------------------------------------------------
+
+
+
+Nach einem... (Ronda,  7. Sep 2003, 18:41:57):
+... Sonntag auf Deutschen Autobahnen kommt einem das irgendwie wie eine sehr
+gute Idee vor.
+
+Ronda
+
+From: Juergen Gerkens <gerkens-usenet@gmx.de>
+Subject: Re: Mit Panzer fahren
+Newsgroups: de.soc.recht.strassenverkehr
+Date:Mon, 1 Sep 2003 18:43:01 +0200
+Message-ID: <bivte2$h25$1@online.de>
+
+Ren 'vollmi' Vollmeier haute in die Tasten:
+
+>> Der Panzer faellt zwar unter das Kriegswaffen-Kontrollgesetz, nicht
+>> aber unter das Waffengesetz ( 57 WaffG).
+>
+> Cool, dann darf man den ja im Gegensatz zu einer Schreckschusspistole
+> an Demonstrationen mitnehmen ;-)
+
+Je mehr man drueber nachdenkt, desto mehr gefaellt einem die Sache:
+
+Kein Scheibenwischer, hinter den jemand Knoellchen klemmen kann.
+
+Nie mehr in der Innenstadt abgeschleppt werden.
+
+Hat da jemand seine Autotuer gegen das eigene heilig Blechle gedonnert?
+
+Oder war's ein Edeka Einkaufswagen?
+
+Oder gar der Ford Transit von Ali Uebel auf dem Aldi Parkplatz?
+
+Jawohl, man kann geradezu freudestrahlend drauf warten, dass
+jemand  beim Einparken gegen das eigene Fahrzeug scheppert.
+
+Totale Entspannung am Stauende: "Ist da eben ein LKW am Heck
+zerschellt oder war das Geraeusch im Radio?
+
+Der TUeV wird in den naechsten 50 Jahren nicht das
+Bodenblech durchschlagen.
+
+Man braucht keine Tankstelle mehr, wenn man im Mc Drive
+das alte Frittierfett sammeln laesst.
+
+Kein Fahrerfoto in der Radarfalle.
+
+Niemand petzt, wenn man das Handy ans Ohr haelt.
+
+50 km/h - Verkehrsberuhigung? Guter Witz!
+
+Nie mehr Schrammen in der Waschanlage bekommen!
+
+Immer gute Sicht im Autokino.
+
+Hat da jemand den Vorrang in Engstellen missachtet? Na und!
+
+Wer vor einem in der Tempo 30 Zone rechts vor links vergisst,
+der bekommt das eben "erklaert".
+
+Wer sich in der Autobahnabfahrt auf dem letzten Meter
+noch in die Spur draengelt, faehrt nie wieder Kamikaze.
+
+Wer vor einem den gruenen Pfeil nicht verstanden hat,
+macht den Fehler nie wieder.
+
+<Kratsch> "Schatz, hast Du auch keinen Blinker am niederlaendische LKW
+gesehen?"
+
+Wer das mit dem Kreisverkehr noch nicht richtig kennt, jetzt oder nie!
+
+Und wer hinter einem in zwei Meter Abstand aufblendet,
+kauft auch nie wieder bei D&W. ;-)
+
+Schoene Gruesse
+Juergen Gerkens
+
+-----------------------------------------------------------------------------
+
+
+
+Nicht Netdigest, aber lustig :) (Vanion,  8. Sep 2003, 07:42:44):
+Die Reaktion find ich net:
+
+V*
+--
+
+"Dorje" <dorjephagmo@ustc.edu> schrieb im Newsbeitrag
+news:8b4e64d3.0309050021.63ef8174@posting.google.com...
+
+> Realitet ist, wenn in China ein Sack Reis umfaellt,
+> dann kann es in der Schwyz zum Wolkenbruch kommen.
+
+
+ganz recht, so ist es. Die Lsung liegt allerdings nicht im
+festhalten und bewachen aller Reissaecke in China. Mge
+dir das wohl irgendwann einleuchten lieber Dorje ;)
+
+mfG R.Braun
+
+-----------------------------------------------------------------------------
+
+
+
+Heise-Forum (Nonne,  8. Sep 2003, 11:31:12):
+Nicht aus dem Usenet, aber trotzdem lustig (oder doch nicht?):
+
+Selbst erlebt, bei einem Nachtflug von San Francisco nach Newark, als
+ wir vor dem Start mehr als eine Stunde angeschnallt im Flieger sassen,
+ ohne dass etwas voranging:
+ 
+ "Ladies & Gentlemen, wir entschuldigen uns fuer die Verzoegerung und
+ bitten um Ihr Verstaendnis, dass uns Ihre Sicherheit wichtiger als
+ Schnelligkeit ist. Beim Start-Up-Check wurde ein ungeklaertes
+ Nebengeraeusch aus einem der Triebwerke festgestellt. Da die Ursache
+ bis jetzt nicht festgemacht werden konnte und Ihr Captain unter
+ diesen Umstaenden nicht starten wollte, haben wir eine Ersatz-Crew
+ aktiviert, deren Captain dieses Geraeusch nicht stoert. Wir wuenschen
+ einen angenehmen Flug .. jadajadajada".
+ 
+ Das sag nochmal einer, die Amis haetten keinen Humor ...
+ 
+
+Nonne, weisst nicht, ob er das glauben soll.
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Heise-Forum (Marcus,  8. Sep 2003, 11:36:53):
+~#! rn=Nonne rt=1063013472 rg=schmarrn.netdigest
+~#! tid=1063013472
+Das war sichzerlich South West Airlines, die haben immer so einen Humor ;9
+
+Ciao, Marcus
+
+-----------------------------------------------------------------------------
+
+
+
+Apotheker (Foobar,  9. Sep 2003, 20:54:55):
+ From: Andreas Kabel <akabel@penguin.slac.stanford.edu>
+ Newsgroups: de.etc.sprache.deutsch
+ Subject: Re: OT: Schriftbild verbessern
+ Date: Tue, 02 Sep 2003 11:48:20 -0700
+ Message-ID: <86y8x7gh6z.fsf@penguin.slac.stanford.edu>
+
+ yst@swissonline.ch (Yvonne Steiner) writes:
+
+ > Helge Volland <helgev@idf.de> wrote:
+ >
+ >> Oder werd Arzt. Deren Klaue kann eh keiner lesen :-)
+ >
+ > Doch: Der Apotheker.
+
+ In einer Zeitungsredaktion hatte der Chefredakteur vor seiner Abreise
+ einen Zettel mit aeusserste Dringlichkeit signalisierenden, jedoch
+ voellig unleserlichen Schriftzuegen hinterlassen. Es waren nur noch
+ wenige Minuten bis zur Drucklegung, und in der Verzweiflung und im
+ Vertrauen auf die Lesekuenste der Apotheker wurde ein Lehrling mit
+ Fahrrad und Zettel zur Apotheke geschickt. Kurz darauf kam er zurueck,
+ trat stumm unter die Redakteure und stellte eine Arzneiflasche mit
+ einer braeunlichen Fluessigkeit auf den Tisch. Niemand sprach ein
+ Wort.
+
+-----------------------------------------------------------------------------
+
+
+
+Brute force Ansatz. Nun weiss ich endlich, was das ist. (Ronda, 12. Sep 2003, 02:20:28):
+From: Dietz Proepper <dietz-news@rotfl.franken.de>
+Newsgroups: de.alt.sysadmin.recovery
+Subject: Re: EC-Karte (was: Passwortaenderung...)
+Date: Mon, 08 Sep 2003 21:42:22 +0200
+Message-ID: <u2mijb.66b.ln@rotfl.franken.de>
+
+Lutz Donnerhacke wrote:
+
+> * Florian Kirstein wrote:
+>> Das ist alles oeffentlich: Das Verfahren litt an mindestens 2 Schwaechen:
+>> - DES: Alles crypto war normales DES, seit Mitte der 90er also technisch
+>> bruteforcebar, fuer "grosse" Organisationen u.U. schon eher. Die PIN
+>> liess sich per DES aus den Daten der Karte berechnen - gespeichert war
+>> sie nirgends.
+> 
+> Einfacher: Es fehlen einige hundert Geldautomaten, die komplett aus der
+> Wand gerissen wurden und nie wieder gefunden wurden.
+
+Was mal wieder beweist - bruteforce funktioniert. Man muss nur den richtigen
+Teil des Systems bruteforcen.
+
+Dietz
+
+-----------------------------------------------------------------------------
+
+
+
+[de.etc.fahrzeug.auto] Re: Fusionsreaktor im Auto (Ronda, 12. Sep 2003, 02:22:27):
+[Anmerkung des Einreichers: Auch die Signatur passt.]
+
+From: Ansgar Kursawe <A.Kursawe@nurfuerspam.de>
+Newsgroups: de.etc.fahrzeug.auto
+Subject: Re: Fusionsreaktor im Auto
+Message-ID: <i7ihlvk5pk551fbo1g944k0b4f6vpq1blv@4ax.com>
+
+Am 5 Sep 2003 09:03:01 -0700, Toni Rellser postete:
+
+>Ich habe mein Auto mit einem Kernfusionsreaktor ausgestattet.Jetzt
+>brauche ich kein Benzin mehr.
+
+[Es ist doch gar nicht April?]
+
+>Darf ich mit so einem Fahrzeug auf deutschen Strassen fahren ?
+
+Solange die Umbauten vom TUeV abgenommen sind, ein TUeV/Dekra-Gutachten
+zur Erteilung einer neuen Betreibserlaubnis vorliegt und diese auch
+beim Strassenverkehrsamt in die Papiere eingetragen ist - ja. 
+
+Dummerweise darfst du das Auto jedoch nicht fahren, da dieses mit
+Kernbrennstoffen betrieben wird. Jeder Transport dieser Brennstoffe
+ist bloederweise nach 4 Atomgesetz anmeldepflichtig, das schraenkt
+deine Flexibilitaet etwas ein. Also musst du bereits die Fahrt zum TUeV
+anmelden. Dazu solltest du ein polizeiliches Fuehrungzeugnis vorlegen
+koennen (4.2 Satz 1 Atomgesetz) und Sachkenntnis nachweisen. Ein
+Doktortitel der Physik ist hier amtlich nicht ausreichend,
+genausowenig wie ein Doktortitel der Chemie etwas ueber amtliche
+Sachkunde zu Gefahrstoffen aussagt. Nach 4.2 Satz 4 ist uebrigens auch
+eine etwas aufgestockte Haftpflichtversicherung noetig. Den Rest des
+Atomgesetzes kannst du selbst durchkauen.
+
+Beachte auch die Kostennoten des 21 Atomgesetz, auch fuer die
+Erteilung einer Transportgenehmigung nach dem oben genannten 4 fallen
+gebuehren an. Ich fuerchte, da ist eine voll aufgetunete Corvette mit
+SHELL 100 und Bleifuss kostenguenstiger zu betreiben.
+
+Ausserdem hast du sicher gegen Importbestimmungen der BRD verstossen.
+Da Kernfusion ziemlich sicher isotopenreines Lithium braucht, ist die
+Einfuhr von einer Isotopentrennnungsanlage anmeldepflichtig, siehe
+http://www.ma-tax.de/A_H_P/listen/listen/20030722%20Ausfuhrliste.pdf
+
+
+Chips und Popcorn holend, 
+
+Ansgar
+
+-- 
+The two most common things in universe are hydrogen and bureaucracy.
+
+-----------------------------------------------------------------------------
+
+
+
+Re: [de.etc.fahrzeug.auto] Re: Fusionsreaktor im Auto (Gloinson, 12. Sep 2003, 13:07:15):
+~#! rn=Ronda rt=1063326147 rg=schmarrn.netdigest
+~#! tid=1063326147
+Wroueber koennen wir jetzt schmunzeln? Ueber das Auto oder ueber das begrenzte
+Blickfeld Ansgars hinsaechlich Fusion iA?
+
+
+-----------------------------------------------------------------------------
+
+
+
+Hm. Irgendwie erinnert mich... (Ronda, 13. Sep 2003, 01:12:16):
+... das an meinen letzten Url... aehm... Arbeitseinsatz in Norwegen und so...
+
+Ronda
+
+From: Christoph 'Mehdorn' Weber <ich-rebew@nexgo.de>
+Newsgroups: de.alt.sysadmin.recovery
+Subject: Re: VHS-Recovery...
+Date: Thu, 11 Sep 2003 21:23:12 +0200
+Message-ID: <slrnbm1it0.2dp.ich-rebew@www.daridos.de.vu>
+
+Hallo!
+
+Bernd Petrovitsch <bernd@bofh.at>:
+> On Thu, 21 Aug 2003 07:58:35 +0000, Juergen Nieveler wrote:
+
+>> Workshop: Wo speichere ich meine Dateien und wie finde ich sie wieder?
+> [ Explorer fuer Anfaenger Kursbeschreibung ]
+> 
+> Das beste:
+> 9:00 - 16:00 Uhr
+> 
+> Ich packs nicht.
+
+  Doch, das muss so sein. Droeseln wir das etwas auf:
+
+ 9:00 Uhr  Leute nehmen am Rechner Platz
+ 9:15 Uhr  $Kurstussi erklaert, wie man Rechner einschaltet
+ 9:30 Uhr  Die Rechner haben fertig gebootet
+ 9:45 Uhr  Die ersten Dateien werden auf dem Rechner versteckt
+10:00 Uhr  $Kurstussi erklaert, wo man $spezielle_datei mit
+           $besonderem_dateinamen ablegen soll
+10:30 Uhr  Auch das ist erledigt, Kaffeepause
+10:45 Uhr  Die Rechner werden - mehr oder weniger ordentlich - wieder
+           abgeschaltet
+11:00 Uhr  Man spricht ueber Probleme, daheim Dateien wiederzufinden. So
+           selbsthilfegruppen-maessig[0]
+11:50 Uhr  Aufbruch zum Mittagessen
+12:45 Uhr  Mittagessen abgeschlossen, Verdauungsspaziergang durch
+           nahegelegenen Park
+14:00 Uhr  Nochmal Selbsthilfegruppe
+14:45 Uhr  Rechner wieder anschalten
+15:00 Uhr  Die User haben in der Zeit zielsicher vergessen, wo die
+   Dateien abgelegt waren, welchen Namen sie hatten und welchen
+           sinnfreien Inhalt
+15:15 Uhr  Nach sinnloser Sucherei schlaegt $Kurstussi vor, mal alle
+   Dateien zu suchen, die sich am heutigen Tag geaendert haben
+15:30 Uhr  Erste User haben ihre Dateien wiedergefunden
+15:45 Uhr  Unter gegenseitiger Hilfe haben jetzt alle ihre Dateien
+           wiedergefunden
+15:50 Uhr  $Kurstussi erzaehlt, dass die Leute $spezielle_datei mit
+           $besonderem_dateinamen oeffnen sollen, den sie zielsicher
+           diktiert
+15:55 Uhr  Alle User haben diese Datei wiedergefunden und stellen fest,
+   dass das schneller ging und sind voellig davon ueberzeugt, dass
+   jetzt alle Dateien unter $besonderem_dateinamen$+
+   laufende_nummer gespeichert werden muessen, da man sie so
+           leichter findet
+16:00 Uhr  $Kurstussi verabschiedet die Leute, muss die Rechner selbst
+   abschalten und notiert, den naechsten Spaziergang um eine
+           Viertelstunde zu kuerzen.
+
+Christoph
+
+[0] Etwa so:
+$K: So, her $Maier, erzaehlen sie uns doch mal, was ihnen schon Schlimmes
+    am Rechner wiederfahren ist, weil sie eine Datei nicht gefunden
+    haben.
+$M: Ja, also... <peinlichumguck>
+    Eines Tages kam ich nach Hause und habe meinen Rechner
+    eingeschaltet, und da hat er gesagt, dass er die Datei vmm32.vxd
+    nicht mehr finden kann. Und da habe ich $Bekannten angerufen, und
+    der hat die dann wieder gefunden. Deshalb musste ich ihn dann mal
+    eine Woche spaeter zum Essen einladen. War eigentlich ganz nett, aber
+    da er erst gegen Abend Zeit hatte, konnte ich an dem Tag meinen
+    Brief nicht mehr schreiben.
+$K: Na, das ist ja gerade noch mal glimplich ausgegangen. Da sehen sie
+    mal, was passiert, wenn man eine wichtige Datei verlegt.
+    <Pause, zum Einwirkenlassen>
+    Herr $Grause, was ist ihnen denn schon passiert?
+$G: Neulich, als ich nach Hause kam, hat mir mein Sohn, 14 Jahre,
+    dunkelhaarig, ledig, erzaehlt, dass er $spiel installieren wollte und
+    zu wenig Platz auf der Festplatte war, und er deshalb ein wenig
+    Platz gemacht haette. Als ich dann am Tag drauf, als meine Frau und
+    die Kinder gerade weg waren, meine sensiblen Bilddokumente ansehen
+    wollte, stellte ich fest, dass sie weg waren. Dabei hatte ich sie
+    extra in C:\TEMP gespeichert. In der $computerbloed stand naemlich,
+    dass dort eh kein Aas reinschaut und daher dort sensible Daten prima
+    vor den Blicken anderer versteckt werden koennen...
+$C: Hatten sie wenigstens ein Backup gemacht?
+$G: Backup, was ist das...
+$K: Herr $Cluesomeuser, lassen sie gefaelligst $G ausreden! Das ist ja
+    eine Unverschaemtheit.
+$G: Aeh... also, das Verzeichnis war dann zumindest lee...
+$K: Das heisst Ordner, verdammt noch mal!
+$G: Ja, jedenfalls war der Ordner leer. Und als ich meinen Sohn dann
+    spaeter mal gefragt habe, wo die Dateien sind, hat er gesagt, dort
+    wuerden eh nur Sachen kurzzeitig gespeichert und er haette einfach mal
+    die 300MB an nicht benoetigten Dateien geloescht und...
+$C: Stimmt. Damit hat ihr Sohn auch recht.
+$K: Halten sie doch endlich mal die Klappe und lassen sie $G ausreden!
+$G: Na ja, und so musste ich dann stundenlang im Web herumsuchen, bis ich
+    endlich die sensiblen Bilddokumente wiedergefunden hatte. Neben der
+    hohen Telefonrechnung habe ich mir dann noch einen Dialer
+    eingefangen.
+[..]
+
+-----------------------------------------------------------------------------
+
+
+
+Das muss ich einfach posten (Vanion, 17. Sep 2003, 22:50:53):
+Grad gefunden, in de.sci.theologie (jaja, sowas lese ich - eine Quelle ewiger
+Freude :)
+
+--
+Subject: Wahrscheinlichkeit der zufaelligen Entstehung von Leben
+From: Uwe.Leutelt@t-online.de
+Date: 09/15/03 21:37
+
+Da sich hier die Atheisten laut stark schimpfend ueber meinen Beitrag -ob der
+Atheismus, der sich auf die Evolutionstheorie stuetzt, eine wissenschaftliche
+Weltanschaung ist, aeussern,  ohne sich die Muehe zu machen vorher das Buch
+"Der Evolutionschwindel" wenigstens mal ansatzweise zu lesen hier einmal der
+mathematische Aspekt der Sache:
+
+Um ein fuer die Entstehung von Leben brauchbares Proteinmolekuel zu erhalten
+muessen drei Vorausetzungen gegeben sein:
+-alle Aminosaeuren muessen vom richtigen Typ und in der richtigen Reihenfolge
+angeordnet sein
+-alle Aminosaeuren muessen linksdrehend sein
+-alle Aminosaeuren muessen durch "Peptidbindung" chemisch aneinander gebunden
+sein
+
+Harun Yahya hat sich mal die Muehe gemacht, exakt auszurechnen, wie gross die
+Wahrscheinlichkeit ist, dass sich die 500 Aminosaeuren, aus denen ein
+durchschnittliches Proteinmolekuel, in der richtigen Anzahl und Reihenfolge
+aneinandergefuegt sind, zusaetzlich der Wahrscheinlichkeit, dass all die
+enthaltenen Aminosaeuren ausschliesslich linksdrehend und durch Peptidbindung
+verbunden sind.
+
+Heraus kommt eine Wahrscheinlichkeit von 1 zu 10 hoch 950.
+
+Hier ein kurzer Auszug aus seinem Buch:
+
+"Wie ersichtlich, ist die Wahrscheinlichkeit der Bildung eines aus 500
+Aminosaeuren bestehenden Proteinmolekuels "Eins" zu einer Zahl, die durch
+Anhaengen von 950 Nullen hinter einer Eins gebildet wird, und das ist eine
+Zahl die der menschliche Verstand nicht mehr erfassen kann. Dies ist nur
+eine theoretische Moeglichkeit. Praktisch hat solch eine Wahrscheinlichkeit
+eine "Null"-Chance zur Verwirklichung. In der Mathematik wird eine
+Wahrscheinlichkeit die geringer als 1:10 hoch 50 ist, statistisch als
+Nullwahrscheinlichkeit
+der Realisierung bewertet.
+Eine Wahrscheinlichkeit von 1:10 hoch 950 ueberschreitet diese Definition um
+ein Vielfaches.
+Wobei die Unwahrscheinlichkeit einer (spontanen) Bildung eines aus
+500 Aminosaeuren bestehenden Proteinmolekuels zu solch einem Ausmass
+geht, koennen wir fortfahren die Grenzen des Verstaendnisses zu noch hoeheren
+Ebenen der Unwahrscheinlichkeit zu draengen. Das
+Haemoglobinmolekuel, das ein lebenswichtiges Protein darstellt, enthaelt 574
+Aminosaeuren, d.h. etwas mehr als das oben erwaehnte Protein. Nun vergegen-
+waertige man sich, dass eine einzige der Billionen von roten Blutzellen
+die im Koerper vorhanden sind aus 28 Millionen Haemoglobinmolekuelen
+besteht.
+Das angenommene Alter der Erde reicht nicht aus zur Bildung auch
+nur eines Proteins durch die empirische Methode, geschweige denn eines
+roten Blutkoerperchens. Selbst wenn wir annehmen, dass sich die
+Aminosaeuren ohne Zeit zu verlieren seit dem Beginn der Welt durch die
+empirische Methode zusammengesetzt und abgebaut haben um ein einziges
+Proteinmolekuel zu bilden, waere die dazu erforderliche Zeit laenger als
+das gegenwaertige Alter der Erde, um eine Wahrscheinlichkeit von 1:10 hoch
+950
+einzuholen.
+Aus all dem geht hervor, dass die Evolution gleich an der
+Anfangsstufe, naemlich der Bildung eines einzigen Proteins in einen
+bodenlosen
+Abgrund der Unwahrscheinlichkeit stuerzt.
+
+Gibt es einen empirischen Mechanismus in der Natur?
+
+Schliesslich kommen wir zu einem sehr wichtigen Gesichtspunkt in
+bezug auf die grundsaetzliche Logik von Wahrscheinlichkeitsberechnungen,
+von denen wir einige Beispiele auffuehrten. Es wurde aufgezeigt, dass die
+obig erstellten Wahrscheinlichkeitsberechnungen astronomische
+Proportionen erreichen, und dass diese praktisch ein Vorkommen unmoeglich
+machen. Dies jedoch stellt einen weitaus wichtigeren und chaotischen
+Aspekt fuer die Evolutionisten dar. Unter natuerlichen Bedingungen koennen
+die Moeglichkeiten gar nicht erst durch eine Versuchsphase abgegrenzt werden,
+denn einen empirischen Mechanismus (Ausschaltung von Fehlern
+durch wiederholte, entsprechend abgeaenderte Versuche), der Versuche
+anstellen wuerde Proteine herzustellen, gibt es in der Natur nicht.
+Die obig aufgefuehrten Berechnungen um die Wahrscheinlichkeit der
+Bildung eines aus 500 Aminosaeuren bestehenden Proteinmolekuels auszuzeigen
+sind nur gueltig fuer eine ideale "empirische Situation", die im wirklichen
+Leben nicht existiert. Das bedeutet, dass die Wahrscheinlichkeit ein
+brauchbares Protein zu erhalten nur dann 1:10 hoch 950 ist, wenn wir
+annehmen,
+dass es einen imaginaeren Mechanismus gibt, durch den eine unsichtbare
+Hand 500 Aminosaeuren aufs Geratewohl zusammenfuegt und, wenn es sich
+zeigte dass es nicht richtig war, sie wieder eine nach der anderen
+auseinander
+nimmt um sie in anderer Reihenfolge erneut zusammenzusetzen, und
+so fort. In jedem Versuch sollten die Aminosaeuren einzeln nacheinander
+entfernt und wieder in einer neuen Reihenfolge angeordnet werden; die
+Synthese sollte nach der 500-sten hinzugefuegten Aminosaeure unterbrochen
+werden, und es sollte gewiss sein, dass keine einzige zusaetzliche
+Aminosaeure beteiligt war. Der Versuch sollte dann unterbrochen werden
+um zu ueberpruefen, ob das Protein gebildet wurde oder nicht, und im Fall
+eines Fehlschlags sollte alles wieder aufgeloest werden um fuer eine andere
+Reihenfolge neu getestet zu werden. Darueber hinaus duerfte in keinem
+Versuch irgend ein nicht-zugehoeriges Material beteiligt sein. Es waere ferner
+absolut notwendig, dass die, waehrend des Versuchs gebildete Kette nicht
+unterbrochen oder zerstoert wird, bevor die 499-ste Bindung erreicht ist.
+Diese Voraussetzungen bedeuten, dass die oben erwaehnten
+Wahrscheinlichkeiten nur in einer kontrollierten Umgebung realisiert werden
+koennen, wo ein bewusster Mechanismus von Anfang bis Ende jede
+Stufe des Prozesses leitet, und wo lediglich "die Auswahl der Reihenfolge
+der Aminosaeuren" dem Zufall ueberlassen ist. Zweifellos ist das
+Vorhandensein solch einer Umgebung unter natuerlichen Bedingungen
+unmoeglich. Aus diesem Grunde ist die Bildung eines Proteins unter
+natuerlichen
+Umgebungsbedingungen logisch und technisch unmoeglich,
+unberuecksichtigt des "Wahrscheinlichkeits"-Aspekts. Es ist in der Tat
+ziemlich
+unwissenschaftlich die Wahrscheinlichkeiten eines derartigen
+Ereignisses ueberhaupt zu erwaegen.
+Einige ungelehrte Evolutionisten erfassen das nicht. Da sie annehmen
+die Bildung von Protein sei eine simple chemische Reaktion, ziehen sie
+laecherliche Schluesse wie etwa: "Aminosaeuren verbinden sich durch
+Reaktion und bilden dabei Proteine". Spontane chemische Reaktionen
+jedoch, die in unbelebten Strukturen auftreten, koennen nur einfache und
+primitive Dnderungen hervorbringen, deren Anzahl bestimmt und
+begrenzt ist. Zur Handhabung etwas komplizierterer chemischer Prozesse
+sind Laboratorien und industrielle chemische Anlagen erforderlich. Arznei
+und viele andere chemische Materialien die wir taeglich benutzen gehoeren
+zu dieser Kategorie. Proteine haben weitaus komplexere Strukturen als diese
+industriellen chemischen Produkte. Es ist daher unmoeglich, dass
+Proteine, von denen jedes einzelne ein Wunder an Design und
+Konstruktion ist, in dem jedes Bestandteil einer bestimmten Ordnung
+gemaess an seinem Platz eingepasst ist, als Ergebnis spontaner chemischer
+Reaktionen entstanden sind.
+Wenn wir alle bisher erlaeuterten Unmoeglichkeiten ignorieren, und nun
+annehmen, dass sich dennoch ein brauchbares Proteinmolekuel "durch
+Zufall" spontan entwickelt habe, so bleibt die Evolution selbst an diesem
+Punkt wieder die Antwort schuldig, denn um seine Existenz zu bewahren,
+muesste dieses Protein von der natuerlichen Umwelt in der es sich befindet
+isoliert und unter sehr speziellen Bedingungen beschuetzt werden.
+Andernfalls wuerde es entweder aufgrund der natuerlichen Umwelt-bedingungen
+zerfallen oder sich mit anderen Saeuren, Aminosaeuren oder sonstigen
+chemischen Verbindungen verbinden und damit seine Eigenschaften
+verlieren und sich in eine total andere und nutzlose Substanz verwandeln."
+
+Das gesamte Buch, das angebliche "Beweise" fuer die Evolutionstheorie aus
+allen Wissenschaftsgebieten auseinandernimmt ist kostenlos als gepackte
+PDF-Datei herunterzuladen auf:
+http://www.harunyahya.com/de/evolutionsschwindel.php
+
+An alle Evolutionisten:
+Bitte erst lesen und dann keine wuesten Beschimpfungen, sondern sachliche
+Kritik ueben, wenn ihr das koennt.
+Ich lasse mich gern darueber belehren in welchen Punkten zur
+Evolutionstheorie der Autor irrt.
+
+Gruss
+          Uwe
+--
+V*, ueberlegt grad wirklich, ob er antworten soll. Aber wohl erst nach dem
+Schenkelklopfen. :)
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Das muss ich einfach posten (Amaryllis, 17. Sep 2003, 22:55:04):
+~#! rn=Vanion rt=1063831853 rg=schmarrn.netdigest
+~#! tid=1063831853
+Da ich unten ein "13%" erblicke (was unter meinem 20%-Filter liegt :-), werde
+ich das Ganze wohl erst lesen, wenns definitiv in de.alt.netdigest gelandet
+ist :-)
+
+Ama*
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Das muss ich einfach posten (Vanion, 17. Sep 2003, 22:57:40):
+~#! rn=Amaryllis rt=1063832104 rg=schmarrn.netdigest
+~#! tid=1063831853
+Ich wollte da nix zensieren :) Aber die ersten 13% reichen voellig aus :) Ein
+wenig Grundlagen modern interpretierter Wahrscheinlichkeitstheorie :)
+
+V*, gibt 'rylles recht. Mehr als eine Bildschirmseite scrollt ueblicherweise
+ungelesen vorbei.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Das muss ich einfach posten (Gloinson, 17. Sep 2003, 23:04:57):
+~#! rn=Vanion rt=1063832260 rg=schmarrn.netdigest
+~#! tid=1063831853
+Und nachdem bewiesen wurde, dass aufgrund der zurechtgelegten
+Wahrscheinlichkeitsverhaeltnisse auf der Erde kein heutige Molekuel so direkt
+entstanden sein kann kommt dann meist die "Theorie der intelligenten
+Anordnung". Jaja, Occams Razors Edge, nicht iterativ durchdacht: "Wenn die
+Evolutionstheorie sooo kompliziert wird, dann ist es doch einfach eine
+Metastruktur (auch Gott genannt) schuldig zu sprechen.
+[Gedankenende/Denkende]"
+
+
+-----------------------------------------------------------------------------
+
+
+
+Ooooh... mein erster Computer! (Ronda, 18. Sep 2003, 00:58:05):
+... dass ich das noch erleben darf... ;-)
+
+Ronda
+
+Subject: [SMTP] mailserver01.cybernet.be
+[entdeckt von Florian Laws]
+
+~>telnet mailserver01.cybernet.be smtp
+
+Trying 213.177.64.33...
+Connected to mailserver01.cybernet.be.
+Escape character is '^]'.
+
+220-mailserver01.cybernet.be ESMTP Sinclair ZX81 running on 3.5 Microdrive;
+Tue, 16 Sep 2003 22:41:46 +0200
+
+220-*******************************************************
+220-*                Welcome to Cybernet                  *
+220-*This smtp is telnet protected don't try any command !*
+220-*                support@cybernet.be                  *
+220 *******************************************************
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Das muss ich einfach posten (Firehawk, 18. Sep 2003, 11:05:37):
+~#! rn=Vanion rt=1063831853 rg=schmarrn.netdigest
+~#! tid=1063831853
+Bei sowas spricht man dann wohl von einem Zufall kosmischen Ausmasses ;)
+
+Firehawk, leise kichernd
+
+-----------------------------------------------------------------------------
+
+
+
+... (Foobar, 20. Sep 2003, 17:13:41):
+From: filter001@desinformation.de (ray)
+Newsgroups: de.talk.liebesakt
+Subject: Penis Enlargement Pils
+Date: 18 Sep 2003 02:57:53 -0700
+Message-ID: <9e65284e.0309180157.53980bb1@posting.google.com>
+
+Vorher hab ich ja anderes Pils getrunken, wenn |berhaupt. Aber jetzt
+trinke ich jeden Tag mindestens 3 Penis Enlargement Pils.
+
+Raymund Hofmann
+
+-----------------------------------------------------------------------------
+
+
+
+Geisterstunde ;-) (Ronda, 20. Sep 2003, 21:35:34):
+From: fotoralf@gmx.de (Ralf R. Radermacher)
+Subject: Re: Imperativ von "erschrecken"
+Date: 13.09.2003 15:24:19 (W+2)
+Message-ID: <1g18dfp.i93llf1duaaomN%fotoralf@gmx.de>
+Newsgroups: de.etc.sprache.deutsch
+
+[SN: "Erschrick" oder "Erschreck Dich nicht!"]
+
+
+Stephan Doerner <stephan.doerner@epost.de> wrote:
+
+> Ich habe folgende Frage: Wie lautet der Imperativ von "erschrecken"? 
+
+"Buh!"
+
+SCNR,
+Ralf
+
+-----------------------------------------------------------------------------
+
+
+
+Wo kommt SWEN her - oder... (Ronda, 24. Sep 2003, 23:17:45):
+...de.alt.recovery.webauthor gibts wirklich!
+
+Ronda
+
+From: Lars Kasper <send_mail.not_spam@LarsKasper.de>
+Newsgroups: de.comm.infosystems.www.authoring.misc,de.alt.recovery.webauthor
+Subject: Internetfuehrerschein (was: Wieviel Leute surfen ohne JS?)
+Date: Mon, 22 Sep 2003 14:57:31 +0200
+Message-ID: <1g1ml9j.6jiigck7vbb4N@usenet.LarsKasper.de>
+
+Rainer Kersten schrieb in dciwam:
+
+> Im uebrigen bin der Meinung, dass ein Fuehrerschein fuer die 
+> Benutzung des Netzes eingefuehrt werden sollte.
+
+Oh, toll. Ich stelle mir gerade meine praktische Surfpruefung vor:
+
+Ich betrete den Computerraum an der Volkshochschule, begruesse den Pruefer
+und der weist mich an, mich an den Windows-XP-Rechner zu setzen.
+
+Pruefer: "Melden se sich als 'Jast' an und starten se dann den Brauser."
+
+Ich waehle den Benutzer 'Gast' und frage nach dem noetigen Passwort. Der
+Pruefer schaut mich etwas schief an: "Na, 'gast' natuerlich."
+
+Alsbald suche ich im quietschbunten Startmenue einen Browser, beim
+Hangeln durch alle Programmgruppen finde ich aber weder Mozilla, noch
+Opera. Nichtmal ein alter Netscape.
+
+Pruefer: "Na, wat dauert det denn so lange? Wat suchense denn? Kennse
+sich nichmal mit den Computer-Grundlagen aus?! Starten se jetzt doch das
+Internet, gleich da auf'm Desktop."
+
+Aus Mangel an Alternativen klicke ich also auf das blaue "e"-Icon.
+
+Die eingestellte Startseite erscheint, noch wesentlich bunter als
+Windows XP, mit vielen Animationen und Schriftarten und -groessen. Laute
+Hintergrundmusik ertoent aus den billigen Lautsprechern; ich will in der
+Taskleiste den Ton wegdrehen.
+
+Pruefer: "Neee, wat hamse denn vor? Lassense det mal sein. Det is meine
+Homepage, zeige ick hier allen Schuelern, empfehle ick jeden, sowas zu
+machen. Hab ick mit Frontpage selbst programmiert, janz einfach ..."
+
+Mir kommt es in den Sinn, "validator.w3.org" in die Adressleiste zu
+tippen, werde daran aber von einem gelben Popup, beschriftet mit
+'ZoneAlarm', am unteren rechten Bildschirmrand gehindert.
+
+Pruefer: "Det is unsere Firewall. Irgendsoein Hacker wollte unseren
+Computer angreifen, aber die Firewall hat det nicht zujelassen. Det
+habense in der Theorie ja gelernt. Klickense det mal wech, Beschwerden
+schreib ick sonst immer an die Provider, aber nich' waehrend 'ner
+Pruefung."
+
+Pruefer: "So, jetzt gehn wa erstma' auf eine Seite fuer
+Computernachrichten. Man muss sich ja informieren. Wegen Viren und Wuermer
+und so'n Getier ..."
+
+Ich habe schon die ersten vier Buchstaben H, E, I und S getippt, da
+meldet er sich schon wieder: "Wat machense denn jetzt schon wieder?
+Wollense Seiten mit Schweinebildchen besuchen, wa? Det kennense, wa?
+HeisseMaedels.de oder sowat, wa? ... Neee, serioese Infos wollen wa.
+Tippense ein: waewaewae Punkt Computerbild Punkt de eh! ..."
+
+<snip/>
+
+Zehn Minuten spaeter.
+
+Pruefer: "Neee neee, das mit den Webseiten ist nicht ihre Staerke, das
+habe ick schon von Anfang an gesehen. Machen wa mal wat anderes. Wir
+verschicken mal ne E-Mail. Machense mal den Outlook Express auf."
+
+Ich tue wie geheissen und sehe zum ersten Mal in meinem Leben dieses
+Programm, von dem ich schon so viel im Usenet gelesen habe ... :-)
+
+Pruefer: "Sie haben doch sicher ne E-Mail-Adresse, wa? Schickense sich
+selbst mal ne E-Mail von hier. Mit 'nem Anhang. Ick habe da ein paar
+lustige Sachen in Eigene Dateien Schraegstrich Lustiges. Suchense sich da
+wat aus."
+
+Ich erstelle eine neue E-Mail an die Adresse 'devnull aet LarsKasper.de'
+...
+
+Pruefer: "Sie haben aber ne lustige E-Mail-Adresse, mit dem Namen hinten.
+Funktioniert denn das? Hamse denn gar keine bei Web.de oder GMX? Hat
+doch jeder. Mit dem Namen vorne. Na, machense weiter, haengense was
+lustiges da dran!"
+
+... und suche mir aus dem von ihm genannten Ordner die Powerpoint-Datei
+mit dem geringsten Dateivolumen aus.
+
+Pruefer: "So, jetzt wegschicken!"
+
+Auch das wird erledigt. Die neuen E-Mails werden auch gleich abgerufen.
+
+Pruefer: "Oh, neue Nachrichten. Was ist denn das? Klickense mal da drauf
+..." Er deutet auf eine neue E-Mail im Posteingang.
+
+Pruefer: "Ah. Von Microsoft. Die schicken uns was, damit wir hier vor
+Wuermern sicher sind. Hamse das schonmal gemacht, so einen Flicken --
+Profis nennen das Paetsch -- aufzuspielen? Klickense den Anhang gleich
+mal an, diese EXE-Datei da ..."
+
+Pruefer: "Hey, wo wollense denn hin? Warum laufense denn weg? Kommense
+wieder her! HEY! DURCHGEFALLEN! Durchgefallen sindse! ... Der naechste,
+bitte!"
+
+
+<xpost>dciwam <fup2>darw</fup2></xpost>
+
+-----------------------------------------------------------------------------
+
+
+
+Der Digest des Netdigest ist da! (Ronda, 28. Sep 2003, 01:08:12):
+Warnung... Hanno (nein, nicht "unser" Hanno, den Namen gibts zweimal...) hat
+nicht gesagt, dass da 125 Artikel liegen...
+
+Subject: [Jubilaeum] 5 Jahre Moderation
+
+Hallo,
+                                                                             
+Heute vor fuenf Jahren habe ich das Amt des Netdigest-Moderators uebernommen.
+
+Daher habe ich mich entschlossen so etwas wie ein persoenliches
+Best-Of herauszubringen. Ich bin zwar noch nicht durch alle Artikel
+durch, aber ich bemuehe mich :)
+
+Das Best-Of ist auf dem Newsserver luggage.rince.de zu finden. Fuer die
+naechsten Tage ist der Zugriff fuer alle Leute zum Lesen frei.
+
+Viel Spass beim Lesen!
+
+Ciao, Hanno
+
+-----------------------------------------------------------------------------
+
+
+
+Was fuer ein Frauen-/Maennertyp bist Du? (Ronda, 28. Sep 2003, 01:14:12):
+... um mal auf die grad so beliebten "Was fuer ein ____-Typ bist
+Du?"-Frageboegen einzugehen (ersetze ____ durch Pirat, Lover, Nerd, Mann,
+Frau, Alien, Mudder...):
+
+From: Irina Rosenthal <artemisia@gmx.li>
+Newsgroups: de.talk.romance
+Subject: Re: Computerwurm verwendet Reply-To-Adressen
+Date: Tue, 23 Sep 2003 12:59:29 +0200
+Message-ID: <bko38s$3vvsj$1@ID-86729.news.uni-berlin.de>
+
+
+Felix Waldner <helpmetohelpyou@gmx.net> writes:
+
+> Denken wir uns doch mal drei populaere OS als Frauentypen:
+>
+> MacOS: die Schoene, die nicht zu viel zu gebrauchen ist
+> Linux: die Raetselhafte, an der es immer Neues zu entdecken gibt
+> Windows: die durchschnittliche, aber treue Lebensbegleiterin
+>
+> Widersprueche willkommen.
+
+Ich darf doch mal die Maennertypen anfuegen?
+
+Windows: der billige Aufreisser. Geht mit jeder ins Bett und haengt
+einem dann irgendwelche Geschlechtskrankheiten an.  
+MacOS X: der, dem die Frauen hinterherlaufen. Sieht umwerfend aus,
+ist aber trotzdem verlaesslich und ein anstaendiger Kerl.
+Linux: das kindliche Genie. Vollbringt Spitzenleistungen und scheitert
+dann an einfachsten Alltagsproblemen. 
+
+viele Gruesse,
+Irina
+
+-----------------------------------------------------------------------------
+
+
+
+[de.alt.netdiges] Re: Coffee leaches vitamins from those who drink it? (Amaryllis, 30. Sep 2003, 22:21:10):
+From: z0308@horga.de (Andreas Frackowiak)
+Newsgroups: de.alt.folklore.urban-legends
+Subject: Re: Coffee leaches vitamins from those who drink it?
+Date: 30 Sep 2003 08:42:59 GMT
+Message-ID: <blbfmj$a78a0$1@ID-169054.news.uni-berlin.de>
+
+Louis Cipher <escupir_hilo@yahoo.com> wrote:
+> 
+> How much coffee can an average American drink, if any, without worry of
+> significant damage to their health?
+
+If you drink the colored warm water (that is called coffee
+and that is usually served across the united states) with 
+sugar you should always worry about the bad taste and what 
+the sugar will do to your body.
+
+On the other hand, you know that coffee comes from countries
+in South America (selling also other drugs to US kids),
+Africa (have heard of Ghaddafi ?) and Arabia (unlimited
+source of oil and terrorists) ?
+
+Do you really think a patriotic North American should support 
+those evil countries with his or her money - and buy/drink coffee ?
+
+Eating freedom fries and drinking coffee doesn't fit very well.
+Andreas
+
+-----------------------------------------------------------------------------
+
+
+
+The best of netdigest... (Ronda,  1. Okt 2003, 23:55:46):
+... gibts wie schon geschrieben auf luggage.rince.de -
+local.best-of-netdigest...
+
+From: Marc Luethi <marc.luethi@gmx.ch>
+Newsgroups: de.alt.sysadmin.recovery
+Subject: Re: Telefon-Luser
+Message-ID: <aoffkso75dmsq1eporklks3hkgpisfsgu3@4ax.com>
+
+frank paulsen <frank.paulsen@gmx.net> wrote:
+
+>der naechste wird zum zum staedtischen krematorium weiterverbunden.
+
+*grins* wenn bei mir zum dritten mal in 3 Minuten das Telefon klingelt
+(und ich habe kein ISDN-Geraet, ich seh nicht, wer anruft), melde ich
+mich immer mit
+
+"Staedtisches Krematorium, Ofen 3, Klappe 5. Was liecht an?"
+
+Einzig schlagfertige Antwort bisher:
+
+"Ich rufe an, weil ich meinen Termin bei ihnen von morgen 16:00 gern
+verschieben moechte ..."
+
+
+Gruss
+
+Marc
+
+
+-- 
+Submissionen fuer de.alt.netdigest bitte an
+<de-alt-netdigest@moderators.dana.de> schicken.
+Der Submitter ist fuer den Inhalt der Einreichung verantwortlich, 
+nicht der Moderator der Newsgruppe.
+
+-----------------------------------------------------------------------------
+
+
+
+Re: The best of netdigest... (Ronda,  1. Okt 2003, 23:56:52):
+~#! rn=Ronda rt=1065045346 rg=schmarrn.netdigest
+~#! tid=1065045346
+... der hier koennte auch von Grimmborn oder Anatol sein...
+
+Message-ID: <38DB5E9D.9EA45D06@netuse.de>
+Date: Fri, 24 Mar 2000 13:25:01 +0100
+From: Kristian Koehntopp <kk@netuse.de>
+Newsgroups: de.comp.lang.php
+Subject: Re: Hierachisches Menue
+
+Carsten Bluem wrote:
+> Kristian Koehntopp <kris@koehntopp.de> wrote:
+> > Das sind die drei Regeln fuer korrektes PHP:
+> >
+> > 1. Wer lesen kann, ist klar im Vorteil.
+> > 2. Wenn man es richtig macht, dann funktioniert es auch.
+> 
+> DREI????
+> 
+
+3. Es gibt immer noch eine Regel, die Du nicht kennst.
+
+Kristian
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: The best of netdigest... (Ronda,  1. Okt 2003, 23:59:24):
+~#! rn=Ronda rt=1065045412 rg=schmarrn.netdigest
+~#! tid=1065045346
+Ok, der haette auch von Grimmborn sein koennen - aber der haette sich dabei
+nicht vertippt...
+
+From: Hans Bonfigt <bonfigt.ses-koeln@t-online.de> 
+Newsgroups: de.alt.sysadmin.recovery 
+Subject: Re: Recovery? Ich glaube nicht. 
+Date:Thu, 11 May 2000 15:35:12 +0100 
+
+Olaf Klein:
+> 
+> >Das was im Moment hier ablaeuft ist aber so gar nicht Recovery.
+> 
+> Ueberall, wo Lutz anfaengt, besser zu wissen wirds nervig.
+
+Kommt drauf an.
+
+Da, wo Lutz anfaengt, besser zu wissen, wird es interessant.
+
+Da, wo er anfaengt, besserzuwissen, wird es ansrengend.
+
+
+Gruss,
+
+Ha "Sie hatte ihre Vorteile, die alte Rechtschreibung" ns
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: The best of netdigest... (Ronda,  2. Okt 2003, 00:01:00):
+~#! rn=Ronda rt=1065045564 rg=schmarrn.netdigest
+~#! tid=1065045346
+OK, ok, gleich hoer ich auf zu posten... also DER waere dann wieder von Anatol
+nach seinen wunderbaren Begegnungen mit Fahrscheinautomaten der DB...
+
+From: robert.weemeyer@gmx.de (Robert Weemeyer)
+Newsgroups: de.etc.bahn.eisenbahn
+Subject: Re: Neuer Name fuer alten Unsinn? "Die Bahn"
+Date: Mon, 03 Apr 2000 19:54:42 GMT
+Message-ID: <8casvd$64f6m$2@fu-berlin.de>
+
+Andreas Terlinden schrieb:
+
+> Ich habe heute gelesen das die Deutsche Bahn AG sich in Die Bahn umbenennen
+> will. 
+
+Aus "Frontal" im ZDF (sinngemaess):
+Fuer welche Eigenschaften steht das Adjektiv "deutsch"?
+Puenktlichkeit, Ordnung, Sauberkeit.
+"Die Bahn" wird schon wissen, warum sie das Wort "deutsch" weglaesst.
+
+Robert Weemeyer, Berlin
+
+-----------------------------------------------------------------------------
+
+
+
+Re: A day in the life or Germany (Amaryllis,  3. Okt 2003, 14:28:55):
+Subject: Re: A day in the life or Germany
+From: Christian Roessler <chr_rossi@web.de>
+Newsgroups: soc.culture.german
+Message-ID: <slrnbnlu3s.1bt.chr_rossi@taniquetil.fqdn.th-h.de>
+Date: Wed, 1 Oct 2003 18:01:08 +0200
+
+Vorher schrieb Hans Schlager:
+
+>> Oct 1 1938
+>> Germany annexes the Sudetenland.
+> Yeah well that's nothing we haven't heard before. But on the
+> very same day countrywoman Mrs. Rosina Himmelfreundpointner
+> from the beautiful village of Unterampflfing stepped out of
+> the frontdoor, slipped on a bit of chicken feed and fell so
+> badly on her buttock that she needed urgent medical help. 
+
+Aber das ist so nicht wahr: Es war nicht Frau Rosina 
+Himmelfreundpointner, es war Frau Marina 
+Himmelfreundpfoertner-Unterebereschenbachner, und sie ist 
+nicht aus der Haustuer, sondern aus der Hintertuere getreten, 
+es war auch kein Huehnerfutter, sondern ein Kuhfladen, sie ist 
+nicht auf den Arsch gefallen, sondern auf die Schnauze, und 
+sie brauchte auch keine medizinische Hilfe, sondern ein paar 
+Schnaepse haben gereicht. 
+Aber Unterampfling stimmt.
+
+Stets zu Diensten und SCNR: Christian
+
+
+-----------------------------------------------------------------------------
+
+
+
+Amiga 500 auf Abwegen... (Ronda,  3. Okt 2003, 19:03:20):
+From: kris@koehntopp.de (Kristian Koehntopp)
+Newsgroups: de.alt.folklore.usenet
+Subject: Re: sendsys [was: Re: cmsg checkgroups]
+Date: 21 Dec 1999 10:16:34 +0100
+Message-ID: <83nghi$723$1@valiant.koehntopp.de>
+
+Mario_Hoerich@t-online.de (Mario Hoerich) writes:
+>Klingt interessant, was hat es mit sendsys und dem Unfall auf
+>sich?
+
+Damals, als das Individual Network noch ein Geist war, hatte ein
+Amiga-User im IN mit News rumexperimentiert und 5
+Checkgroup-Nachrichten generiert, die dann aufgrund einer Panne
+in die Welt entkamen. Als diese Nachrichten dann UUCP-Land
+verliessen und via EuNet Deutschland das Internet betraten,
+wurden sie vergleichsweise schnell weltweit verbreitet. Erinnert
+Euch Kinder: damals gab es noch keinen Spam und keinen
+Binaermuell, alt.sex und alt.sex.bondage waren die einzigen
+beiden Sex-Gruppen und beide waren interessant und lesbar.
+Damals lag die mittlere Newstransferzeit auf der Welt lag unter
+4 Stunden!
+
+Ausserdem gab es damals auch noch keine Verzoegerung in der
+sendsys-Reponse-Verarbeitung. Also generierten alle empfangenden
+Rechner brav 5 sendsys und sandten diese brav an den Absender,
+dessen MX auch wieder auf EuNet Deutschland zeigten. Dort kamen
+also vergleichsweise synchron haufenweise eingehende Mails an,
+die auf einer Siemens MX alle einen Empfaengerprozess
+generierten, bis der Speicher alle war und die MX ueber die
+linke Tragflaeche abschmierte und sich in den Boden bohrte. Das
+kam oefter vor (schliesslich war es eine MX), also startete man
+bei EuNet die MX neu, um neben ihr stehend einem erneuten Halt
+des Systems beizuwohnen.
+
+Solange EuNet down war, kamen die Mails natuerlich bei deren
+Fallback an, der ebenfalls zu viele Prozesse kassierte und ein
+aehnliches Verhalten an den Tag legte wie EuNet selbst. Beide
+Rechner waren jedoch nicht ganz unwichtig fuer die Verbreitung
+von Mail auf dem europaeischen Kontinent, sodass man mit einiger
+Berechtigung sagen kann, dass besagter Amiga 500-User ohne
+besondere Anstrengung den groesseren Teil Europas aus dem Netz
+geblasen hat.
+
+EuNet musste dann ein wenig mit dem DNS tricksen und die
+DNS-Propagation abwarten, bevor sie wieder online gehen konnten.
+Der Amiga-User wurde unter anderem deswegen nicht standrechtlich
+erschossen, weil er im passenden Moment einige Kisten Sekt fuer
+EuNet aus dem Hut zaubern konnte.
+
+Kristian
+
+-----------------------------------------------------------------------------
+
+
+
+... wohl war, wohl war... (Ronda,  3. Okt 2003, 19:10:43):
+From: Ulli Horlacher <framstag@bofh.belwue.de>
+Newsgroups: de.comp.os.unix.apps
+Subject: Re: Suche Email-Client
+Date: 12 Dec 1999 16:53:10 GMT
+Message-ID: <830jtm$8vr$1@news.BelWue.DE>
+
+Malte Gell <malte.gell@gmx.net> wrote:
+
+> fuers Fragen sollte man sich nicht entschuldigen muessen, es gibt keine
+> dumme Fragen, nur dumme Antworten 
+
+So was dummes kann nur jemand sagen, der noch nie in einer
+Benutzerberatung gearbeitet hat.
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Wie baue ich ungeschickte Dokumente? - Abschreckende Beispiele gesucht (Amaryllis,  3. Okt 2003, 19:49:51):
+Subject: Re: Wie baue ich ungeschickte Dokumente? - Abschreckende Beispiele
+gesucht
+From: "Anton Berg" <anton.berg@excite.com>
+Newsgroups: de.comp.text.dtp
+Message-ID: <blhsph$cglh6$1@ID-8515.news.uni-berlin.de>
+
+Ralph Benz schrieb
+> Fuer meine Azubine stelle ich gerade zusammen, was der Laie (oder
+> *scheinbare* Profi) so alles falsch machen kann.
+
+Hey, die anderen Beitraege haben mich voll an meinen Alltag in der Firma
+erinnert - 80% davon hatten wir auch schon. Und dann waren da noch:
+
+- Auftraege fuer Trauerbildkarten, bei denen das einzige Foto des
+Verstorbenen sein Personalausweis (eingeschweisst, mit den
+Kopierschutzlinien) war
+
+- Bilder, die wegen (raeumlich!) zu kleinem Geldbeutel (in dem sie
+unbedingt transportiert werden mussten) mal eben gefaltet waren...
+
+- wir: "wir brauchen das Originalbild" - Kunde: "klar, das faxe ich
+Ihnen sofort!"
+
+- Fax vom Kunden, darauf handschriftliche Markierung: "Bitte _dieses_
+Blau verwenden!"
+
+- Gruppenbild, von dem nur eine Person genommen werden soll. Leider die
+anderen sehr raumgreifend mit Edding ausgestrichen...
+
+- Mail: "anbei das Bild..." - Mailgroesse ca. 2kb... klar, war ja auch nur
+der Link auf die Festplatte des Absenders.
+
+- Diskette mit der Bemerkung: "schauen Sie mal, ob was drauf ist"
+
+- zwei A4-Seiten Text fuer eine Anzeige im Format 30x45 mm
+
+- Mail, die als Anhang eine Mail hat, die als Anhang eine Mail hat, die
+als Anhang...
+
+- A2-Plakate als JPG mit 20kB, bitte zweifarbig schwarz/gruen drucken
+
+- Entwuerfe fuer randabfallenden Druck ohne Beschnittzugabe - moeglichst
+mit einem Foto am Rand...
+
+- undefinierbare Dateien, Nachfrage beim Kunden "mit welchem Programm
+haben Sie...?" - Kunde: "Windows!"
+
+...und es werden taeglich mehr... ;-)))
++
+
+-----------------------------------------------------------------------------
+
+
+
+Re: b.c-Sitzplatz - Wie macht ihr das? (Amaryllis,  3. Okt 2003, 19:51:11):
+From: Oliver Schnell <o@tenesu.mkm.de>
+Newsgroups: de.etc.bahn.tarif+service
+Subject: Re: b.c-Sitzplatz - Wie macht ihr das?
+Date: Wed, 1 Oct 2003 14:26:27 +0000 (UTC)
+Message-ID: <bleo6j$lct$1@ds01.mkm.de>
+
+Reinhard Schumacher <spam.schumacher@arcor.de> wrote:
+>>Angehoerige des Konzerns haben uebrigens, so habe ich mir sagen lassen,
+>>aufzuspringen und ihren Sitzplatz zu Verfuegung zu stellen, so ein
+>>zahlender Kunde anderweitig keinen Platz mehr findet.
+
+> Das ist richtig, und damit habe ich auch keine Probleme. Aber ich habe
+> auch noch Bekannte, die nicht bei der Bahn arbeiten und muss mir
+> laufend deren Klagen anhoeren, auch ueber diese b.c.-Plaetze. Und ich
+> finde dieses System unfair.
+
+Also dann erklaer deinen Bekannten die Eisenbahn doch folgendermassen:
+
+Am besten ists, du reservierst dir einen Platz, dann weisst du, wo du
+dich hinsetzen musst.
+
+Reservierst du nicht, dann meide
+
+Familien/Kleinkindabteil, wenn da jemand mit Nachwuchs kommt, musst du
+den Platz freigeben;
+
+Schwerbeschaedigtenabteil, wenn da jemand mit koerperlichen Defekten
+kommt, musst du den Platz freigeben;
+
+comfort.plaetze, wenn da einer mit sozialen Defekten kommt, musst du
+den Platz freigeben;
+
+Fuehrerstand, wenn da einer mit pekuniaeren Defekten kommt, musst du
+den Platz freigeben, denn das ist der Lokfuehrer;
+
+Menschen mit geistigen Defekten triffst du dagegen am ehesten da, wo der
+Aufenthalt fuer Fahrgaeste gestattet ist und gleichzeitig Streckensicht
+moeglich ist. Solche Plaetze musst du zwar nicht freigeben, ist aber
+besser fuer dich;
+
+Mein Gott, ist doch alles nicht so schwer. ;-)
+
+
+-----------------------------------------------------------------------------
+
+
+
+[de.etc.bahn.misc] Nochmal Speisewagen (selbsterklaerend) (Deepblue,  6. Okt 2003, 19:34:25):
+Newsgroups: de.etc.bahn.misc
+Subject: Nochmal Speisewagen (selbsterklaerend)
+From: Edgar Warnecke <ewarnecke@gmx.net>
+Date: Fri, 03 Oct 2003 19:12:40 +0200
+Message-ID: <9bbrnv0lro2n3odnklsfcuj9375smosbfm@4ax.com>
+
+Mit freundlicher Genehmigung von Horst Evers:
+From: Kabelsalbader <kabelsalbader-admin@prenzl.net>
+
+~~~ Protzner (Horst Evers (c))
+
+Rueckfahrt von Stuttgart nach Berlin. Ich hab keine
+Reservierung, aber der Zug ist pickepacke voll. Na toll.
+Nach nur zwei Stunden wird kurz hinter Frankfurt ein Platz
+im Speisewagen frei. Immerhin. Wenn ich alle halbe Stunde
+einen Kaffee bestelle, sichert mir das das Bleiberecht und
+kostet mich bis Berlin 30 Mark. Teure Platzkarte, aber
+egal. Leider sitzen an meinem Tisch schon Herr Fringer und
+Dr. Maismann. Offensichtlich macht der eine in Kosmetika,
+der andere in Textilien. Das wissen mittlerweile alle hier,
+denn sie quatschen unaufhoerlich in ihre Handys.
+"Ja, Fringer hier, na, der Fringer von 'Fringer und
+Fringer', ich bin jetzt kurz hinter Frankfurt, sagen Sie
+dem Herrn Protzner, er soll mich zurueckrufen, damit wir
+uns in Berlin gleich treffen koennen. Die Sache ist sehr
+wichtig. Meine Nummer ist 0173-4424453, Fringer, sehr
+wichtig!!!"
+Laengst ist zwischen Dr. Maismann und Herrn Fringer ein
+Wettstreitentbrannt,wessenGeschaeftebedeutendersind,
+also bruellen sie immer lauter in ihre Taschentelefone,
+damit auch jeder im Wagen ganz sicher von ihrer immensen
+Bedeutung fuer den Wirtschaftsstandort Deutschland
+unterrichtet ist. Schnell geht es offenkundig um Leben und
+Tod.
+Leider scheint sich Herr Protzner der Bedeutung dieser
+Geschaefte nicht bewusst zu sein, denn er ruft einfach
+nicht zurueck, weshalb Herr Fringer allein ihn innerhalb
+einer Stunde genau achtzehn Mal zu erreichen versucht.
+In Hildesheim steigt Dr. Maismann aus. Offensichtlich hat
+er verloren und muss zur Strafe in Hildesheim bleiben.
+Euphorisiert von diesem Erfolg bruellt der siegreiche
+Fringer nach Hildesheim nochmal doppelt so laut in sein
+elektronisches Zepter. Das und die betraechtlichen
+Kaffemengen in meinem Koerper fuehren dazu, dass ich einen
+verzweifelten Entschluss fasse.
+Gehe einen Waggon weiter zum Kartentelefon und waehle
+Fringers mir mittlerweile hinlaenglich bekannte Handynummer.
+"Ja, hier ist Protzner. Hoern Sie zu, Fringer, ich bin im
+Moment gar nicht in Berlin, ich bin im Moment etwas
+noerdlich von Braunschweig bei der Jagd. Trotzdem sollten
+wir uns aber unbedingt treffen, Sie wissen ja selbst, wie
+wichtig diese Sache ist. Steigen Sie also in Braunschweig
+aus, nehmen Sie sich ein Taxi zur noerdlichen Stadtgrenze
+und laufen Sie dann einfach gerade in den Wald hinein. Dann
+kommen Sie direkt auf mich zu, koennen Sie gar nicht
+verfehlen!!!"
+Als ich zurueckkomme, kramt Fringer schon hektisch seine
+Sachen zusammen. Er will noch einen Anruf machen, aber der
+Akku seines Handys ist leer. Oh, da haette sich die Sache
+ja fast von selbst erledigt. Ueberlege kurz, ob ich ihn
+dann nicht aufklaeren sollte, komme aber zu dem Schluss,
+dass es Herrn Fringer sicher mal ganz gut tut, eine Weile
+durch den Wald zu laufen. Ich verabschiede ihn: "Bleiben
+Sie stark, Herr Fringer, wir alle verlassen uns auf Sie."
+Er nickt wissend und hastet dann zum Ausgang.
+Endlich Ruhe. Und sogar den ganzen Kaffee hat mir der
+Mitropa-Kellner, da er zufaellig mein Gespraech am
+Kartentelefon mitgehoert hat am Ende spendiert. Netter Zug.
+
+(aus: Salbader Nr. 33)
+
+-----------------------------------------------------------------------------
+
+
+
+[ch.talk] Re: Vorschlag fuer eine neue Newsgroup (Deepblue,  6. Okt 2003, 19:37:40):
+From: "Tom Steinbeck" <Spam.Tom@gmx.ch>
+Subject: Re: Vorschlag fuer eine neue Newsgroup
+Newsgroups: ch.talk
+Message-ID: <3f7f8948$0$20053$fb624d75@newsspool.solnet.ch>
+
+> >wie waer's mit einer ch.auto Newsgroup wo man ueber
+> >alles was mit Autos zu tun hat diskutieren kann? Das ist
+>
+> de.etc.fahrzeug.auto
+>
+> Gruss, Patrick
+
+Spinnst du??? mit einer de.xxx Group machen wir uns wieder vom Ausland
+abhaenig! Das wollen bei den naechsten Wahlen mindestens 26% einer gewissen
+volksnahen Partei nicht. Ich bin deshalb fuer die Schaffung neuer
+ch.newsgroups wie:
+
+ch.talk.abschottung
+ch.talk.auslaenderprobleme
+ch.talk.eu-nein
+ch.talk.asylmissbrauch
+ch.talk.angstschuererei
+ch.talk.nein-zu-allem
+
+Wieso sollen wir immer auf auslaendische Gruppen ausweichen? Kann mir dafuer
+mal jemand einen guten Grund nennen?
+
+Gruss
+Tom
+
+
+-----------------------------------------------------------------------------
+
+
+
+Bayern Muenchen (Nonne,  7. Okt 2003, 13:03:19):
+Aus dtj:
+Hi,
+
+ich frage mich, welche sportlichen Leistungen man wohl von einem
+Spieler namens "Rheuma-Kai" erwarten kann.
+
+Nonne, kringelt sich auf dem Boden.
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Einwahl- und VPN-Nutzer aufgepasst: der Blast-o-mat (Amaryllis, 11. Okt 2003, 19:46:37):
+Subject: Re: Einwahl- und VPN-Nutzer aufgepasst: der Blast-o-mat
+Newsgroups: rwth.dialup
+Date: Thu, 9 Oct 2003 20:51:25 +0200
+From: Markus Dobel <mdobel@kawo2.rwth-aachen.de>
+Message-Id: <20031009185120.G15312@balu.kawo2.rwth-aachen.de>
+
+On Thu, Oct 09, 2003 at 09:07:06AM +0000, Hans-Bernhard Broeker wrote:
+> Jens Liebchen <jens_news2@liebchen-online.de> wrote:
+>
+>> die Arbeit der Netzwerkadmins weniger, das eigentliche Problem
+>> leider nicht, denn das liegt nunmal im DAU. Ein Airbag im Auto
+>> rettet sicherlich auch viele Menschenleben hilft aber nicht bei
+>> unge|bten Autofahrern.
+>
+> Aha.  Und das ist dann also ein Argument f|r die Abschaffung von
+> Airbags, oder wie?  Merke: ein Fahranfnger mit Airbags ist zumindest
+> nicht gefhrlicher f|r andere als einer ohne, und in jedem Fall
+> weniger gefhrlich f|r sich selbst.
+
+Depends. Ein Airbag ist kein Ersatz fuer vorsichtiges Fahren.
+Autofahrer wissen dies jedoch meist und fahren auch mit Airbag
+vorsichtig.
+
+Unbedarfte Computer-Nutzern haben genau dafuer haeufig kein
+Verstaendnis. "Ich hab ne Desktop-Firewall und nen Virenscanner, nun
+kann ich ja ruhig auf alles klicken, was mir ueber den Weg laeuft. Vor
+allem, wenns ein Sicherheits-Update von Microsoft ist."
+
+Selbst merkwuerdige Meldungen  werden einfach weggeklickt, bis der
+Rechner schlicht und ergreifend garnicht mehr funktionieren will.
+Merke: Alle Dialogboxen sind merkwuerdig, der Inhalt unwichtig. Wenn
+man auf OK klickt, gehen sie aber weg. Ist der Rechner gaenzlich
+unbenutzbar, weint man sich halt beim Admin aus, setzt diesen dann vor
+den Desktop voller Bonzibuddies, Gators, eZulas und laesst ihn
+wenigstens fuenf Viren/Trojaner o.ae. deinstallieren, die der
+installierte Virenscanner deshalb nicht erkannt hat, weil sie einfach
+noch nicht im Signaturenfile von Dezember 1999 enthalten waren.
+
+Dafuer ist der Rechner dank Zonealarm so krass sicher, dass er die
+Windows-Netzwerkumgebung fuer den Rest der Nutzerschar unbenutzbar
+macht, in dem er "Jetz bin ich hier der Master Browser" ins Netz
+bruellt, sich danach aber die Ohren zuhaelt, wenn jemand die Liste der
+in der Arbeitsgruppe befindlichen Rechner abfragen will. Ausserdem
+dauert der Mail-Versand jedes mal mehrere Minuten, weil Zone Alarm im
+Super-Stealth-Mode alle "Angriffe" des Mailservers auf den Identd-Port
+erfolgreich ohne Reject abwehrt.
+
+Das ist in etwa so, als wuerde der Fahranfaenger sich den Gurt um den
+Hals wickeln und die Haende laessig mitten aufs Lenkrad legen, damit
+ihm im Falle eines Crashs wenigstens noch schnell die Handgelenke
+gebrochen werden bevor er erwuergt wird.
+
+Versucht man einem solchen Nutzer zu erklaeren, was er falsch gemacht
+hat und wie ers richtig macht, hoert dieser seltenst zu. Schliesslich
+"will man doch nur mit dem Teil arbeiten und nicht zum Profi werden".
+
+Gruss, Markus
+
+
+-----------------------------------------------------------------------------
+
+
+
+[z-netz.alt.rollenspiele.dsa] Re: Argh! (Amaryllis, 11. Okt 2003, 19:49:59):
+Subject: [z-netz.alt.rollenspiele.dsa] Re: Argh!
+From: Jens Himmelrath <usenet@zhayad.de>
+Reply-To: jens@zhayad.de
+Newsgroups: de.alt.netdigest
+Followup-To: de.talk.jokes.d
+
+[Anmerkung: Das Bild ist von einer Rollenspiel-Convention und zeigt 
+einen ziemlich repraesentativen Durchschnitt. Die Verfasserin ist selbst 
+leidenschaftliche Rollenspielerin.]
+
+From: Hilke K. Greff <sephyra@web.de>
+Subject: Re: Argh!
+Newsgroups: z-netz.alt.rollenspiele.dsa
+Date: Wed, 08 Oct 2003 16:07:41 +0200
+Message-ID: <ec48ov0f5mrb47dk6lq22ki4gq9fgfv6ds@4ax.com>
+
+Matthias Haan <dr.ace@gmx.net> schrieb einst:
+
+>http://www.fanwerk.de/spacegothic/bilder/ratcon2003/gross/ratcon117.jpg
+
+... ansonsten ein hochinteressantes Bild - charakterisiert es doch die
+Spezies Rollenspieler auf sehr anschauliche Art und Weise. Selbst die
+roten Augen sind nicht unbedingt fehl am Platze...
+
+Vollschlanke Herren, chipskauende Autogesichter, eisteeschluerfende
+Damen, jeder zweite hat ne Brille und/oder lange Haare, T-Shirts, die
+entweder  Individualitaet ausdruecken sollen (George W. Bush,
+wahrscheinlich mit einem 13373n Spruch drauf) oder von irgendeiner
+Poser-Metal-Band stammen. Umnaechtigt sieht dort so ziemlich jeder aus
+und ist der klassische Gesichtsausdruck eines Hardcore-RPGlers.
+Wichtig: die Quotenfrau (die mit dem Eistee) und ein Quotenschwarzer -
+Rollenspieler zeichnen sich einerseits durch erhoehten Hormonspiegel
+(hervorgerufen von Chicks-in-Chainmail-Covern) und/oder Toleranz aus.
+
+Nicht vergessen sollte man auch, dass wahrscheinlich 80% der
+anwesenden Herren solo sind. Die Quotenfrau dagegen duerfte sich
+entweder ganz wohl  fuehlen (weil sie staendig ueber ICQ, Usenet, IRC
+oder per Mail, denn anders naehert sich ein Rollenspielermaennchen einem
+Rollenspielerweibchen nur ungern, mit allerlei Herren in Kontakt
+getreten wird und somit sich die Besten rauspicken kann) oder
+ausgesprochen unwohl (weil die holde Rollenspielmaennlichkeit sie eben
+per ICQ, Usenet, IRC oder Mail nervt...). Vergeben ist sie auf jeden
+Fall und mindestens jeder dritte in dem Saal verflucht den Kerl, der
+schneller war.
+
+Der vollschlanke Herr mit Bart, der direkt in die Kamera guckt, stand
+wahrscheinlich noch vor fuenf Minuten irgendwo im Weg rum und hat
+Thomas Roemer vollgesuelzt, um ihm entweder:
+a) von seinem Stufe-30-Magier zu erzaehlen, der Borbarad im Alleingang
+besiegt hat und Freizauberer ist. Waehrend des Gespraechs hat sich
+Thomas Roemer gewuenscht, dass Mord nicht strafbar waere.
+b) zu sagen, wie Scheisse DSA ist und dass sich Ulrich Kiesow im Grab
+umdrehen wuerde. Waehrend des Gespraechs hat sich Thomas Roemer gewuenscht,
+dass Mord nicht strafbar waere.
+c) von seinem neuen, eigenentwickelten Chicks-in-Chainmail-RPG
+erzaehlt, in dem sein Char eine Art Gott ist, dem die Chicken huldigen.
+Waehrend des Gespraechs hat sich Thomas Roemer gewuenscht, dass Mord nicht
+strafbar waere.
+Beruflich ist er Dauerstudent der Informatik, ein 13373r (kennt jemand
+die Zahl fuer 'r'?) Hacker und wohnt noch bei Mami in der Dachkammer.
+
+Der schwarzgekleidete Kerl links neben ihm ist dagegen einer jener
+Moechtegernsatanisten. In der RPG-Runde seines besten Kumpels (der
+Vollschlanke von eben), spielt er stets irgendwas maechtig Fieses und
+waehrend des Rollenspiels tun sich wahre Abgruende der menschlichen
+Seele auf. In seinem Zimmer (irgendeine verkiffte WG) riecht es immer
+ein wenig nach Patschouli, er hoert Deine Lakaien und die Welt ist
+einfach schlecht zu ihm. Mama hat ihn schon laengst rausgeworfen und er
+haelt seinem dicken Kumpel vor, wie uncool es doch ist, noch bei Mama
+zu wohnen (dafuer hat der schwarzgekleidete aber auch kein Moped....).
+Frauen verfuehrt er gerne mit irgendwelchen Vampirgeschichten (die Dame
+mit dem Eistee hat ihn in ihrer ICQ-Ignore-Liste unter dem Namen "Lord
+Darkness"). Bevor er in den Saal kam, lag er noch unten in der
+Turnhalle und hat Schlaf nachgeholt, da er die Nacht lang mit spitzen
+Plastikzaehnchen versucht hatte die wenigen anwesenden Damen zu
+beissen... diese waren natuerlich nicht sonderlich davon angetan und
+die Eisteedame hat ihn als perversen Satanisten bezeichnet.
+
+Nun zu einem anderen, typischen Rollenspielerexemplar - die
+Grinsebacke ganz links im Metallica-T-Shirt.
+Der Aermste - er waere gerne hart, bekam aber in der Schule immer eins
+auf die Klappe. Hier jedoch, unter Gleichgesinnten, hat er endlich
+seine Ruhe - es gibt ja noch groessere Trottel als ihn (siehe der
+vollschlanke Kerl von vorhin mit seinem Satanistenkumpel).
+Er ist der liebe, nette Bubi von nebenan und die Eisteedame hatte
+schon Pixelsex bei Ultima Online mit ihm (bis ein boeser M0sch0r
+auftauchte und den Elfenjuengling namens Aragon [man beachte das
+kreative Fehlen des 'r's] den er verkoerperte, niederknueppelte, um sich
+die Eisteedame zu krallen). Zu mehr, als nur Metallica hoeren, hat es
+bei ihm nicht gereicht - das ist schon boese genug. Die Maenner hassen
+ihn, die Frauen moegen ihn oder finden ihn einfach daemlich. Auf jeden
+Fall kriegt er von Mutti, wo er noch waehrend seiner Lehre zum
+Einzelhandelskaufmann wohnt, zum Geburtstag immer Socken und
+Unterwaesche geschenkt. Ist er nicht herzig?
+
+Nun zu Mister Weltkritisch - der Kerl mit dem George-W.-Bush-T-Shirt.
+Ihn kennt man unter so einem Namen wie "Philosoph" in den Newsgroups
+und Diskussionsforen dieser Welt. Er liebt es ueber Politik zu
+philosophieren (zum Studieren reicht es halt nicht) und draengt gerne
+jedem seine Meinung auf. Er ist kritisch... bzw. waere es gerne und hat
+zu jedem Thema was zu sagen, auch wenn er keine Ahnung hat. Er hasst
+Dieter Nuhr.... und noch mehr hasst er die Eisteedame, die sich von
+seinem Gelabere gestern abend nicht beeindrucken liess (immerhin war
+sie auch auf der Flucht vor dem Satanisten mit den Plastikzaehnchen und
+weiter vorne stand ja der suesse Aragon). Ganz gut verstand er sich mit
+dem Vollschlanken - konnten sich die beiden doch wunderbar gegenseitig
+dichtsuelzen. Meist spielt er Kleriker, die auch im Spiel den Spielern
+ihre Meinung aufdruecken oder absolut atheistische Elfen, die stets mit
+einem laessigen "Sanya" auftauchen.
+Er ist der Weltverbesserer und -retter Nr.1 - wenn es nach ihm ginge,
+doch leider reicht es nur fuer die Rolle des Detlefs bei den
+Weltenrettern....
+
+So... das wars erstmal.
+
+Ciao,
+Hilke Greff
+Institut fuer Rollenspielercharakterisierung
+
+-----------------------------------------------------------------------------
+
+
+
+Re: [z-netz.alt.rollenspiele.dsa] Re: Argh! (Miril, 11. Okt 2003, 21:51:10):
+~#! rn=Amaryllis rt=1065894599 rg=schmarrn.netdigest
+~#! tid=1065894599
+Ahja. Interessant. Werd Thomas am Montag mal erzaehlen, was er
+angeblich so alles denkt.
+
+Miril
+
+-----------------------------------------------------------------------------
+
+
+
+Re: [z-netz.alt.rollenspiele.dsa] Re: Argh! (Gralkor, 12. Okt 2003, 08:58:25):
+~#! rn=Amaryllis rt=1065894599 rg=schmarrn.netdigest
+~#! tid=1065894599
+... auf jeden Fall ist der nette vollschlanke Mensch ein wichtigtuender
+Volltrottel
+Gruende: er hat einen FaST-Ausweis (und lt. Nummer von Mitte 2002, also kurz
+vor Aufloesung :) )
+Und FaST ist tot, begraben und fuer immer weg (schade eigentlich, hat gut
+Hobby finanziert ;) )
+G.
+
+-----------------------------------------------------------------------------
+
+
+
+Musik, Linux und HTML (Nonne, 16. Okt 2003, 10:08:26):
+Stefan T. Unterweger tat wo schreiben:
+
+>* Eric-Alexander Schaefer:
+>> >>> vG, der ... dazwischen auch gern Paul Simon hoert...
+>> >> Und ihr wollt echte Maenner [TM] sein? ;-).
+>> > Aechte Maenner[tm] hoeren Hendrix, so wie ich?
+>
+>> Aber nicht doch. Aeschte Maenner hoeren natuerlich Barry Manilow (sp?)!!!1!
+>
+>Aber nicht doch. Echte Maenner[tm] hoeren /dev/random > /dev/dsp in
+>voller Lautstaerke.
+
+Und abends zum einschlafen Debian "Woody", erste CD^W^Wdie Ouvertuere in
+little-endian, op. i386.
+
+Mi'Paul Simon letztes Jahr live in der Berliner Waldbuehne erlebt
+habend'cha
+
+Nonne, kichernd.
+
+-----------------------------------------------------------------------------
+
+
+
+bash.org (Nonne, 18. Okt 2003, 10:59:15):
+* Amuck50 designs some magic items for a D&D campaign
+ <Amuck50> heheh Arrows of Nuking.....
+ <Kyle> Cock ring of glory.
+ <Amuck50> cock ring of +2 protection
+
+Nonne, bastelt jetzt sowas.
+
+-----------------------------------------------------------------------------
+
+
+
+Re: bash.org (Vanion, 18. Okt 2003, 11:12:48):
+~#! rn=Nonne rt=1066467555 rg=schmarrn.netdigest
+~#! tid=1066467555
+http://bash.org/?4848 is auch nich schlecht.
+
+-----------------------------------------------------------------------------
+
+
+
+Endlich! Der Wissenschaft sei Dank! (Ronda, 18. Okt 2003, 19:57:42):
+Bemerkung: Normalerweise werden auf dieser Mailingliste nur ernsthafte
+News gepostet. Ich kenne leider die Quelle dieses Textes nicht, da
+Sven ihn wohl nur weitergeleitet hat.
+
+ Dies ist eine weitergeleitete Nachricht
+Von    : Sven Dosch <SDosch@t-online.de>
+An     : "nuntius" <nuntius@blindzeln.net>
+Datum  : Sonntag, 5. Oktober 2003, 01:42
+Betreff: [NUNTIUS] Neue physikalische Erkenntnis zum Abnehmen
+
+===8<=================== Original Nachrichtentext ===================
+Was noch nie bei Diaeten beruecksichtigt wurde......
+
+Alle bekannten Diaeten vernachlaessigen voellig einen wichtigen Punkt:
+die Temperatur der Speisen und Getraenke.
+
+Wir alle wissen, dass eine Kalorie notwendig ist um 1 g Wasser um 1
+Grad C zu erwaermen. Man muss kein Wunderkind sein errechnen zu koennen,
+dass der Mensch wenn er ein Glas kaltes Wasser trinkt -sagen wir mit 0
+Grad- ca. 200 Kalorien braucht, um es um 1 Grad zu erwaermen. Damit es
+auf Koerpertemperatur gebracht wird, sind also ca. 7400 Kalorien
+notwendig, d.h. 200g Wasser mal 37 Grad Temperaturunterschied. Diese
+muss unser Koerper aufbringen, da die Koerpertemperatur konstant bleiben
+muss. Dazu nutzt er die einzige Energiequelle, die ihm kurzfristig zur
+Verfuegung steht, unser Koerperfett. Es muss also Koerperfett verbrennen,
+um die Erwaermung zu leisten. Denn die Thermodynamik laesst sich nicht
+beluegen.
+
+Trinkt man also ein grosses Glas Bier ca. 400 g mit 0 Grad verliert man
+ca. 14800 Kalorien. Jetzt muss man natuerlich noch die Kalorien des
+Bieres abziehen ca. 800 Kalorien fuer 400 g Bier.
+
+Unter dem Strich betrachtet verliert man also ungefaehr 14000 Kalorien
+bei einem kalten Glas Bier.
+Natuerlich ist der Verlust um so groesser, je kaelter das Bier ist. Ebenso
+verhaelt es sich mit kalten
+Nachspeisen wie Eis zum Beispiel. Bei einer Portion von 200g nehmen
+wir ca. 1000 Kalorien zu uns
+verlieren aber durch die Erwaermung auf Koerpertemperatur 7400 Kalorien.
+Hinzu kommen dann noch ca. 7000 Kalorien zum Schmelzen des Eises, ca.
+35 Kalorien pro Gramm. Richtig betrachtet bleibt also ein Verlust von
+13400 Kalorien. Da der Anteil der Kalorien in Lebensmitteln, im
+Vergleich zu den Kalorien des Waermeverbrauchs nur sehr gering ist, ist
+es also fast egal was wir essen oder trinken, nur kalt muss es sein.
+
+Diese Art Kalorien abzubauen ist wie jedem einleuchten mag viel
+effektiver als z.B. Fahrrad fahren oder Joggen bei denen nur ca. 1000
+Kalorien pro Stunde verbrannt werden. Auch Sex ist mit nur 100
+Kalorien pro Orgasmus gegen kaltes Bier sehr ineffektiv.
+
+Abnehmen ist so einfach. Wir muessen alle einfach nur kaltes Bier und
+Eis in Mengen zu uns nehmen und die Thermodynamik erledigt den Rest.
+Ein Nachteil dieser Diaet bleibt allerdings, wenn wir z.B. eine heisse
+Pizza essen, die uns durch ihre Waermeenergie eine Unmenge an Kalorien
+zufuehrt.
+
+Der aufmerksame Leser hat aber bestimmt schon die Loesung parat: man
+muss die heisse Pizza einfach nur mit genug kaltem Bier und Eis
+ausgleichen.
+
+
+
+
+===8<============== Ende des Original Nachrichtentextes =============
+
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Endlich! Der Wissenschaft sei Dank! (Gloinson, 18. Okt 2003, 23:42:50):
+~#! rn=Ronda rt=1066499862 rg=schmarrn.netdigest
+~#! tid=1066499862
+Naja, der aufmerksame Leser weiss die Vorsilbe "Kilo" zu schaetzen, die selbst
+Ernaehrungswissenschaftler nur allzugern vor irgendwelchen Energieangaben fuer
+Nahrungsmittel vergessen :)
+Jaja, ich stinke weil ich den Witz erklaert habe.
+
+
+-----------------------------------------------------------------------------
+
+
+
+Ok, der IST platt... (Ronda, 19. Okt 2003, 21:01:32):
+... aber schon ganz nett ;-)
+
+From: "Marc F. Neininger" <nospam@champagnierle.de>
+Newsgroups: stgt.general
+Subject: Re: Suche: Autowerkstatt S-Vaihingen
+Date: Fri, 17 Oct 2003 10:10:36 +0200
+Message-ID: <3F8FA3FC.3050901@champagnierle.de>
+
+Michael Schumacher schrieb:
+
+> Einfache Antwort. Die einzige Werkstatt, zu der ich jemals 100%
+> Vertrauen hatte, ist Autoflott in der Katzenbachstr.50
+
+Am Sonntag hast Du bei RTL noch gesagt, Dein Team haette verdient 
+gewonnen und eine Superleistung die ganze Saison ueber gebracht.
+Und jetzt das...
+
+SCNR
+
+Marc
+
+-----------------------------------------------------------------------------
+
+
+
+DAU (Nonne, 20. Okt 2003, 10:23:29):
+Aus Anoymer Quelle:
+Manche Kunden koennen einen echt in den wahnsinn
+treiben:
+
+Kunde fragt an, warum die Webstatistik fuer folgende
+Tage nicht da ist:
+
+31.06.2002,31.11.2002,29.02.2003
+30.02.2003,31.02.2003
+
+Antwort vom Support:
+
+Zu folgenden Tagen,[...]
+muss ich Ihnen erneut mitteilen, dass diese nicht im
+Kalenderjahr vorhanden sind. Aus diesem Grund koennen
+dort auch keine Statistiken abgerufen werden. Bitte
+ueberpruefen Sie diese Tage in einem Kalender.
+
+Es gibt diese Tage nicht!
+--------------------------
+
+Soweit so gut, Antwort des Kunden:
+
+>>>>
+tut mir leid das sie die offensichtlichen probleme
+nicht erkennen koennen.
+
+ich kann nicht nachvollziehen wieso ausgerechnet diese
+tage in ihrem kalenderjahr nicht exestiren zumal an den
+anderen monaten der einundreistigste in den statistiken
+immer erfasst werden. das ist
+wahrscheinlich "systemadministartoren-logik" die mir
+verschlossen bleibt. oder ist das naeher in ihrem
+pdf-handbuch naeher erlaeutert?
+
+wenn ihnen und ihren kollegen der job keinen spass
+macht, dann suchen sich einen neuen aber hoeren sie auf
+auf kosten der kunden ihr
+desinteresse auszuleben.
+
+Nonne, ist sich nicht sicher, ob das wirklich passiert ist.
+
+-----------------------------------------------------------------------------
+
+
+
+Ich ueberlege... (Ronda, 20. Okt 2003, 22:44:40):
+... ob man den Doktor aus der Nachricht hier nicht mal zu einer zuenftigen
+Diskussion in der MPA einladen sollte. Er macht das echt prima und wuerde toll
+in eine kultivierte Schlammsch...Diskussion von Padreic, Anatol, Grimmborn und
+so passen.
+
+Ronda
+
+From: "Dr. Joachim Neudert" <neudert@5sl.org>
+Subject: Re: Un-CD's ueberschwemm en den Markt
+Newsgroups: ger.ct
+Date:Sun, 12 Oct 2003 07:54:18 +0200
+Message-ID: <bmaq8m$k6fvd$1@ID-88484.news.uni-berlin.de>
+
+Martin Rohner schrieb:
+
+> Hallo,
+> 
+>>Es machen aber alle freiwillig mit.
+> 
+> VN>
+> VN>Das gibt ihm noch lange nicht das Recht, mit den Teilnehmern so
+> VN>umzuspringen wie er es tut.
+> 
+> Werden die Leute da gegen ihren Willen festgehalten ?
+> 
+> Gruss Martin
+
+Ja, klar.
+
+Eigentlich wollten die lieber auf ihrer Yacht in Monte Carlo mit den 
+ganzen Chicks Cocktails schluerfen. Als sie aber morgens aufwachten, 
+stellten sie fest, dass sie immer noch in dieser Wohnung im Plattenbau in 
+Gera festsitzen. Weil sie bei kritischer Durchsicht ihrer Moeglichkeiten 
+(Schulzeugnisse, Ausbildung, Verwandschaftsgrad zu Millionaeren und 
+Adeligen) recht verzweifelt wurden, stellten sie fest: Sie wollen es
+versuchen, sie muessen da durch, an Dieter Bohlen vorbei, der sie grillen
+wird.
+
+(ist jetzt gar nicht so ironisch gemeint, wie es rueberkommt: diese armen 
+Wuerstchen in ihrem "pursuit of happiness" tun mir leid, diese 
+willfaehrigen Luser als "freiwillige" Opfer des selbstgefaelligen (warum 
+nur?) Bohlen).
+
+So (Bohlen) kann man es nicht machen. Eigentlich. Aber panem et 
+circensis, das Publikum freuts immer wieder, wenn ein Dilettant eins 
+unter die Guertellinie reingewuergt bekommt. Wird ja nur die Lebensluege 
+zerstoert, irgend jemand muss es machen.
+Natuerlich koennte man die Leute ohne Talent vorher aussortieren. Aber 
+Ziel der Sendung ist ja nicht einen Star zu finden- das ist wertlos und 
+witzlos- (wer hat zuletzt gewonnen? Im Gedaechtnis blieb zurecht nur der 
+Exzentriker Kueblboeck) Ziel ist amuesant zu unterhalten, und schon im 
+Feuilleton liest sich ein Premierenverriss fuer das Kulturpublikum immer 
+amuesanter, als ein Lob...Warum sollten die Proleten es anders sehen?
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Die Auktion (Amaryllis, 25. Okt 2003, 12:05:48):
+From: Hans-Georg Bickel <hgbusenetmuell@gmx.de>
+Newsgroups: de.rec.tv.lindenstrasse
+Subject: Re: Die Auktion
+Date: Tue, 21 Oct 2003 00:10:06 +0200
+Message-ID: <bn1mlm$sbgd7$1@ID-108823.news.uni-berlin.de>
+
+Hartmut 'Hardy' Schiszler <schiszler@web.de> wrote:
+
+>Hardy, was machen einklich Frauen in Newsgroups?
+
+Das sind die Auswirkungen der Bildungsmisere. Frueher erhielten
+die Maedchen noch soliden Handarbeitsunterricht und vertrieben
+sich die Freizeit mit Stickereien, Stricken oder Naehen. Dabei
+wurden bleibende Werte geschaffen, die auch fuer die Aussteuer
+Verwendung finden konnten.
+
+Heute kann das kaum noch eine Frau und so bleibt ihnen nichts
+anderes uebrig, als zur Zerstreuung in Newsgroups zu posten.
+
+HG,
+Grundkapital schaffend.
+
+-----------------------------------------------------------------------------
+
+
+
+Nix fuer Kids: Apparat - Maschine - Geraet (Ronda, 31. Okt 2003, 01:07:52):
+
+Praegnant. Echt.
+
+
+From: Bjoern Schreiber <usenet-oktober@bjoernschreiber.de>
+Subject: Re: Kaffeemaschine Philips Senseo
+Newsgroups: de.alt.fan.aldi
+Date: Tue, 28 Oct 2003 21:36:18 +0100
+Message-ID: <bnmk08$os3$1@nets3.rz.RWTH-Aachen.DE>
+
+Nico Lubitz schrieb am 28.10.2003 20:12:
+>"Murat Urkan" <Murat.Urkan@gmx.de>  wrote:
+>
+>
+>>Bei meiner "Espressomaschiene" macht mich das
+>>eher nervoes.
+>>
+>>Die "" sind, weil es keine Maschiene ist... 
+>
+>
+>Sondern eine Maschine?
+
+[klugscheiss]
+Nein, ein Apparat. Maschinen setzen naemlich nur energie um, ein Apparat 
+setzt Stoff um (waehrend ein Geraet Signale umsetzt)
+[/Klugscheiss]
+
+Kaffemaschinen sind ein Liebslingbeispiel fuer Ablaufdiagramme...
+
+Dein Doedel ist z.B. alles gleichzeitig:
+
+Nach erfolgreichem Betrieb bist Du ziemlich platt, Deine Partnerin aber 
+gerade ziemlich heiss ;-):
+Energie uebertragen -----> Maschine
+
+Eine gewisse Fluessigkeit wurde vom einfachem Koerpersekret als 
+eventueller Alimenteerzeugungssaft eingesetzt:
+Stoff uebertragen -----> Apparat
+
+Du hast sicherlich etwas gespuert:
+Signal uebertragen -----> Geraet
+
+(ok, *das* Beispiel steht nicht im Vorlesungsumdruck....)
+
+Theoretisch wuerde man sich jetzt eins von den drei Sachen aussuchen, um 
+Deinen Doedel entgueltig zu klassifizieren. Fuer Deine Perle ist er 
+entweder eine Maschine, weil mal wieder nicht genug Ausdauer (Energie) 
+da war oder ein Apparat, weil sie gewisse Plaene betreffs gewisser 
+weisser Kleider, Ringen, Kombiautos und viel Geschrei hat.
+
+Fuer Dich als "End User" ist er natuerlich ein Geraet. Worum sollte es auch
+sonst gehen.
+
+
+scnr
+
+
+Bjoern, standhaft ingenioese Klischees zu erfuellen versuchend. Hab heute 
+sogar ein Karohemd angehabt. Seit zwei Jahren zum ersten Mal.
+
+-----------------------------------------------------------------------------
+
+
+
+Damit die Aufmerksamkeit an de.alt.netdigest nicht schwindet... (Ronda, 31. Okt 2003, 01:13:19):
+Fuer Betroffene vermutlich kaum witzig - aber das duerfte ihrer Aufmerksamkeit
+recht bald entgehen.
+
+Ronda
+
+[Submitter's Note: ADS steht fuer Aufmerksamkeits-Defizit-Syndrom;
+ Zeilenumbrucxh repariert]
+
+Subject: Re: Vorschlag: Einrichtung von de.alt.soc.ads
+Date: Tue, 28 Oct 2003 15:20:41 +0100
+From: "Mario Jung" <spamgetlost@nurfuerspam.de>
+Newsgroups: de.alt.admin
+
+Volker "Darkon" Riehl schrieb:
+
+>> de.alt.soc.ads
+>
+> Hmmm... haben die Vorschlagenden das Interesse an der Gruppe verloren,
+> oder warum kommt so lange nichts mehr?
+
+Du kennst wohl ADS nicht :-)
+
+mario
+
+-----------------------------------------------------------------------------
+
+
+
+Ganz schoen dunkel hier... (Foobar,  4. Nov 2003, 19:50:45):
+[SN: Es ging um die Frage, warum Dynamolicht vorgeschrieben ist und
+keine Batterien/Akkus verwendet werden duerfen. Gek|rzt.]
+
+From: Wolfgang Strobl <wks000@t-online.de>
+Newsgroups: de.rec.fahrrad
+Subject: Re: Vorgestern abend, Innenstadt
+Date: Sun, 02 Nov 2003 22:46:07 +0100
+Message-ID: <hitaqvgcrrvqu6ag9eusqk3uegq8rmfhei@4ax.com>
+
+Andreas H|nnebeck <ah@despammed.com>:
+
+>Akkus und Batterien koennen leer werden, wenn man unterwegs wird.
+
+Nein, das ist nicht die offizielle Begr|ndung, das ist daf|r noch nicht
+dumpf genug. Die Zeitschrift "Radmarkt" fragte einen
+Ministerialbeamten, warum an dem Verpflichtung, eine
+Beleuchtungseinrichtung auch tags|ber mitzuf|hren festgehalten w|rde,
+und zitierte ihn mit der Antwort, daw|rde, man ja jederzeit mit "pltzlich
+hereinbrechender Dunkelheit" rechnen m|sse. Auf ein konkretes Beispiel
+angesprochen nannte er dann eine Sonnenfinsternis.
+
+-----------------------------------------------------------------------------
+
+
+
+Akzent (Foobar,  6. Nov 2003, 20:38:01):
+ From: Martin Hoefs <hoefs@web.de>
+ Newsgroups: de.rec.tv.misc
+ Subject: Re: ISH pack mir ann Kopp...
+ Message-ID: <bobguk$1cqfdi$1@ID-128081.news.uni-berlin.de>
+ Date: Wed, 05 Nov 2003 19:51:28 +0100
+
+ Hallo,
+ Andreas Mauerer schrieb:
+ >>Der Gipfel: Tagsueber lauuft 9Life, nachts nach 2 Uhr ARTE. Wie
+ >>sinnreich!
+ > 
+ > Schau mal, wie die knappen Antennenfrequenzen in Hamburg verteilt sind:
+
+ Tja, halt sich alles irgendwie erledigt, da ISH ARTE komplett aus
+ meinem Kabelnetz genommen hat ...
+
+ NB: Welch' Unterschied in den Hotlines von ISH und ARTE:
+
+ Bei ISH Ilsa, She-Wolf of the *hust*:"WATT? Kein ARTE? KANN NICHT
+ SEIN!1! Kann ich Ihnen nicht helfen!!1 Wiederhoern!<knacks>"
+
+ Bei ARTE eine Franzoesin mit ungeheuer erotischem Akzent:"Oh 'err
+ 'oefs, das freut 'uns saehr, daz Sie uhns vermissaen! Unsere Justiz-
+ abteilung ist schon 'unterwegs zuer Lohndesmaedienanstahlt.[1]"
+
+ Gruss, Martin
+
+ [1]Ich war wohl nicht der einzige, der sich beschwert hatte.
+
+
+-----------------------------------------------------------------------------
+
+
+
+[de.etc.bahn.bahnpolitik] Re: Getraenkeautomaten in ICE's ? (Deepblue, 10. Nov 2003, 20:24:27):
+From: hweede@snafu.de (Henning Weede)
+Newsgroups: de.talk.tagesgeschehen,de.etc.bahn.bahnpolitik
+Subject: Re: Getraenkeautomaten in ICE's ?
+Date: 9 Nov 2003 20:07:48 GMT
+Message-ID: <bom6qk$1f7a88$1@uni-berlin.de>
+
+"anatoli derimba" <nospam@rumbudu.net> writes:
+
+>Wieso gibt es keine Getraenkeautomaten im ICE, wo man auch mal eien
+>Cola fuer 50Cent kaufen kann anstatt fuer das 5-fache beim Schaffner?
+
+Weil damit folgendes Erlebnis nicht mehr geht:
+
+Ich war mal geschaeftlich in Holland, mit der Bahn statt zu fliegen,
+weil ich unterwegs dringend arbeiten musste. Der Termin war super
+gelaufen, Kunde sehr zufrieden, und das wollte ich auf der
+Rueckfahrt im ICE ein wenig begiessen. Mit einem Bier. Der Schaffner
+kam also vorbei und fragte mich, ob ich etwas trinken wolle, also
+bestellte ich ein Bier. Man sah ihm unschwer seine tuerkische
+Abstammung an, warum auch nicht. Als er zurueckkam, brachte er
+mir eine gelbliche, schaeumende Fluessigkeit, und gleichzeitig las ich
+das Namensschild auf seiner Brust: "Herr Uerin".
+
+Henning
+
+-----------------------------------------------------------------------------
+
+
+
+Wartung einer Kristallkugel (Amaryllis, 10. Nov 2003, 21:01:35):
+Von: Andreas Lobinger (Andreas.Lobinger@netsurf.de)
+Newsgroups: de.sci.electronics
+Betrifft: Re: Rechtecksignal im Ultraschallbereich erzeugen ? 
+Datum: 2002-04-11 08:06:09 PST 
+Message-ID: <3CB5A64D.619D7571%40netsurf.de>
+
+
+Aloha,
+
+Uwe Hercksen schrieb:
+> Kurt Harders schrieb:
+> > Sorry, meine Kristallkugel ist gerade zur Wartung.
+> was wartet man denn an einer Kristallkugel?
+> Ist sie blind geworden und muss neu poliert werden? 
+
+Polieren kann man auch mal selber machen, ausserdem kommt das eh erst am
+Schluss.
+
+Ich lass so alle Jahreszeitenwechsel mal auswuchten, d.h. die Gut-Boese
+Balance 
+neu einstellen. Wobei ich sie einen Tick mehr Richtung Vergangenheit-Gut 
+Zukunft-Boese vorstellen lasse. 
+
+Dann natuerlich den Geradeauslauf testen. Du nimmst ein paar
+unabaenderliche 
+Tatsachen und schaust, ob die in 3,6,12,24 Monaten immer noch zu sehen
+sind.
+
+Im Gegenzug auch die Kurvenlage, d.h. Uebergange von Meinungen in
+Tatsachen und
+umgekehrt. 
+
+Dann noch zur Abnahme in eine Eich-Realitaet. Mein Wartungsteam nimmt da
+eine 
+vollstaendig-vorhersehbare, es geht aber auch mit einer
+vollstaendig-bekannten. 
+
+Stempel ins Serviceheft nicht vergessen. Wer schon mal die ISO-9001
+Truppe
+im Haus hatte, weiss warum. Polieren, verpacken. 
+
+Und wer noch eine Kurzzeitzweitkugel sein Eigen nennt, kann sie dann dem 
+Postmann direkt aus der Hand engegennehmen.
+
+Ich lasse das alles von einem Team in der Naehe machen - ihr wisst ja wo
+-
+nachdem ich vom Verschwinden eines Freundes erfahren hatte, der eine
+in der eigenen Garage eingestellte Kugel im Auto als Navigationssystem
+benutzen wollte.
+
+Einen froehlichen Tag wuenschend
+  LOBI
+
+
+
+-----------------------------------------------------------------------------
+
+
+
+Betrifft:Akku aufladen (Apophis, 12. Nov 2003, 15:18:11):
+ 
+Von:Guenni W (Guenni@postmaster.co.uk)
+Betrifft:Akku aufladen 
+View: Complete Thread (20 Beitraege)  
+Original Format 
+Newsgroups:de.comm.geraete.mobil.nokia
+Datum:2001-07-23 16:05:04 PST 
+ 
+
+ich habe hier ein Akku wo draugfsteht das man ihn 14 Stunden aufladen mus mit 
+55mA. Mit 165mA geht es in 4 Stunden. Das mueste doch auch mit dem Handy Akku
+gehn 
+wenn das Ladegeraet nicht so lahm ist. Warum ueberhaubt dieser Verlust ? Aus
+meinem 
+Sicherungskasten kommen 16 A. das steht drauf und auf mein Ladegeraet kommen
+nur 
+25 mA . Z.b. bei mein Nokia dauert das aufladen 4 Stunden mit 25 mA. Wenn es
+mit 
+16 A gehen wuerde dann dauert es viel schneller. Man kann es ganz einfach mit
+dem 
+Dreisatz ausrechnen.
+1 A = 100 mA
+25mA = 2,5 A
+2,5 A = 4 Stunden laden
+16 A = 0,625 Stunden
+also 6,25 Minuten
+4 Stunden laden neft total. Ich kenne einen der sagte man kann vielleicht was
+am 
+Ladegeraet umloeten. wie geht das ? Ich krige es nicht mal auf.
+
+
+-----
+
+noch mehr von diesem Spezialisten gibts hier:
+http://tinyurl.com/up0c
+http://tinyurl.com/up0f
+
+apophis :)
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Betrifft:Akku aufladen (Grimmborn, 12. Nov 2003, 15:24:25):
+~#! rn=Apophis rt=1068646691 rg=schmarrn.netdigest
+~#! tid=1068646691
+Argh. Vor allem der Dreisatz haut mich ja aus den Latschen. Wofuer eigentlich
+einen PISA-Test, wenn das usenet zur Beurteilung ausreicht?
+
+GdA
+
+-----------------------------------------------------------------------------
+
+
+
+[de.comp.os.unix.linux.moderated] Re: Module laden in 2.6 (Deepblue, 12. Nov 2003, 20:09:22):
+Subject:Re:Moduleladenin2.6
+From:FrankKuester<frank@kuesterei.ch>
+Newsgroups:de.comp.os.unix.linux.moderated
+Date:Wed,5Nov200312:09:17+0100
+
+Markus Raab <markus.raab@aon.at> schrieb:
+
+> Joerg Sommer wrote:
+>
+>> The UNIX Guru's View of Sex:
+>> # unzip ; strip ; touch ; finger ; mount ; fsck ; more ; yes ; umount
+>> # ; sleep
+>
+> fsck nach mount ist aber boese!
+
+Ach Quatsch. Davon wird in Wirklichkeit nur abgeraten, weil dann die
+Festplatte einige Wochen lang kotzt und anschliessend immer voller und
+dicker wird. Wenn man es 9 Monate durchgehalten hat, gibt es viele
+kleine Festplaettchen.
+
+Fra'Und das ist gut so'nk
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Betrifft:Akku aufladen (Ark, 13. Nov 2003, 19:36:35):
+~#! rn=Apophis rt=1068646691 rg=schmarrn.netdigest
+~#! tid=1068646691
+Hm, wenn ich jemanden wirklich loswerden will, kann man den Sicherungskasten
+nehmen ... mal sehen, wo steht der? :-)
+
+
+              *** ARK * the * Magnificent ***
+
+
+-----------------------------------------------------------------------------
+
+
+
+[de.admin.news.regeln] Re: Duerfen kleinstminderheiten eine Mehrheitsentscheidung blockieren? (Deepblue, 14. Nov 2003, 20:13:00):
+From: Werner Jakobi <readbutspamfiltered@morver.de>
+Newsgroups: de.admin.news.regeln
+Subject: Re: Duerfen kleinstminderheiten eine Mehrheitsentscheidung
+blockieren?
+Date: Tue, 11 Nov 2003 22:42:52 +0100
+Message-ID: <borolc.kk.1@jakobi-28216.user.uni-berlin.de>
+
+Sebastian Hirschmann <Seb.Hi@gmx.de> posted:
+
+>Um von der Polemik wieder etwas wegzukommen: H. blockiert und
+>verhindert sinnvolle und wichtige Veraenderungen durch sein
+>Verhalten, das meine ich mit "Amoklauf".
+
+Ach wo. Haeuser bauen, Kinder kriegen und neue Gruppen einrichten dauert 
+halt etwas. Von den dreien kommen nur Kinder manchmal vorzeitig.
+
+Gruss, Werner
+
+-----------------------------------------------------------------------------
+
+
+
+la-concha.de (Foobar, 17. Nov 2003, 20:11:19):
+
+ [Quoting ergaenzt.]
+
+ From: Rainer Kersten <rainerkersten@t-online.de>
+ Newsgroups: de.alt.recovery.webauthor
+ Subject: Re: Profi Journalisten
+ Date: Sat, 15 Nov 2003 00:41:09 +0100
+ Message-ID: <3FB56815.9050402@t-online.de>
+
+ Michael Praast wrote:
+
+ > "Irmgard Schwenteck" <nixspam@4haus.de> schrieb:
+ > >Ein Hundebaby lehrt man, dass es sein Pflicht im Leben ist,
+ > >einen Menschen zu finden, dem es dient und den es liebt.
+ > >Ein Kaetzchen lehrt man, einen anpassungsfaehigen und liebevollen
+ > >Sklaven zu finden, der auf Freundlichkeiten reagiert. (Pam Brown)
+
+ > Das erklaert, warum bestimmte Koerperregionen von Frauen als Muschi
+ > (auch gern genommener Kosename fuer Katzen) betitelt wird und
+ > warum Frauen Maenner manchmal als dummen Hund schimpfen.
+ > Und Frauen luegen bekanntlich nie, sie erfinden die Wahrheit.
+
+ Nungut. Ich denke, jetzt muss ich die Geschichte doch mal hier ertippen.
+
+ Ende 2002 reiste ich ein europaeisches Land, in dem ziemlich viel 
+ spanisch gesprochen wird. In der Hoffnung, dort Kunden zu finden, 
+ und im Wissen, dass Domain-Registrierung dort ziemlich teuer ist, 
+ reservierte ich mir schonmal auf Verdacht die Domain la-concha.de
+ "Concha"[span.] = Muschel. Ausserdem ist "La Concha" der bekannte 
+ Name einer weltberuehmten, muschelfoermigen Bucht, an der eine 
+ Grossstadt liegt.
+
+ Ich fuehlte mich gut vorbereitet.
+
+ Das Risiko, dass Kunden mit Auftraegen drohen koennten, wurde 
+ Realitaet. U.a. brauchte eine vornehme Dame WWW-Seiten. Der Mensch, 
+ in dessen Auftrag ich htmlisieren sollte, kann feilschen wie ein 
+ Dotcomm-CEO zwei Minuten vor dem Konkurs. Nun gut. Kann ich auch.
+
+ Also frag ich ihn erstmal, ob es ihm Recht sei, wenn wir aus 
+ Kostengruenden auf die Reservierung einer Domain verzichten. Ich 
+ haette da was.
+
+ Ich: la-concha.de
+
+ Er: Ja wie?
+
+ I: Nix ja wie. Is ne .de-Domain, die ich fuer solche Faelle vorhalte.
+
+ E: La Concha?
+
+ I: Ja. Wie die Bucht da draussen. Kennse doch!
+
+ Er fing so komisch an zu grinsen.
+
+ I: labindestrichconchapunktde. Was gibt es denn da zu grinsen?
+
+ E: Und was machen wir dann damit?
+
+ I: Machen wir schlicht einen Ordner mit dem Namen der guten Frau 
+ dahinter.
+
+ E: Nee, ne? Wie saehe denn dann die URL aus?
+
+ I: Is doch klar! labindestrichconchapunktdeschraegstrich<name>
+
+ Er rennt bruellend vor Lachen aus dem Bau. Anwesende Kunden und 
+ Kollegen gucken ihm verbluefft hinterher. Und dann ziemlich komisch 
+ auf mich. Ich zucke die Schultern. "Keine Ahnung, was er hat."
+
+ Irnkwann kommt er zurueck, kichert immer noch vor sich hin, und 
+ genehmigt das. Wurde dann auch so gemacht und veroeffentlicht.
+
+ Nach ein paar Tagen ging es mir auf den Keks, dass er jedes Mal 
+ schallend anfing zu lachen, wenn er mich sah. Also habe ich mal 
+ jemand anderen gefragt, ob ich da vielleicht eventuell 
+ moeglicherweise eine Pointe verpasst haben koennte.
+
+ "Jau", sagt er, "hast Du. 'Concha' heisst nicht nur 'Muschel', 
+ sondern umgangssprachlich auch 'Muschi'."
+
+ Die URL, ganz normal gelesen, war also: "La Concha de <name>"
+
+ Volltreffer!
+
+ Ich fragte ihn natuerlich, warum in beim heiligen W3C er das denn 
+ genehmigt haette? "Och", sagt er, "die Dame is so vornehm, die weiss 
+ das nicht."
+
+ Stimmt. Ihr ist das nicht aufgefallen. Aber drei Monate spaeter hat 
+ es ihr jemand gesteckt. Ich bin froh, dass ich sicherer Entfernung 
+ sass, als sie mit einem Rudel Freundinnen seinen Laden stuermte. 
+ Immerhin konnte sein (nicht-spanischer) Boss die Dame glaubhaft 
+ davon ueberzeugen, dass er das auch nicht wusste.
+
+ Er rief dann an: "Wir brauchen gaaaanz dringend ne ordentliche Domain!"
+
+ Nein. Gefeilscht hat er diesmal nicht.
+
+
+-----------------------------------------------------------------------------
+
+
+
+Aus alt.comp.programming (Mupfel, 19. Nov 2003, 23:11:21):
+From: Albert Hendriks <nospam_appiehendriks@hotmail.com>
+Newsgroups: alt.comp.programming
+Subject: Linux: help!
+
+Tomorrow will very probably be the first day at my new job. The problem is:
+They are working with Linux. The linux tutorials I find on google are about
+installing Linux or what commands to use, but I don't have to do that I
+just want to know basic things like:
+
+How do I start Internet Explorer (just to give you an expression of my
+Linux knowledge ;)
+How do I start and use "Windows Explorer"?
+How do I search in and for files?
+How do I edit a file?
+How do I upload a file with what (ftp) program?
+What are the equivalents for CTRL+Z,X,C,V and S?
+How do I reset the computer (CTRL+ALT+DEL)?
+Are there other important things I need to know (Things like "Linux does
+not support a mouse" or whatever)?
+
+Yeah that should about cover the first couple of days.
+I will be creating PHP files with Javascript, MySQL etc.
+
+-mupfel-
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Aus alt.comp.programming (Muadib, 20. Nov 2003, 10:15:39):
+~#! rn=Mupfel rt=1069279881 rg=schmarrn.netdigest
+~#! tid=1069279881
+mit einem wort hier hat man einen menschen der so gut wie nichts von linux
+weiss, ein unbeschriebenes blatt papier, einen willigen eleven, einen
+potenziell ueberzeugten; schade dass man wohl nur witze auf seine kosten
+machen wird anstatt die chance zu nutzen :)
+
+-----------------------------------------------------------------------------
+
+
+
+Frauen und Maenner (Nonne, 24. Nov 2003, 10:13:57):
+Note: Quoting von Vorposter aufgrund von Sinn- und 
+Zusammenhangslosigkeit entfernt.
+
+From: Marcel Weiher <marcel@cs.tu-berlin.de>
+Newsgroups: de.talk.romance
+Subject: Re: "Die Geschichte wiederholt sich immer wieder und ich will 
+schon
+nicht mehr"
+Date: 16 Nov 2003 20:17:10 GMT
+Message-ID: <bp8m06$t2k$3@news.cs.tu-berlin.de>
+
+Habe letztens was lustiges dazu gelesen:
+
+Frauen wollen ihre Maenner wie Kaffee:stark,dunkel
+und heiss.
+
+Dann giessen sie Milch rein, damit er nicht so dunkel
+ist, Zucker damit er nicht so stark ist und schliesslich
+pusten sie noch damit sie sich nicht verbrennen.
+
+Und meckern dann ueber die lauwarme Bruehe.
+
+War uebrigens von einer Frau...
+
+:-)
+
+Marcel
+
+Nonne, kichert.
+
+-----------------------------------------------------------------------------
+
+
+
+Plural (Maarg, 25. Nov 2003, 19:48:17):
+From: Volker Gringmuth <einklich@gmx.net>
+Subject: Re: S: Karikatur zum Thema "Sexistische Pluralformen"
+Newsgroups: de.etc.sprache.deutsch
+Date:Fri, 14 Nov 2003 20:35:30 +0100
+Message-ID: <bp3eah.3vvl88f.1@h1.einklich.net>
+
+
+Dirk Kraemer (Dirk_Kraemer@gmx.de) wrote:
+
+> Verfuegt jemand von euch ueber eine Karikatur, die diese Form von
+> sprachlichen Sexismus auf den Punkt bringt?
+
+Die schoenste mir bekannte Karikatur dazu ist nicht grafisch, sondern
+rein textlich - ich habe sie hier unter der Bezeichnung "frauengerechte
+Bibeluebersetzung" schon des oefteren zitiert.
+
+"Jeder und jede, der oder die von diesem Wasser trinkt, den oder die
+wird wieder duersten; jeder und jede aber, der oder die von dem Wasser
+trinken wird, das ich ihm oder ihr gebe, den oder die wird nicht mehr
+duersten in Ewigkeit, denn das Wasser, das ich ihm oder ihr geben werde,
+wird in ihm oder ihr zu einer Quelle ..."
+
+Haette Jesus tatsaechlich so gesprochen, die Frau haette den Jakobsbrunnen
+mit hysterischem Geschrei verlassen. Seine Wertschaetzung gegenueber der
+Frau bestand in der Tatsache, dass sie ihm als Person wichtig war, und
+nicht in seiner Grammatik. Und das koennte einklich auch heute noch so
+sein ...
+
+
+-----------------------------------------------------------------------------
+
+
+
+mal was ganz altes (Anthea, 27. Nov 2003, 12:38:09):
+Subject: Re: tilde
+Date: Sun, 18 Jan 1998 23:55:42 -0500
+From: Krogg <krogg.no.to.spam@inspace.net>
+Organization: PDN/Chatlink
+Newsgroups: alt.ascii-art
+
+[...]
+Obasciiandanechdote:
+I saw this idea somewhere when i was a teen.And i used to leave all the
+apples in the computer room at school with this little progie on it at
+the end of my programming class.No need for a disk its so small.
+
+.***---------.
+|.***-------.|
+||      IQ              ||
+||     Quiz             ||
+|| What is the          ||
+|| abbreviation         ||
+|| for "mountain"       ||
+||?_                    ||
+||                      ||    )
+||                      ||   (
+|'***-------'| .-------.
+|&Apple ii/e       [| ]  | | [___]'|
++***---------+ +-------+
+
+no matter what the user puts in
+it displays:
+
+.***---------.
+|.***-------.|
+||                      ||
+||                      ||
+||     WRONG!!!!!       ||
+||                      ||
+||                      ||
+||                      ||     )
+||                      ||   )(   )
+||                      ||  (  ) (
+|'***-------'| .-------.
+|&Apple ii/e       [| ]  | | [___]'|
++***---------+ +-------+
+
+Waits a few secs then displays:
+.***---------.
+|.***-------.|
+|| "mountain" is        ||
+||  correctly           ||
+||  abbreviated         ||
+||  "Mt."               ||     )
+||                      ||    (  (
+||                      ||  (  )  )
+||                      ||   )(( (
+||                      ||  (  )) )
+|'***-------'| .-------.
+|&Apple ii/e       [| ]  | | [___]'|
++***---------+ +-------+
+waits 10 secs then displays:
+.***---------.
+|.***-------.|        :
+||       "Mt"           ||   :
+||Place your finger     ||      :
+||on your head and      ||   :     :
+||repeat "Mt." 3 times. || : :  :  :
+||                      || : ): : ::
+||                      || )((: )::)
+||                      ||(  ))(( ((
+||                      || )(( )))((
+|'***-------'|(.-------.)
+|&Apple ii/e       [| ]  | | [___]'|
++***---------+ +-------+
+It again waits like 10 secs and
+the displays:                   :    :     .:
+.***---------.    .   :     :
+|.***-------.|   :   :   .
+||    Your right,       ||  :  . :  :
+||     Your head        ||    .:. :
+||      IS empty!!!!    || : :(::.: :
+||                      ||  :.)):.::
+||                      ||  :(((::.(
+||                      || ::))))::))
+||                      || (:((((((((
+||                      || )))))))))))
+|'***-------'|(.(((((((((
+|&Apple ii/e       [| ]  | | [___]'))
++***---------+ +-------(
+
+It was so cool to watch someone acutualy do it.
+I actualy saw the teacher try it,and fall for it!!!!
+
+
+-----------------------------------------------------------------------------
+
+
+
+Superhitparade der Volksmusik oder so... (Ronda,  2. Dez 2003, 23:13:55):
+Hm. Irgendwie erinnert mich das an den Kollegen, der jetzt 14 Tage auf engstem
+Raum mit den "Drei jungen Tenoeren" verbringen darf... muss ich da Mitleid
+haben?
+
+Ronda *nachdenklich*
+
+From: Olaf Kaluza <olaf@criseis.ruhr.de>
+Newsgroups: de.etc.fahrzeug.auto
+Subject: Re: Mercedes ruestet ab
+Date: Sun, 30 Nov 2003 21:27:12 GMT
+
+Dirk Salva <dsalva@gmx.de> wrote:
+
+ >Und diese ganzen neumodischen Abkuerzungen machen aus einem schlechten  
+ >auch keinen guten Fahrer oder aus einem schlechten ein Fahrzeug mit gutem  
+ >Fahrwerk. Auch das Fahrerverhalten bei Vollbremsung mit ABS will trainiert 
+ >werden, ein ungeuebter Fahrer kann IMO genausogut auf ABS verzichten, weil 
+
+Ich habe eine super Idee! In den Prospekten fuer neue Wagen kommt noch
+folgendes als Option.
+
+[ ] FST-System 500Euro 
+
+Da eh kaum jemand weiss was ABS und ESP usw. bedeuten werden die Leute
+es einfach kaufen ohne zu wissen was es ist. Hauptsache der Nachbar
+hat es noch nicht.
+
+Und sobald die Leute dann den Wagen einen Monat haben ruft jemand an
+und nennt ihnen  den Termin des mitgekauften Fahrer-Sicherheits-Training. 
+Tja, und damit haben wir sie im Sack. :-]
+
+ >mehr und rationeller moeglich sein werden (und dann auch gnadenlos verbaut 
+ >werden) sorgen nur fuer noch daemlichere Autofahrer.
+
+Dagegen hilft dann:
+
+[ ] AIQT-System [400 Euro]
+
+Automatischer Intelligenz Quotienten Test vor dem Start des
+Motors. Wird aber nicht an Leute ueber 60 verkauft da die nach
+einmaligen Genuss der 'Superhitparade der Volksmusik' den Wagen nicht
+mehr starten koennten.
+
+Olaf
+
+-----------------------------------------------------------------------------
+
+
+
+PC fuer Hardware (Ronda,  2. Dez 2003, 23:26:35):
+Oh Gott. Nach "Freedom Fries" nun auch noch das?
+
+Ronda *verzweifelt ein ganz bisschen an den USA...*
+
+Ps: Ja, ich habe den Artikel verstanden ;-) Ich verzweifel nur am
+Originalzitat...
+
+From: Juergen Ernst Guenther <muftix@rrr.de>
+Newsgroups: de.alt.sysadmin.recovery
+Subject: Re: Meister und Sklaven
+
+Kurt Bernhard Pruenner <9sjs4p001@sneakemail.com> wrote:
+> Nils Kassube wrote:
+>> Los Angeles officials have asked that manufacturers, suppliers and
+>> contractors stop using the terms "master" and "slave" on computer
+>> equipment, saying such terms are unacceptable and offensive.
+
+> Laesst sich ja leicht loesen, das Problem:
+
+> http://ars.userfriendly.org/cartoons/?id=20031130
+
+Und die Organisationsstruktur eines Plattenbusses
+wird nicht mehr bestimmt, sondern in einem Treibergremium
+ausdiskutiert. Das zentrale Gremium organisiert sich bei jedem
+Bootvorgang, wobei der jeweils aelteste aktive Treiberbaustein
+die Aushandlung einleitet.  Auch antwortet nicht mehr die Platte,
+die angesprochen wurde, sondern jede, die meint, etwas beitragen
+zu koennen, erhaelt anteilig Datenbuszeit, garantiert ist das natuerlich
+nur fuer Majoritaetsplatten, die eigenen Fraktionsstatus geniesen.
+Die Aufgabe der jeweils nicht majoren Platten ist es, die Antworten
+der majoren Platten als unbrauchbar und korrumpiert anzuzweifeln.
+
+Um die Ausgewogenheit zu gewaehrleisten, gibt es einen
+Antidiskriminierungstreiber, einen Datenschutztreiber
+und einen Lobbytreiber fuer jede organisierte Bauteilgruppe,
+die Beitraege von einzelnen Plattenclustern forcieren oder
+unterdruecken koennen.
+
+Neben den allgemeinen Daten und Steuerbussen gibt es zwischen
+den Gremien zur Informationsgenerierung noch diverse
+Presseagenturbusse, die in einer grosser Zahl lokaler
+Busse muenden, die die Monitorinformation jeweils mit kleinen
+redaktionellen Aenderungen weitergeben.
+
+   .m.
+
+-----------------------------------------------------------------------------
+
+
+
+Es verwundert... (Ronda,  2. Dez 2003, 23:34:23):
+... irgendwie kaum, dass diese Frage aus einer Microsoft-Newsgroup kommt,
+oder?
+
+Ronda *MPA/News/Mail-abarbeitend*
+
+[Quoting repariert]
+
+From: "Dieter Paulsen" <depau@freenet.de>
+Subject: Re: Tastaturprobleme
+Newsgroups: microsoft.public.de.german.windowsxp.hardware
+Date: Wed, 26 Nov 2003 13:32:52 +0100
+Message-ID: <bq26h8$1tfkr4$1@ID-52295.news.uni-berlin.de>
+
+"stern" <anonymous@discussions.microsoft.com> schrieb im Newsbeitrag
+
+> Wenn ich mein Notesbook anzuende funktionieren di Tasten:
+> g, h und backspace manchmal nicht. Ich muss den Notesbook
+> meistens mehrmals abloeschen und neu anzuenden, damit es
+> wieder funktioniert. Was koennte das Problem sein?
+
+mal mit normalem Einschalten versuchen, ist auch billiger ;-))
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Es verwundert... (Gloinson,  3. Dez 2003, 05:15:06):
+~#! rn=Ronda rt=1070404463 rg=schmarrn.netdigest
+~#! tid=1070404463
+Arr. Harr. Harr. Harr.
+
+Wenn man beruecksichtigt, dass der Fragende sicherlich nicht Deutsch spricht
+liegt die Komik entweder im Uebersetzungprogramm oder in der innovativ
+lustigen Antwort.
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Es verwundert... (Darklor,  3. Dez 2003, 09:58:40):
+~#! rn=Gloinson rt=1070424906 rg=schmarrn.netdigest
+~#! tid=1070404463
+Aber eine gewisse Komik kann man dem nicht absprechen
+
+Darklor
+
+-----------------------------------------------------------------------------
+
+
+
+[de.alt.fan.tolkien] Re: [Semi-OT] Wenn Deutschland Mittelerde waere... (Amaryllis,  4. Dez 2003, 22:28:30):
+Message-ID: <bqksq4.194.1@abi03sgo.news.arcor.de>
+From: Till Potinius <Till_Potinius@abi03sgo.de>
+Newsgroups: de.alt.fan.tolkien
+Subject: Re: [Semi-OT] Wenn Deutschland Mittelerde waere...
+Date: Wed, 03 Dec 2003 14:43:16 +0100
+
+Andreas Cammin schrieb folgendes:
+
+> Bei Mordor bin ich mir nicht ganz sicher ob ich es nach Bayern oder
+> Sachsen verlegen soll *duck* ;-)
+
+Sachsen. Die Orks sind recht klein, die Sachsen auch. Und Blackspeech
+gibbet da auch. Und Parallelen zwischen dem schwarzen Tor und der
+Mauer waren ja auch mal gegeben.
+
+MFG, Till
+
+
+-----------------------------------------------------------------------------
+
+
+
+Ich glaub... (Ronda, 11. Dez 2003, 23:27:50):
+... ich wuesste ein-zwei Leute hier, denen der Job der Reimpolizei echt Spass
+machen wuerde.
+
+Ronda ;-)
+
+From: spam-or-nospam@gmx.de (Manfred Russ)
+Newsgroups: de.talk.jokes,de.talk.jokes.d
+Subject: Re: LITTLE CHRISTMAS GEDICHT
+Date: Tue, 9 Dec 2003 13:59:29 +0100
+Message-ID: <MPG.1a3f2b855bb3fb3b98a4c5@ID-30918.user.dfncis.de>
+
+
+*pockpockpock*
+
+"Ja, wer ist da?"
+"REIMPOLIZEI!"
+"Wer bitte?"
+"REIMPOLIZEI! BITTE OeFFNEN SIE!"
+
+*quietsch*
+
+"Guten Abend Herr (zumtuerschildlins) Wowereit. Wir sind von der 
+Literaturpolizei, Abteilung Reim & Vers (plaketteunterdienasehalt); wir 
+haetten da ein paar Fragen an sie."
+"Ja, aeh, wieso, ich.."
+"Wir haben Kenntnis davon erhalten, dass sie am 6.12.03 gegen 12.28 Uhr 
+im Internet ein, aeh, Gedicht in Umlauf gebracht haben, das in mehrerer 
+Hinsicht gegen Sitte & Anstand, aehm, Reim und Metrum verstoesst. Sie 
+koennen natuerlich zuerst ihren Anw, ehaemm, Lektor kontaktieren."
+"??"
+"Unseren Informationen zufolge wurden folgende inkriminierten 
+Belegstellen von Ihrem T-Online-Anschluss aus verbreitet:"
+"Falls Sie meinen Usenet-zugang meinen: Ich poste ueber Tiscali"
+"Hoeren Sie, veralbern Sie mich jetzt bitte nicht, Sie stecken schon tief 
+genug in der Scheisse, verstehen Sie mich? Es gibt in der Bundesrepublik 
+Deutschland Internet von AOL und von T-Online."
+"(lufthol)"
+"Und auf so simple Verschleierungstaktiken fall ich nicht rein, ja? 
+'Tiscali' ist 'T-Online' auf Lateinisch. Meinen Sie, ich merk da nicht? 
+'Ti-scali'! 'Scali' - die Leiter, die Linie; und 'Ti' ist 'T-' ..."
+"(sprachlos)"
+"Also zur Sache:"
+
+
+
+Sat, 6 Dec 2003 12:28:26 +0100 Stefan Wowereit schrieb: 
+
+> In the kitchen of the house 
+> mother makes the Christmasschmaus. 
+> She is working, schufts and bakes 
+> the hit is now her Joghurtkeks 
+
+Unzulaessiger Jambuswechsel.
+
+> Day by day does so vergang 
+> and the holy night does come 
+
+Scheinreim.
+Strafverschaerfend wirkt der Einsatz im Paarreim.
+
+> Then the childrenlein are coming 
+> candle-Wachs is abwaerts running. 
+
+Scheinreim zum zweiten. Siehe oben.
+
+> and the angels look so fine 
+> well this is the Weihnachtstime. 
+
+Scheinreim zum dritten. Damit kann die zu erwartende Strafe nicht 
+mehr zur Bewaehrung ausgesetzt werden.
+
+> when unterm Weihnachtsbaum they're hocking 
+> then nothing can them ever shocking. 
+> They are happy, are so fine 
+> this happens in the christmastime. 
+
+Scheinreim.
+Als strafmildernd ist dabei die Refrain-aehnliche Funktion zu werten.
+ 
+> The animals all in the house 
+> the Hund, the Katz, the bird, the Maus, 
+> are turning round the Weihnachtsstress, 
+> enjoy this as never nie 
+
+Garkeinreim.
+(Schaemen Sie sich eigentlich gar nicht, Sie Perversling?)
+
+
+> well they find Kitekat and Chappi 
+> in the Geschenkkarton of Papi. 
+
+"well they" - wie soll das bittschoen betont werden? Naja. Lassen wir's 
+als Spondeus durchgehen - weil bald Weihnachten is'.
+ 
+> The family behins to sing 
+               ^Typo. Geht extra.
+
+> Her nose indeed is very fine 
+> ende of the Weihnachtstime
+
+Gut, hatten wir schon.
+(wischzueck) Ich fuell das jetzt mal aus - Sie koennen's gleich bezahlen, 
+Sie koennen natuerlich auch Einspruchg einlegen - wird aber wohl nix 
+nuetzen, kann ich Ihnen versichern. Seit Knoth Kanzler ist, weht da ein 
+anderer Wind. Durchschlag ist fuer Sie.
+Ach ja: Paarreimsteuer (ab 42 Zeilen) erledigen die Kollegen vom 
+Finanzamt. Schoenen Tag noch.
+ 
+> Autor leider Unbekannt
+
+Den kriegen wir schon noch, verlassen Sie sich drauf!
+
+
+xpost&Fup2
+Manfred
+
+-----------------------------------------------------------------------------
+
+
+
+Mal etwas wirklich nuetzliches... (Ronda, 12. Dez 2003, 01:17:36):
+... damit gewisse Mudder nicht wieder Choco Crossies aus Ue-Eiern machen
+muessen. Hm. Vielleicht waers doch besser, das nicht zu posten, die Crossies
+waren echt lecker. Egal ;-)
+
+Ronda
+
+[SN: Es geht um die Frage, mit welcher Methode moeglichst
+     viele Herr-der-Ringe-Ue-Ei-Figuren zu ergattern sind.]
+
+From: Tobias Mummert <teergrube@phreaker.net>
+Newsgroups: de.alt.fan.tolkien
+Subject: Re: Die Ue-Eier-Seuche geht wieder um :-)
+Date: Thu, 4 Dec 2003 12:44:58 +0100
+Message-ID: <slrnbsu7hp.87m.teergrube@doczook.de>
+
+* Andreas Cammin [2003-12-04 11:09 GMT] schrieb:
+
+> Mich wuerde interessieren, wer hier noch sammelt, und ob ihr bessere 
+> Tipps drauf habt an die Figuren zu kommen als die Brute-Force-Methode. 
+> Ans Schuetteln glaub ich uebrigens nicht :-)
+
+Du benoetigst ein wenig Empirie, eventuell einen Taschenrechner,
+Bleistift und Notizblock (oder einen Laptop...).
+
+Ferner sollten Dir befremdliche Blicke Deiner Mitkunden im Supermarkt
+Deines Vertrauens egal sein.
+
+Du schnappst Dir mehrere Paletten, schlenderst zur Obstabteilung und
+wiegst *jedes* Ei. Die Ergebnisse werden sorgfaeltig notiert oder in den
+Laptop geklopft. Mit dieser Datenbasis rechnest Du die einschlaegigen
+statistischen Werte aus und kaufst lediglich diejenigen Eier, die im
+Gewicht *signifikant* (5%-Level reicht, denke ich) vom arithmetischen
+Mittel nach oben abweichen.
+
+Denn die Figuren sind etwas schwerer als der durchschnittliche Inhalt
+der Ueberraschungseier.
+
+Das ist kein Witz, ich bin durch diese Methode bei 25 gekauften Eiern
+immerhin auf 21 Volltreffer gekommen.
+
+Gruss,
+Tobias
+
+-----------------------------------------------------------------------------
+
+
+
+Sprache :) (Vanion, 14. Dez 2003, 13:02:17):
+Guenter Thaler wrote:
+> Wie sieht es mit 'eMail' oder 'e-Mail' aus? Falsch oder nur wenig
+> gebraeuchlich?
+Wie schreibst Du sBahn, uBoote und hMilch? Auch tShirts, cWaffen,
+eWerke, gStrings und iPuenktchen sowie dein eigenes yChromosom sollten
+Dir die Entscheidung vereinfachen.
+
+--
+V*
+
+-----------------------------------------------------------------------------
+
+
+
+! (Foobar, 19. Dez 2003, 03:05:12):
+From: Christoph Paeper <crissov2003Q4@gmx.net>
+Subject: Re: Warum "Studierende" ??
+Newsgroups: de.etc.sprache.deutsch
+Date:Wed, 17 Dec 2003 19:04:19 +0100
+Message-ID: <brq5qp$14cb$1@ariadne.rz.tu-clausthal.de>
+
+> Warum der Frauenanteil der Germanistikstudierenden hoeher ist 
+> als der Frauenanteil bei Germanistik-ProfessorInnen, ist eine 
+> interessante Frage.
+
+Analog koenntest du fragen, warum der Frauenanteil bei Grundschuelern
+niedriger ist als der bei Grundschullehrern.
+
+-----------------------------------------------------------------------------
+
+
+
+Agent Elrond (Foobar,  1. Jan 2004, 20:23:26):
+ From: "JPM III" <jpmccord@hotmail.com>
+ Subject: Agent Elrond
+ Newsgroups: alt.movies.the-matrix
+ Message-ID: <bsclvv$c48cm$1@ID-53393.news.uni-berlin.de>
+ Date: Wed, 24 Dec 2003 13:30:13 -0500
+
+ As you can see, we've had our eye on you for some time now, Mr. Aragorn. It
+ seems that you've been living two lives. In one life, you're Aragorn, son of
+ Arathorn, descended from Isildur and heir to the throne of Gondor. You have
+ a deep family history that reaches into past ages, you give hope to men and
+ keep none for yourself, and you want to marry my daughter.
+
+ The other life is lived in the shadows, where you go by the ranger alias
+ "Strider" and are guilty of virtually every violation of kingship we have a
+ law for. One of these lives has a future with my daughter, and one of them
+ does not.
+
+ I'm going to be as forthcoming as I can be, Mr. Aragorn. You're here because
+ we need your help. We know that you've been contacted by a certain
+ individual, a hobbit who calls himself Frodo Baggins. Now whatever you think
+ you know about this hobbit is irrelevant. He is considered by many
+ authorities to be carrying out the most dangerous burden of all: the One
+ Ring of Power.
+
+ My colleagues believe that I am wasting my time with you, but I believe that
+ you wish to do the right thing. We're willing to wipe the slate clean, give
+ you a fresh start, and all that we're asking in return is your cooperation
+ in bringing a hobbit to Mount Doom and accepting the crown of Gondor.
+
+-----------------------------------------------------------------------------
+
+
+
+Disclaimer (Foobar,  4. Jan 2004, 20:49:03):
+Message-ID: <d6a21ezm.fsf@mayweb.de>
+From: Wilfried May <mail@mayweb.de>
+Newsgroups: de.alt.recovery.webauthor
+Subject: Disclaimer
+
+Habe gerade diesen tollen Disclaimer gefunden:
+http://parklandschaft.cg-space.de/disclaimer/disclaimermain.html
+vor allen der zweite Abschnitt ist schon toll:
+
+Unwiderrufliche Vereinbarung:
+
+Der Verfasser dieser Seite traegt keine Verantwortung fuer die Art,
+wie die hier zur Verfuegung gestellten Informationen genutzt werden.
+Dateien und alles andere auf dieser Seite sind nur fuer den privaten
+Gebrauch bestimmt und sollten darum nicht runtergeladen 
+oder gelesen werden. Wenn Sie irgendwie in Verbindung mit der Regierung,
+Anti-Pirate Gruppen oder anderen aehnlichen Gruppen stehen, ist der
+Zugang zu den Dateien und das lesen der HTML Seiten verboten. 
+Alle Objekte dieser Seite sind privates Eigentum und somit nicht zum 
+lesen bestimmt. Grundsaetzlich ist es verboten diese Seite zu betreten. 
+Wenn Sie diese Seite dennoch betreten, verstossen Sie gegen den 
+"Code 431.322.12 of the Internet Privacy Act", der 1995 von Bill Clinton
+verabschiedet wurde. Das heisst sie koennen gegen die Personen, die diese 
+Dateien verwalten, nicht vorgehen.
+
+-----------------------------------------------------------------------------
+
+
+
+SWT (Maarg,  8. Jan 2004, 20:07:50):
+ From: Holger Koetting <holger.koetting@gmx.de>
+ Newsgroups: de.etc.bahn.misc
+ Subject: Re: Detlev, der Rapper
+ Date: Wed, 31 Dec 2003 00:55:20 +0100
+ Message-ID: <3FF21068.7DB6@gmx.de>
+
+ [SN: SWT = Schoenes-Wochenend-Ticket, bis zu fuenf Erwachsene koennen mit
+ einem einzigen fahren]
+
+ Ralf Gunkel wrote:
+ > Ich weiss ich bin eklig.
+
+ Nein, richtig eklig ist es, Schnorrer auflaufen zu lassen.
+ A: "Haben Sie ein Wochenendticket?"
+ B: "Ja."
+ A: "Dann fahre ich da mit."
+ B: "(keine Antwort)"
+ (Kontrolle kommt, selber Verbundfahrschein vorzeigen)
+ Kontro: "Und Sie?"
+ A: "Ich fahre auf dem SWT mit"
+ Kontro: "Der hat kein SWT"
+ A: "Sie haben doch gesagt, dass Sie eines haetten."
+ B: "Stimmt doch auch. Kannst Du sogar gerne haben."
+ (Altes SWT rueberreich)
+ B: "Bitte sehr. Nach 'nem gueltigen SWT haste ja nicht
+     gefragt."
+ Kontro (dick grinsend): "Das macht dann 40 EUR".
+
+ Mal so erzaehlt bekommen, und so aehnlich dann auch selbst
+ praktiziert. Wer so dummdreist ist und nicht mal fragt, ob
+ er mitfahren koenne, sondern das so einfach feststellt, ist
+ selber schuld. :-)
+ Alternativ steigen solche Leute auch gerne in Luetzelsachsen
+ aus.
+ Vor ein paar Tagen abends meinte auch mal wieder jemand von
+ der ueblichen nordbadisch/suedhessischen
+ Schwarzfahrerklientel mit Hilfe des ueblichen
+ Dosto-Spielchen der Kontrolle entgehen zu koennen. Rechnung
+ leider ohne Zub und wissende Fahrgaeste gemacht. :-)
+
+ Gruss,
+
+ Holger K. aus D.
+
+
+ -- 
+ Submissionen fuer de.alt.netdigest bitte an
+ <de-alt-netdigest@moderators.dana.de> schicken.
+ Der Submitter ist fuer den Inhalt der Einreichung verantwortlich, 
+ nicht der Moderator der Newsgruppe.
+
+
+
+-----------------------------------------------------------------------------
+
+
+
+Ich mag angewandte Informatik ;-) (Ronda,  9. Jan 2004, 23:02:36):
+From: Lutz Donnerhacke <lutz@iks-jena.de>
+Newsgroups: de.alt.sysadmin.recovery
+Subject: Re: Jobmarkt immer noch total im Arsch?
+Date: Thu, 8 Jan 2004 13:58:36 +0000 (UTC)
+
+[SN:  Das nenne ich angewandte Informatik.]
+
+* Steffen Peter wrote:
+> Lutz Donnerhacke <lutz@iks-jena.de> wrote:
+>> Ausbildungszeit korreliert nicht mit Eignung.
+>
+> Natuerlich. Aber faendest Du es nicht auch laecherlich, wenn Du Dich morgen
+> irgendwo bewerben wuerdest, und Deine Eignung von fachfremden Psychologen
+> anhand der Schnelligkeit des Sortierens eines Mailqueues bewertet wuerde?
+
+Nein. Besonders, wenn es von Hand zu machen ist, weil es ein richtiger
+Posteingang ist. Daran erkennt man sehr gut, ob der Anwaerter von Algorithmen
+Ahnung hat.
+
+Da ich gerade bemerke, dass ich noch nichts dazu geschrieben habe, hier die
+Story:
+   Friedrich Froebel, der in Keilhau einen Kindergarten/Schule fuer
+   Sprachgestoerte eroeffnete und u.a. damit das Konzept Kindergarten in die
+   Paedagogik einfuehrte, hinterlies einen groesseren handschriftlichen
+Nachlass
+   dort.
+
+   Auf der Suche nach einer Arbeit hat $Bekannter eine ABM in der dortigen
+   Bibliothek angeboten bekommen, da er als Urenkel Froebels durchaus mit den
+   familiaeren Handschriften gut klarkommt. Ausserdem verfuegt er ueber
+   Erfahrungen im Bibliothekswesen.
+
+   Als Theologe hat er aber nicht sonderlich tiefe Kenntnisse der
+Algorithmen-
+   theorie. Und so fragte er bei einem Tee, wie man Handschriften nach Datum
+   sortiert, denn seine Kollegen aus Bibliothekszeiten wussten nur, dass es
+sehr
+   lange dauert einige zigtausend "Zettel" zu sortieren.
+
+   Ich habe ihm dann mit Zuckerstuecken und Loeffeln erklaert, wie ein Radix-
+   Exchange Sort funktioniert und er hat dieses Verfahren dann umgesetzt:
+
+   Man nehme eine Turnhalle, markiere zehn grosse Rechtecke, die man mit
+   '0' bis '9' beschriftet. An die Rechtecke stelle man einige Schueler, die
+   uebergebene Zettel aufeinander stapeln sollen.
+
+   Dann lasse man den Rest der Klasse laufen: Zettel vom grossen Stapel
+nehmen.
+   Aufs die letzte Jahresziffer schauen und Zettel zum richtigen Rechteck
+   tragen.
+
+   Wenn fertig, staple man alle Zettel aufeinander (0 auf 1 auf 2 ... auf 9).
+
+   Dann lasse man nach Jahrzehnt laufen. Staplen und nach Jahrhundert laufen
+   lassen. Staplen und Halle aufraeumen.
+
+   Am meisten beeindruckt waren die anderen Bibliothekare als die Geschichte
+   hoerten.
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Ich mag angewandte Informatik ;-) (Grimmborn,  9. Jan 2004, 23:08:46):
+~#! rn=Ronda rt=1073685756 rg=schmarrn.netdigest
+~#! tid=1073685756
+Sehr schoen. Lass mich raten, der Witz liegt darin, dass Lutz nicht verstanden
+hat dass "nach Datum sortieren" und "nach Jahreszahl sortieren" nicht dasselbe
+ist?
+
+GdA
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Ich mag angewandte Informatik ;-) (Ronda,  9. Jan 2004, 23:11:28):
+~#! rn=Grimmborn rt=1073686126 rg=schmarrn.netdigest
+~#! tid=1073685756
+Nein, der Witz liegt darin, dass ich zu faul war herauszufinden, ob das
+Verfahren in der Art wirklich Sinn macht ;-)
+
+Ronda *Dipl.-Ing. und damit algorithmentechnisch-banausig*
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Ich mag angewandte Informatik ;-) (Humni, 10. Jan 2004, 14:58:34):
+~#! rn=Ronda rt=1073686288 rg=schmarrn.netdigest
+~#! tid=1073685756
+Ich hab mal meine CDs, als ich gerade die Datenstrukturen-Vorlesung gehoert
+habe, mit Mergesort sortiert. Alle anderen haben mich fuer bekloppt erklaert,
+womit sie sicher Recht hatten. Ich haette das auch gar nicht erst erzaehlen
+sollen.
+
+Humni
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: Ich mag angewandte Informatik ;-) (Muadib, 10. Jan 2004, 17:28:39):
+~#! rn=Humni rt=1073743114 rg=schmarrn.netdigest
+~#! tid=1073685756
+das gleiche hat mal ein kollege mit erdnuessen und bubblesort gemacht, also
+sei nicht beunruhigt
+
+-----------------------------------------------------------------------------
+
+
+
+Re^5: Ich mag angewandte Informatik ;-) (Bambi, 10. Jan 2004, 18:57:08):
+~#! rn=Muadib rt=1073752119 rg=schmarrn.netdigest
+~#! tid=1073685756
+Wie hat er die Erdnuesse unterschieden? Nach Gewicht?
+
+-----------------------------------------------------------------------------
+
+
+
+Re^6: Ich mag angewandte Informatik ;-) (Foobar, 10. Jan 2004, 18:57:34):
+~#! rn=Bambi rt=1073757428 rg=schmarrn.netdigest
+~#! tid=1073685756
+Geschmack.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^7: Ich mag angewandte Informatik ;-) (Muadib, 10. Jan 2004, 18:59:10):
+~#! rn=Foobar rt=1073757454 rg=schmarrn.netdigest
+~#! tid=1073685756
+groesse
+
+-----------------------------------------------------------------------------
+
+
+
+[de.comp.sys.mac.soc] Re: ZDF Wiso: iMacs brennen nicht (Deepblue, 10. Jan 2004, 20:20:42):
+From: michaelnoe@mac.com (Michael Noe)
+Newsgroups: de.comp.sys.mac.misc,de.comp.sys.mac.soc
+Subject: Re: ZDF Wiso: iMacs brennen nicht
+Date: Tue, 6 Jan 2004 16:19:51 +0100
+Message-ID: <1g75emt.1ljxqdbb5zztqN@ID-7682.user.dfncis.de>
+
+Ralf Wenzel <ralf.wenzel@web.de> wrote:
+
+> eben rein zufaellig gesehen: WISO hat wohl verschiedene Rechner einem
+> Brandtest gegenuebergestellt und festgestellt, dass der iMac als
+> einziger NICHT brennt.
+
+Nicht kompatibel, wie immer halt... ;-)
+
+X-post & F'up2 Wohnzimmer.
+
+-----------------------------------------------------------------------------
+
+
+
+So war das! (Ronda, 11. Jan 2004, 22:56:09):
+Und das hier ist zwar Rubrik Schmarrn, aber die Wahrheit. Basta!
+
+Ronda
+
+From: "Rosi W." <schneekukuk@yahoo.de>
+Newsgroups: de.soc.familie.kinder
+Subject: Genauso war das !
+Date: Fri, 9 Jan 2004 16:14:55 +0100
+Message-ID: <btmgfg$399$00$1@news.t-online.com>
+
+"Rosi W." <schneekukuk@yahoo.de> schrieb:
+
+Genauso war das !
+
+Wenn du nach 1978 geboren wurdest, hat das hier nichts mit dir zu
+tun - Verschwinde!
+
+Kinder von heute werden in Watte gepackt!
+
+Wenn du als Kind in den 50er, 60er oder 70er Jahren lebtest, ist
+es zurueckblickend kaum zu glauben, dass wir so lange ueberleben
+konnten!
+
+Als Kinder sassen wir in Autos ohne Sicherheitsgurte und ohne
+Airbags.
+
+Unsere Bettchen waren angemalt in strahlenden Farben voller Blei
+und Cadmium.
+
+Die Flaeschchen aus der Apotheke konnten wir ohne Schwierigkeiten
+oeffnen, genauso wie die Flasche mit Bleichmittel.
+
+Tueren und Schraenke waren eine staendige Bedrohung fuer unsere
+Fingerchen.
+
+Auf dem Fahrrad trugen wir nie einen Helm.
+
+Wir tranken Wasser aus Wasserhaehnen und nicht aus Flaschen.
+
+Wir bauten Wagen aus Seifenkisten und entdeckten waehrend der
+ersten Fahrt den Hang hinunter, dass wir die Bremsen vergessen
+hatten. Damit kamen wir nach einigen Unfaellen klar.
+
+Wir verliessen morgens das Haus zum Spielen. Wir blieben den
+ganzen Tag weg und mussten erst zu Hause sein, wenn die
+Strassenlaternen angingen. Niemand wusste, wo wir waren und wir
+hatten nicht mal ein Handy dabei!
+
+Wir haben uns geschnitten, brachen Knochen und Zaehne und niemand
+wurde deswegen verklagt. Es waren eben Unfaelle. Niemand hatte
+Schuld, ausser wir selbst. Keiner fragte nach "Aufsichtspflicht" .
+Kannst du dich noch an "Unfaelle" erinnern? Wir kaempften und
+schlugen einander manchmal gruen und blau. Damit mussten wir leben,
+denn es interessierte den Erwachsenen nicht.
+
+Wir assen Kekse, Brot mit dick Butter, tranken sehr viel und
+wurden trotzdem nicht zu dick.
+
+Wir tranken mit unseren Freunden aus einer Flasche und niemand
+starb an den Folgen.
+
+Wir hatten nicht: Playstation, Nintendo 64, X-Box, Videospiele,
+64 Fernsehkanaele, Filme auf Video, Surround Sound, eigene
+Fernseher, Computer, Internet-Chat-Rooms. Wir hatten Freunde!
+
+Wir gingen einfach raus und trafen sie auf der Strasse. Oder wir
+marschierten einfach zu deren Heim und klingelten. Manchmal
+brauchten wir gar nicht klingeln und gingen einfach hinein. Ohne
+Termin und ohne Wissen unserer gegenseitigen Eltern. Keiner
+brachte uns und keiner holte uns. Wie war das nur moeglich?
+
+Wir dachten uns Spiele aus mit Holzstoecken und Tennisbaellen.
+Ausserdem assen wir Wuermer. Und die Prophezeiungen trafen nicht
+ein: Die Wuermer lebten nicht in unseren Maegen fuer immer weiter
+und mit den Stoecken stachen wir nicht besonders viele Augen aus.
+
+Beim Strassenfussball durfte nur mitmachen, wer gut war. Wer nicht
+gut war, musste lernen, mit Enttaeuschungen klarzukommen.
+
+Manche Schueler waren nicht so schlau wie andere. Sie rasselten
+durch Pruefungen und wiederholten Klassen. Das fuehrte nicht zu
+emotionalen Elternabenden oder gar zur Aenderung der
+Leistungsbewertung.
+
+Unsere Taten hatten manchmal Konsequenzen. Das war klar und
+keiner konnte sich verstecken. Wenn einer von uns gegen das
+Gesetz verstossen hat, war klar, dass die Eltern ihn nicht aus dem
+Schlamassel heraushauen. Im Gegenteil: Sie waren der gleichen
+Meinung wie die Polizei! So etwas!
+
+Unsere Generation hat eine Fuelle von innovativen Problemloesern
+und Erfindern mit Risikobereitschaft hervorgebracht. Wir hatten
+Freiheit, Misserfolg, Erfolg und Verantwortung. Mit alldem wussten
+wir umzugehen.
+
+Und du gehoerst auch dazu.
+
+Herzlichen Glueckwunsch
+
+Gruesse an alle, die ueberlebt haben
+
+
+Rosi
+
+-----------------------------------------------------------------------------
+
+
+
+Re: So war das! (Whitetiger, 12. Jan 2004, 17:49:17):
+~#! rn=Ronda rt=1073858169 rg=schmarrn.netdigest
+~#! tid=1073858169
+Das stand neulich sogar mal im ... *gruebel* Stern. Oder Spiegel... verwechsel
+ich immer.
+Tiger
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: So war das! (Medic, 12. Jan 2004, 21:29:47):
+~#! rn=Whitetiger rt=1073926157 rg=schmarrn.netdigest
+~#! tid=1073858169
+Du verwechselst Stern und Spiegel?!
+:uaaaaht.
+
+-----------------------------------------------------------------------------
+
+
+
+dcsf (Nonne, 13. Jan 2004, 14:30:25):
+Hallo NG,
+
+Vor ca.2 Wochen schickte mir Microsoft eine email mit der Bitte einen
+Securitypatch zu installieren.Das hab ich natuerlich gemacht.Aber seither
+schickt mir Microsoft pro Tag zwischen 30 und 50 dieser Aufforderungen den
+Securitypatch zu installieren.
+Meine Frage:
+1.Ist es ratsam jede dieser Aufforderungen zu befolgen,oder kann man auch
+mal ein paar Updates auslassen??
+2.Was ist ueberhaupt ein Securitypatch?
+Ich frage dies weil die ganze Updaterei sehr zeitintensiv ist.Unsere ganze
+Familie ist seit 2 Wochen dadurch sehr beansprucht.
+Mein Opa hat schon gedroht gar nicht mehr zu uns zu kommen.Die Downloaderei
+geht ihm so langsam auf den Sack,sagt er.
+
+Gruss
+Klaus
+
+Nonne, nicht sicher, ob das ein Troll war oder der das ernst meint.
+
+-----------------------------------------------------------------------------
+
+
+
+Was Praktisches aus dtj (Nonne, 14. Jan 2004, 13:00:06):
+WIE MAN EINE KATZE BADET
+========================
+
+
+1. Reinige gruendlich die Toilette
+
+2. Fuege dem Toilettenwasser die noetige Menge an Shampoo bei
+und oeffne beides, die Klobrille und den Deckel.
+
+3. Fang' die Katze und beruhige sie, waehrend Du sie in
+Richtung Badezimmer traegst.
+
+4. Stecke die Katze in einem ruhigen Moment in die Toilette
+und
+schliesse beide Deckel (koennte sein, dass Du auf den oberen
+Deckel draufstehen musst, damit sie nicht fliehen kann).
+WARNUNG: Bring keinen Teil Deines Koerpers zu nahe an den
+Rand, da ihre Pfoten nach allem greifen werden, was sie
+erreichen koennen. Die Katze wird sich nun selbst bewegen
+und eine Menge Schaum
+erzeugen. Mach Dir keine Gedanken ueber die entstehenden
+Geraeusche, die aus Deiner Toilette kommen, die Katze
+geniesst das wirklich.
+
+5. Druecke die Spuelung der Toilette drei oder vier mal. Das
+bewirkt einen 'Turbowasch- und Spuelgang' der sich fuer mich
+als aeusserst effektiv bewaehrt hat.
+
+6. Lass jemanden die Tuer nach draussen oeffnen und stelle sicher,
+dass sich niemand zwischen der Toilette und der Ausgangstuer
+befindet.
+
+7. Stelle Dich soweit hinter die Toilette, wie Du kannst und oeffne
+rasch beide Deckel.
+
+8. Die frischgewaschene Katze wird wie eine Rakete aus der
+Toilette hervorschiessen und nach draussen rennen um sich
+selbst zu trocknen.
+
+
+Hochachtungsvoll,
+
+
+
+Der HUND
+
+Nonne, haette sich die Anleitung frueher gewuenscht.
+
+-----------------------------------------------------------------------------
+
+
+
+Absicht oder Dummheit? (Nonne, 16. Jan 2004, 08:38:23):
+
+Stefan Birk wrote:
+
+[...]
+
+Huch, da ist mein kleines Sig-Tool doch tatsaechlich abgelaufen! Naja, jetzt
+hab ich die Vollversion!
+
+RandomSignature-Professional 3.2 - DEMO
+***U are using an illegal key! Please buy a LEGAL copy!***
+:-)
+
+Nonne, kringelt sich vor lachen.
+
+-----------------------------------------------------------------------------
+
+
+
+[de.comm.provider.misc] Re: Neue Dialer Abzocke: Jetzt Sat-Einwahlnummern (Deepblue, 17. Jan 2004, 19:31:09):
+From: Sven Paulus <sven@karlsruhe.org>
+Subject: Re: Neue Dialer Abzocke: Jetzt Sat-Einwahlnummern
+Newsgroups: de.comm.provider.misc
+Date:5 Dec 2003 13:04:35 GMT
+Message-ID: <bqpvp3$vau$1@akk3-dmz.akk.uni-karlsruhe.de>
+
+Bjoern Schliessmann <chr0n0ss@despammed.com> wrote:
+>> Fuer *nix gabs bis jetzt noch keinen Trojaner,
+>> das ist auch systembedingt gar nicht moeglich.
+
+> Warum sollen Trojanische Pferde dort nicht moeglich sein? Unix und
+> Verwandte sind nicht per definitionem sicher.
+
+Exakt, die konnten sogar schon Wuermer via Internet zu einer Zeit,
+als Windows noch nicht einmal Netzwerk konnte, es ist also nicht so,
+dass Microsoft neben der grafischen Oberflaeche, der Maus und dem
+Internet auch Trojaner erfunden hat:
+http://www.mit.edu/people/eichin/virus/strategies.html
+
+-----------------------------------------------------------------------------
+
+
+
+Re: [de.comm.provider.misc] Re: Neue Dialer Abzocke: Jetzt Sat-Einwahlnummern (Ronda, 18. Jan 2004, 00:02:43):
+~#! rn=Deepblue rt=1074364269 rg=schmarrn.netdigest
+~#! tid=1074364269
+Der Link ist echt spannend. Besonders wenn man sich den ganzen Artikel
+durchliest:
+
+http://www.mit.edu/people/eichin/virus/main.html
+
+Interessant ist unter anderem der Abstract:
+'In early November 1988 the Internet, a collection of networks consisting of
+60,000 host computers implementing the TCP/IP protocol suite, was attacked by
+a virus, a program which broke into computers on the network and which spread
+from one machine to another.'
+
+... 60.000 Computer, die das Internet bilden... as time goes bye...
+
+Ronda
+
+-----------------------------------------------------------------------------
+
+
+
+Das koennte auch in die MPA unter suche-biete passen... (Ronda, 18. Jan 2004, 00:07:49):
+... die Frage ist nur: Katze oder Rasierer austauschen?
+
+[SN: Zeilenumbruch korrigiert]
+
+From:  Oliver Pfeiffer <oliver.pfeiffer@gmx.net>
+Newsgroups:  de.etc.haushalt
+Subject: Katze und Braun Activator 8595 (Elektrorasierer)
+Message-ID: <Xns94587BE5E624Doliverpfeiffergmxnet@pfeiffer.myfqdn.de>
+Date: Sun, 21 Dec 2003 12:10:42 +0100
+
+Hallo,
+
+ich habe mir vor wenigen Tagen einen neuen Braun Rasierer "Activator
+8595" gekauft. Das ist so ein selbstreinigendes Geraet mit
+Reinigungsstation, in die man den Rasierer nach der Rasur zum Aufladen
+und Reinigen reinstellt.
+
+Schon am ersten Abend habe ich meine Katze vermisst. Nach einigem
+Suchen fand ich sie im Badezimmer vor der Station hockend. So ist mir
+aufgefallen, dass das Steckernetzteil einen recht aufdringliches
+Sirren von sich gibt - auf das scheinbar insbesondere meine Katze
+abfaehrt.
+
+Ausserdem "britzelt" es im 2 Sekunden Takt im Rasierer, wenn dieser
+voll geladen ist (Anzeige wechselt staendig von "Test" auf "Full").
+
+Habt Ihr dieses "Britzeln" auch? Bei mir flackert dabei zusaetzlich die
+blaue LED. Das alles macht meine Katze total kirre. Wenn Ihr das nicht
+habt, dann lohnt sich vielleicht ein Umtausch fuer mich?
+
+-----------------------------------------------------------------------------
+
+
+
+[de.alt.talk.unmut] Re: Telekom Unmut (Deepblue, 24. Jan 2004, 14:24:40):
+From: Henning 'Faroul' Peters <tellmenews@faroul.de>
+Newsgroups: de.alt.talk.unmut
+Subject: Re: Telekom Unmut
+Date: Tue, 20 Jan 2004 20:50:55 +0100
+Message-ID: <buk0r4$ip84e$1@ID-203167.news.uni-berlin.de>
+
+> Trotzdem Unmut ueber Willkuer und Trotteligkeit bei dem T-Laden, wo die
+> Rechte nicht weiss was die Linke tut.
+
+Erinnert mich an eine Story: ein Bekannter arbeitet in einem Laden, wo
+normalerweise 4-10 mal die Stunde das Telefon. Nur an einem Tag nicht. In
+der Mittagspause dann mal die Probe und von einer T-Zelle aus angerufen.
+Freizeichen, aber kein Klingeln.
+Also die Stoerstelle angerufen. "Am Freitagnachmittag? Das wird schwierig,
+aber wir versuchen, noch einen Techniker vorbeizuschicken."
+Erwartungsgemaess passierte Freitag nichst mehr, ebenso Samstag.
+Als auch Montag Mittag noch nichts zu sichen war, rief man wieder die
+Stoerstelle an. "Moment, ich hatte das doch einem Techniker mitgeteilt; ich
+versuche mal, den zu erreichen und verbinde Sie dann direkt." *tuut*tuut*
+
+Der Techniker meldete sich tatsaechlich: "Was beschweren Sie sich? Ich
+versuche Sie seit Freitag nachmittag fuer eine Terminabsprache anzurufen!"
+
+No comments...
+
+-----------------------------------------------------------------------------
+
+
+
+[de.alt.sysadmin.recovery] Re: Nicht smart (Deepblue, 24. Jan 2004, 20:35:02):
+From: ignatios@fourier.cs.uni-bonn.de (Ignatios Souvatzis)
+Newsgroups: de.alt.sysadmin.recovery
+Subject: Re: Nicht smart
+
+Kristian Koehntopp schrob:
+
+> Ueber 30-jaehrigen ist das Betreten der Loveparade selbst in Begleitung
+> ihrer Kinder untersagt.
+> 
+> Zum Glueck.
+
+Ueber 30-jaehrige mit dem Verlangen nach nervtoetender "Musik", kollektivem 
+Konsum von Drogen, Massenauflauf mit gelockerten Sitten, und einem Umzug
+dazwischen gehen nicht zur Love Parade, sondern zum rheinischen Karneval.
+
+-is
+
+-----------------------------------------------------------------------------
+
+
+
+Schuetzenfest fuer Anfaenger... (Ronda, 24. Jan 2004, 21:51:42):
+Aber Achtung: Sehr sehr lang... und nicht immer sehr lecker...
+
+Ronda
+
+
+From: Elfis Ravendoza 
+Subject: Mein Beitrag zum Thema Humor  
+Newsgroups: Schattenwelt-Foren
+Message-ID: keine
+Datum: 20.1.2004, 18:11 
+
+[Anmerkung des Einreichers: Lang und so gut, dass ich es gern hier sehen
+wuerde]
+
+> Fuer alle die NICHT vom Lande kommen und NICHT wissen was ein
+> Schuetzenfest ist, hier die Erklaerung:
+> 
+> Schuetzenfest
+> 
+> Einmal im Jahr is in jedem Dorf der Ausnahmezustand. Diese Orgie
+> heisst dann Feuerwehr-, Schuetzen-, oder Saengerfest oder meinetwegen
+> auch Huehnerwaemserball, is vollkommen egal, weil is alles dasselbe.
+> Dann wird nen Zelt aufgebaut irgendwo und mindestens drei Tage
+> getestet, wie viel Ballerbruehe die alte Karkasse noch aufsaugen kann.
+> Faengt meist schon Tage vorher an, mit Kraenzeflechten, Birkenbraken
+> anne Verkehrsschilder nageln oder weiss der Henker: Hauptsache mitn
+> Trecker rumnageln und Kiste Bier dabei. Waehrend die Maenner in der
+> Wildnis das gefaehrliche Tannengruen erlegen, sitzen die Weibchen im
+> Kreis und basteln daraus meterlange Kraenze. So wird die traditionelle
+> Rollenteilung gefestigt und keiner kommt auf dumme Gedanken. Die
+> Sitte des Kraenzens is uralt.
+> 
+> 
+> 
+> Frueher beim Schuetzenfest kamen immer mehrere Leute zu Tode:
+> 
+> Kaputtgesoffen, anner Theke totgetrampelt oder anner achten Bratwurst
+> erstickt. Ja und weil das ganze Dorf nachn Zeltfest zu tattrig war,
+> um nen Kranz fuer die Beerdigungen zu flechten wurden die vorher auf
+> Vorrat fertiggemacht.
+> 
+> Musste man Montag dann bloss noch auf Ende schneiden das Gestruepp,
+> Papierblume dran und ab nachn Friedhof. Heute gibs ja kaum noch Tote
+> bei Zeltfesten, nich mal mehr Schlaegereien die warn ja frueher der
+> Hoehepunkt. Die Schlaegerei ist die Form, in der der Mann vom Lande
+> einem andern sagt, dass er ihn lieb hat. Und nach der
+> Massenschlaegerei in der Sektbar waren alle Maenner Blutsbrueder. Doch
+> die soziale Kaelte is auch aufm Dorf zu spueren: keiner haut mehr dem
+> anderen einfach so einen in die Fresse.
+> 
+> Ein heimlicher Hoehepunkt beim Zeltfest ist der spontane
+> Geschlechtsverkehr an der Rueckwand vom Festzelt. Wenn die Kerle zum
+> Pissen irgendwo ins Gebuesch verschwinden, erinnern sie sich
+> ploetzlich, dass sie nicht bloss ein Loch im Kopp haben, wo man Bier
+> reinschuetten kann, sondern dass es zwischen den Beinen auch wieder
+> rauskann. Und mit dieser verkuemmerten Restexistenz hatten sie frueher
+> doch auch immer viel Spass. Und jetzt schlaegt die erotische Phantasie
+> gnadenlos zu: Sex ohne sich gross ausziehen zu muessen, is das
+> allergroesste. Hose is eh noch auf vom Pissen, quasi die halbe Miete.
+> 
+> Jetzt fehlt bloss noch die Gelegenheit. Doch da siehts dann finster
+> aus:
+> 
+> die Anzahl der willigen Tanten, die teilentbloesst an der Zeltwand
+> lehnen, haelt sich
+> 
+> doch in Grenzen. Und so laufen Dutzende von halbbesoffenen Typen mit
+> offener Buchse hinterm Zelt rum und verstehen die Welt nich mehr.
+> Muesst Ihr mal drauf achten, so ab 23 Uhr etwa geht's los: dann
+> schleichen hier ueberall die Maenner durchs Unterholz. Offiziell wollen
+> sie natuerlich nur zehn Liter Gerstenaufguss nach draussen bringen, in
+> Wahrheit sind sie auf Suche nach erotischen Abenteuern. Es gibt auch
+> Maenner, die gehen zum Pinkeln in den Toilettenwagen, die haben die
+> Hoffnung schon aufgegeben, dass da draussen in der Wildnis noch
+> irgendwas zu loeten waere. Aber auch bei den andern sieht die Realitaet
+> nich besser aus: nach dem Strullen kommen sie total gefrustet wieder
+> zurueck ins Zelt. Frueher entlud sich dann der Frust in einer
+> homoerotischen Ersatzbefriedigung: der Massenschlaegerei. Haben wir
+> schon gesehen: gibs heute kaum noch.
+> 
+> Was bleibt also: Das EINE: Koerper stillegen durch Alkoholzufuhr. Das
+> hoert sich einfach an, isses aber nich, weil beim Zeltsaufen gibt es
+> festgelegte Rituale, die man unbedingt beachtet muss:
+> 
+> 1. Ein Bier bestellen geht gar nich. Damit sagt man, dass man ne
+> knickrige Sau is, keine Freunde hat oder Antialkoholiker, quasi das
+> allerletzte.
+> 
+> 2. Also immer mindestens zehn Stueck, einen Meter oder ein ganzes
+> Tablett. Nie vorher abzaehlen, wie viel Leute um einen herumstehen und
+> dann genau die Anzahl bestellen. Am besten irgendeine Zahl ueber die
+> Theke groelen und ab dafuer.
+> 
+> 3. Ganz falsch: Die Umstehenden fragen, ob sie ueberhaupt noch ein
+> Bier haben wollen. Wichtige Regel: gefragt wird nich. Saufen ist
+> schliesslich kein Spass.
+> 
+> 4. Wenn der Stoff da is, nich bloed rumgucken und ueberlegen, wem man
+> denn eins in die Hand druecken soll. Am besten die Glaeser wild in der
+> Umgebung verteilen, denn nur so zeigt man seine Grosszuegigkeit. Nur
+> der kleinkarierte Pisser stellt sich da an.
+> 
+> 5. Wer zahlt wann welche Runde? In der Regel kommt jeder der Reihe
+> nach dran. Ganz miese Wichser saufen die ersten neun Runden an der
+> Theke mit und wenn sie an der Reihe waeren, muessen sie ploetzlich
+> pissen. Der erste Besteller bestimmt meist die Dauer des Projekts:
+> Wenn er zwoelf Bier bestellt, muessen alle solange warten, bis zwoelf
+> Runden durch sind.
+> 
+> Wichtig ist, dass der Strom nie abreisst. Also wenn alle noch die
+> Haelfte im Glas haben, sofort die naechste Runde ordern und das neue
+> Glas in die Hand druecken. Was voll peinlich ist: Mit zwei Glaesern in
+> der Hand an der Theke stehen, deshalb is Tempo angesagt beim
+> reinschuetten, is schliesslich kein Kindergeburtstag.
+> 
+> 6. Richtig fiese Schweine bestellen zwischendurch noch ne Runde Korn
+> oder die absolute Hoelle "Meyers Bitter", eine Art gruenes
+> Schlangengift, dass mit dem Eiter von toten Froeschen verfeinert
+> wurde.
+> 
+> Hier wird's ernst. Sollte sich sowas andeuten, kann man bloss noch die
+> Flucht ergreifen. Merke: Biersaufen kann man ueberleben aufm Zeltfest
+> mit etwas Planung und Glueck; nach Meyers Bitter weigert sich sogar
+> der Notarzt, diese Schweinerei wiederzubeleben.
+> 
+> 7. Konsequent durchgezogen, bist Du normalerweise aufm Zelt um halb
+> Neun stramm wie die Kesselflicker. Geht natuerlich nich, weil Du
+> kannst ja noch nich Hause, wegen Verdacht auf Weichei. Was also dann?
+> 
+> Pausen machen! Dafuer sind in der Regel zwei Sachen vorgesehen -
+> Bratwurstfressen und Tanzen.
+> 
+> a) Bratwurstfressen:
+> 
+> Vorteil: an der Bude gibs kein Meyers Bitter, da bist Du also ne
+> zeitlang sicher vor der Alkoholvergiftung durch andere. Nu sind die
+> Bratwurststaende auf Zeltfesten immer so konzipiert, dass die
+> Nachfrage immer groesser ist als das Angebot.
+> 
+> In der Bude arbeiten auch meistens Fachkraefte, denen man beim Grillen
+> die Schuhe besohlen kann. Einzige Qualifikation: sie koennen mit einem
+> Sauerstoffanteil in der Luft von unter 1% ueberleben, deswegen wirken
+> sie auch so scheintot. Nu sagt der Laie: watn Scheiss, das koennte man
+> doch viel besser organisieren: zackzack kaemen die Riemen uebern
+> Tresen.
+> 
+> Falsch: die mickrigen Bratwurstbuden mit den Untoten am Grill stehen
+> da nich aus Versehen, sondern absichtlich. Hier kann man Asyl
+> beantragen von der Sauferei und je laenger man auf den verkohlten
+> Prengel warten muss, desto groesser die Ueberlebenschance.
+> 
+> b) Tanzen:
+> 
+> Im Vergleich zu Bratwurstfressen natuerlich die schlechtere Wahl, weil
+> anstrengend und mit Frauen. Aber irgendwann geht halt kein Riemen
+> mehr rein in den Pansen und Du musst in den sauren Apfel beissen. Also
+> zack, einen Rochen von den Baenken gerissen und irgendwie bescheuerte
+> Bewegungen machen.
+> 
+> Wenn Du Glueck hast, spielt die Kapelle mehr als zwei Stuecke und Du
+> kannst Dir ein paar Bier ausse Rippen schwitzen. Hast Du Pech, kommt
+> sofort nachm ersten Stueck der Thekenmarsch und Du stehst wieder da,
+> von wo Du gerade geflohen bist.
+> 
+> c) Sektbar:
+> 
+> Eine richtig gruselige Bude, quasi die Abferkelbox im Festzelt. Hier
+> isses so voll und eng, hier bleibst Du auch noch stehen, wenns
+> eigentlich nich mehr geht. Es soll schon Kriegsverletzte gegeben
+> haben, denen hat man in der Sektbar beide Beinprothesen geklaut und
+> sie habens nich gemerkt..
+> 
+> Doch der Preis, den Du fuer die Stehhilfe zahlst is hoch: Du musst
+> Sekt saufen aus so mickrigen Blumenvasen, die man von der Spermaprobe
+> beim Urologen kennt. Ziemlich eklig alles. Wenns keine Sektbar gibt,
+> gibst meist ne Cocktailbar: Cocktail heisst im Zelt aber nich
+> Caipirinha oder Margerita sondern Fanta/Korn oder Korn mit Fanta.
+> Also vorsichtig. Hier kanns ganz schnell zuende gehen. Eine
+> Alternative fuer den ganzen schnellen Weg ins Nirwana is noch der
+> hannoversche Zaubertrank: Luettje Lage. Vom Preis-Leistungs-Verhaeltnis
+> her immer noch ne reelle Sache: So besaeuft sich der kritische
+> Verbraucher und hat es ruckzuck geschafft. Doch bevor Du nach Hause
+> darfst, kommt noch ein ganz wichtiger Punkt, naemlich....
+> 
+> d) Kotzen:
+> 
+> Klingt scheisse, Du wirst aber dankbar sein, wenn Dein Koerper, Dir
+> Dieses Geschenk bereitet. Du hast Platz fuer neue Bratwuerste und
+> vielleicht sogar Glueck, dass Du die letzten zwanzig Bier noch
+> erwischt, bevor sie Dein Gehirn erreicht haben. Der Profi jedenfalls
+> kotzt oft und gern. - So jetzt waeren wir auch schon bald beim
+> Nachhause gehen. Haha. Wenn Du abers den Zeitpunkt verpasst hast, und
+> Du kommst vom Pissen oder Bratwurstkotzen wieder ins Zelt und es sind
+> bloss noch zwanzig Mann uebrig.
+> 
+> Aetsch: Arschkarte gezogen. Denn jetzt heisst es:
+> 
+> e) Die Letzten:
+> 
+> Ab jetzt geht es um so spannende Sachen wie Fassaussaufen - es is
+> immer mehr drin, als Du denkst, oder Absacker trinken, wenns ein
+> Meyers Bitter ist, kannst Du Dir gleich den Umweg ueber den Notarzt
+> sparen und den Bestatter anrufen. Jeder passt jetzt auf, dass keiner
+> heimlich abhaut.
+> 
+> Die ersten sacken einfach so vor der Theke zusammen, damit sie
+> jedenfalls nich noch mehr saufen muessen. Vorteil dieser Phase des
+> Zeltfestes: Du musst nich mehr extra mehr nach draussen latschen fuer
+> Pissen und Kotzen: geht jetzt alles vor Ort.
+> 
+> f) Nach Hause
+> 
+> Faellt aus. Mach Dir keine Illusionen: alleine schaffst Dus nich mehr,
+> Taxis gibst nich aufm Land, und wenn, wuerden sie Dich nich mitnehmen.
+> 
+> Deine Frau kommt nich, um Dich zu holen, die is froh, dass dieses
+> Wrack nich inner Wohnung liegt und der Gestank in die Moebel zieht.
+> Was bleibt ist.
+> 
+> g) Der Morgen danach:
+> 
+> Die ersten Sonnenstrahlen brechen durch die Ritzen in der
+> Zeltfestplane. Du wirst wach von einem Zungenkuss, wie Du ihn noch nie
+> in Deinem Leben gekriegt hast. Leidenschaftlich kuesst Du zurueck. Dann
+> machst Du Deine verklebten Augen auf und blickst in das froehliche
+> Gesicht des zottigen Koeters von dem Karusselfritzen. Und mit einem
+> eigenen Beitrag zum Thema Wuerfelhusten faengt der Tag wieder an. Dein
+> Kopf fuehlt sich an wie nach einem Steckschuss.
+> 
+> Jetzt hilft nur noch: Stuetzbier bis die Maschine wieder halbwegs
+> normal laeuft.
+> 
+> 
+> 
+> 
+> 
+> 
+> 
+> Arkan Institut
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Schuetzenfest fuer Anfaenger... (Darklor, 29. Jan 2004, 11:06:46):
+~#! rn=Ronda rt=1074977502 rg=schmarrn.netdigest
+~#! tid=1074977502
+Klasse!
+
+Darklor
+
+-----------------------------------------------------------------------------
+
+
+
+[de.rec.musik.machen] Re: Urheberrecht bei Techno-Makern (Deepblue, 29. Jan 2004, 20:40:27):
+Christian Hauschke <chauschke@web.de> schrieb:
+> > Leider ging dieser Krug nicht an mir vorbei und ich habe die
+> > unsaeglichen Scooter wirklich mal mit diesem Lied "live" im
+> > Fernsehen gesehen. Leider musste ich die Fernbedienung erst
+> > suchen...
+>
+> War nichts grosses, schweres, doch gerade noch Schleuderbares in
+> der Naehe? Die grossen TV-Anstalten muessten gegen sowas versichert
+> sein.
+
+Dummerweise war das bei meinen Eltern zuhause, und die waeren darob
+sicherlich nicht sonderlich erfreut gewesen. Obwohl die Erklaerung
+bestimmt lustig geworden waere: "Ich habe leider den Fernseher in akuter
+akustischer Notwehr zerstoeren muessen." :-)
+
+-----------------------------------------------------------------------------
+
+
+
+[de.alt.fan.aldi] Re: Aldi Nord Notebook (Deepblue, 29. Jan 2004, 21:07:36):
+Peter Bruells <pb@ecce-terram.de> wrote:
+
+> Hartmut 'Hardy' Schiszler <spamischdoof@expires-2004-01-31.arcornews.de>
+writes:
+> > Ne, da mache ich nicht mehr mit. Da suche ich mir jetzt ein anderes
+> > Usenet!
+> Schade, dass "Habe mir das Usenet gekauft" von Stefan Schneider nicht
+> in Google archiviert ist.... 
+
+Da bringst du mich gerade auf eine Idee... gruebel Ich koennte das
+Usenet bei ebay versteigern.
+
+-------------------------------------------------------------------------
+Usenet-Diskussion-AntwortenaufalleFragenrar
+-------------------------------------------------------------------------
+
+Sensationell!!! Antworten auf alle deine Fragen!!! Brauchst du Hilfe
+fuer
+die Hausaufgaben? Will deine Ex nur Kohle von dir? Parkt dein Nachbar
+immer auf deinem Stellplatz? Ist ein Kardanwheelie moeglich? Wann kommt
+der naechste Aldi-PC? Wie bekomme ich das Moos aus meinem Rasen? Wie
+werde ich Web-Designer? Muss bei ebay bewerten? Wie konfiguriere ich
+Zone Alarm richtig?
+
+Eine absolute Raritaet, das Usenet gibt es garantiert nur einmal.
+
+Versteigert werden ab nur !!einem Euro!! die geheimen Zugangsdaten,
+damit auch du im Usenet deine bewegensten Frage stellen kannst.
+
+***KEINPORTO,ABSOLUTVERSANDKOSTENFREI***
+Das Usenet wird portofrei zu dir in die Wohnung geliefert,
+Voraussetzung
+ist nur, dass du diese Versteigerung von zu Hause aus sehen kannst.
+
+Folgekosten sind nicht in dieser Auktion eingeschlossen, keine
+EU-Garantie wegen Privatauktion.
+-------------------------------------------------------------------------
+
+Gruss, Kath'Ka-Ching'inka
+
+-----------------------------------------------------------------------------
+
+
+
+Wurm... (Foobar, 30. Jan 2004, 23:17:16):
+From: Thilo Herrmann <herrmt@gmx.de>
+Newsgroups: de.alt.netdigest
+Subject: [Heise Forum] Mydom/Novarg
+Followup-To: de.talk.jokes.d
+Date: Fri, 30 Jan 2004 17:00:03 +0000 (UTC)
+
+http://www.heise.de/security/news/foren/go.shtml?read=1&msg_id=4988930&forum_i
+d=52252
+
+Kindermund tut Wahrheit kund    
+LexLuthor (28. Januar 2004 15:22) 
+
+Beim Fruehstueck meinte meine Tochter (11) zu mir: "Du Papa, da ist
+heute ein Wurm. In fast jedem Computer. Der heisst outlook oder so." 
+
+
+
+-----------------------------------------------------------------------------
+
+
+
+[de.comp.security.firewall] Re: Personal Firewalls (Deepblue,  2. Feb 2004, 20:14:53):
+From: Wolfgang Ewert <w.ewert2002@gmx.de>
+Newsgroups: de.comp.security.firewall
+Subject: Re: Personal Firewalls
+Date: Fri, 30 Jan 2004 10:06:54 +0100
+Message-ID: <fr6dvb.6jq.ln@news.wolfgang.ewert.com>
+
+Hallo Stefan Werner, Du teiltest mit:
+
+> Am 29.01.2004 15:29 schrieb Juergen Ilse:
+
+> > Johannes Mueller <joh_im_usenet@gmx.de> wrote:
+> > 
+> >>Stefan Werner <65r8vzp02@sneakemail.com> skribis:
+> >>
+> >>>Ein Denial of Service kommt letztlich durch eine Ueberlastung des Servers
+> >>>zustande. Ob die durch legitime oder absichtliche illegitime Anfragen 
+> >>>zustande kommt, spielt keine Rolle: Das Resultat ist, dass der Server 
+> >>>fuer seine eigentlichen Zwecke nicht erreichbar ist. Und fuer diese 
+> >>>Situation, egal wodurch es ausgeloest wird, brauche ich eine Absicherung.
+> >>
+> >>Die gibt es aber nicht.
+> > 
+> > 
+> > Zumindest nicht wirklich, wenn der DDOS auf hinreichend "breiter Front"
+> > daherkommt ...
+> > 
+> Natuerlich gibt es die. Die Absicherung kann auch einfach darin bestehen, 
+> dass man seine Firma nicht vital abhaengig vom Internet-Zugang macht.
+
+O.k.: eBay-Auktionen finden in Zukunft bei Sotherby's statt, Dein Buch
+kaufst Du bei Deinem Amazon-Buchhaendler um die Ecke, Usenet-Beitraege
+hast Du frankiert an sunrise, Thurgauerstrasse 60, 8050 Zuerich
+einzureichen, und DNS-Anfragen sind anVeriSign,487EastMiddlefield
+Road, Mountain View, CA 94043 bzw. anVeriSignEurope,Cheminde
+Blandonnet, 8, CH-1214 Vernier, Geneva (hach, hast Du's gut) zu richten.
+
+
+-----------------------------------------------------------------------------
+
+
+
+[microsoft.public.de.security.heimanwender] Re: Habe eine eMail von Public Support (Deepblue,  2. Feb 2004, 20:19:12):
+Gabriele Neukam schrieb:
+
+>On that special day, Michael Sturm, (taxi7000taxi@msn.com) said...
+>
+>> habe eine eMail von "Public Support" erhalten,
+>> in Englisch Betreff: "Newest Net Security Patch"
+>> mit einem Q447175.exe-Anhang.
+>
+>Bitte, wo ist das naechste Universum? Hier ist kein Platz mehr fuer die 
+>Strichliste, nicht mal n-dimensional gefaltet. 
+
+Ich bin dafuer, dass MS mit dem nae. Patch-Day ein Update
+herausbringt, wo
+der Startbildschirm von Windows geaendert wird und danach gross und
+deutlich drauf steht: Wir verschicken keine Patches per E-Mail an
+Sie.
+Und am besten gleich noch ein kurzer Link auf eine Info-Seite
+darunter.
+
+-----------------------------------------------------------------------------
+
+
+
+[de.rec.musik.recherche] Re: irische Volksmusik (Deepblue,  5. Feb 2004, 19:58:29):
+"Lars Wiedersheim" <LarsCW@t-online.de> schrieb
+
+> Ich suche ein Stueck aus der irischen Volksmusik.
+> Es ist meiner Meinung nach relativ bekannt.
+> Wenn man es hoert, bringtmanesgleichmitIrlandinVerbindung.Eswird
+> meistens mit einer Geige oder der irischen Fiddle gespielt.
+
+Deine Beschreibung gleicht dieser:
+"Ich suche einen Song von Bohlen, der absolut grauenhaft klingt".
+
+
+Gruss
+Rolf
+
+-----------------------------------------------------------------------------
+
+
+
+Re: [de.rec.musik.recherche] Re: irische Volksmusik (Lug,  6. Feb 2004, 06:00:45):
+~#! rn=Deepblue rt=1076007509 rg=schmarrn.netdigest
+~#! tid=1076007509
+The Wild Rover...
+
+Lugifer
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: [de.rec.musik.recherche] Re: irische Volksmusik (Zarniya,  6. Feb 2004, 16:12:12):
+~#! rn=Lug rt=1076043645 rg=schmarrn.netdigest
+~#! tid=1076007509
+Whiskey in the Jar....
+
+jaja... ich kann mir nie merken, welchen Whiskey man mit e und welchen ohne
+schreibt.
+
+Marc
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: [de.rec.musik.recherche] Re: irische Volksmusik (Croft,  6. Feb 2004, 16:13:21):
+~#! rn=Zarniya rt=1076080332 rg=schmarrn.netdigest
+~#! tid=1076007509
+Den schottischen schreibt man ohne e.
+
+Croft
+
+-----------------------------------------------------------------------------
+
+
+
+[de.alt.folklore.ddr] Re: Bergsteiger (aus der Super-Illu) (Deepblue,  6. Feb 2004, 21:09:33):
+Ralf Schrader wrote:
+
+> BTW: Wer schreibt wohl die ganzen Computerviren und -wuermer, an denen sich
+> gut verdienen laesst. Script- Kiddies oder Festangestellte?
+
+Dem Code nach zu urteilen, Festangestellte. Selbst Scriptkiddies
+koennen besseren abschreiben.
+
+
+-----------------------------------------------------------------------------
+
+
+
+[de.alt.sysadmin.recovery] Datensicherung - Medienwechsel (Deepblue,  9. Feb 2004, 21:54:38):
+Zum Wochenende noch eine sehr recovery Story aus einem kleinen
+mittelstaendischen Unternehmen:
+
+Dort laeuft in der Entwicklungsabteilung ein kleiner Server dessen Backup
+jede Nacht auf eine DVD gebrannt wird. Das groesste Problem bei dieser
+Loesung war, wer jeweils einen leeren Rohling einlegt damit die
+Sicherung auch laufen kann. Die Leute dort haben dann folgende Loesung
+ersonnen:
+
+Nach dem Backup-Lauf faehrt die Schublade des DVD-Brenners auf. Dort
+unterbricht sie eine Lichtschranke was wiederum dazu fuehrt, dass die
+Stromzufuhr zum Lebenserhaltungssystem (sprich: Abteilungs-Kaffeemaschine)
+unterbrochen wird. Das bedeutet, dass es am naechsten Morgen nur dann
+Kaffee gibt, wenn jemand die Schublade schliesst. Und da kann dieser
+"Operator" dann auch gleich einen neuen Rohling einlegen.
+
+Nach Aussage eines Bekannten der dort arbeitet hatten die seit
+Einfuehrung dieser Methode nur noch einmal Probleme mit dem Backup,
+und das war als die Kaffeemaschine kaputt war. :-)
+
+-----------------------------------------------------------------------------
+
+
+
+[ger.ct] Re: Luther (Deepblue, 10. Feb 2004, 21:21:33):
+Herwig Huener & Josella Simone Playton <webmaster@Josella-Simone-Playton.de>
+writes:
+
+> SF-Story-Vorschlag: Ein ZeitReisender bringt
+> Luther einen PC. Haette es ihm bei der Uebersetzung
+> des Neuen Testamentes geholfen? Waere dann
+> was anders gelaufen?
+
+Meine Vermutungen:
+------------------
+1. Luther waere als Hexer verbrannt worden, denn er bedient sich eines
+Teufelswerkzeuges.
+2. Luther haette die Elektrizitaet erfinden muessen um genuegend "Saft" fuer
+den PC zu haben.
+3. Luther haette die Bibel nicht uebersetzt sondern bis zu seinem Lebensende
+Solitaire gespielt.
+4. Luther waere wahnsinnig geworden, weil die Bibel viel zu umfangreich ist um
+mit Winword(TM) bearbeitet zu werden.
+5. Die mit SYSTRAN uebersetzte Bibel wuerde von sehr viel mehr Menschen
+gelesen werden, und sei es nur weil die Uebersetzung so lustig ist.
+6. Luther haette den PC an das Kirchenportal genagelt und dabei die Festplatte
+zerstoert.
+7. Luther waere an der Tatsache verzweifelt, dass er nach getaner Arbeit zwar
+nun die perfekt uebersetzte Bibel auf seiner Festplatte hat, das DIN A4 Papier
+zum Ausdrucken aber erst in ein paar Jahrunderten erfunden wird.
+8. Luther haette einen privaten Kleinkrieg mit der automatischen
+Rechtschreibkorrektur gehabt.
+9. SCO wuerde heute behaupten, dass auch die Bibel intellektuelles Eigentum
+von SCO enthaelt und die protestantische Kirche verklagen.
+
+-----------------------------------------------------------------------------
+
+
+
+CD (Maarg, 11. Feb 2004, 15:29:06):
+Die unlustige Uebersetzung habe ich weggelassen...
+--- schnipp ---
+
+From: Claudio Del Duca <Claudio_566@gmx.de>
+Subject: Amerikanischer CD Haendler mit Humor...
+Newsgroups: de.rec.musik.rock+pop
+Date:Wed, 04 Feb 2004 10:41:21 +0100
+Message-ID: <opr2uai70bomxiqj@news.gmx.de>
+
+Ich habe mir am Sonntag beim CD-Haendler http://www.cdbaby.com in
+Portland, Oregon 2 Jazz-CDs bestellt. Das an sich ist ja noch nichts
+ungewoehnliches.
+
+Aber am Montag bekam ich per Mail die Bestaetigung dass meine CDs 
+abgeschickt wurden.
+
+Beim Lesen der Mail hab ich mich schlappgelacht, aber lest doch selbst
+(aber beschwert Euch hinterher nicht wenn Ihr vor lachen Bauchschmerzen 
+bekommt):
+
+---Your CDs have been gently taken from our CD Baby shelves with
+sterilized contamination-free gloves and placed onto a satin pillow.
+
+A team of 50 employees inspected your CDs and polished them to make
+sure they were in the best possible condition before mailing.
+
+Our packing specialist from Japan lit a candle and a hush fell over
+the crowd as he put your CDs into the finest gold-lined box that
+money can buy.
+
+We all had a wonderful celebration afterwards and the whole party
+marched down the street to the post office where the entire town of
+Portland waved 'Bon Voyage!' to your package, on its way to you, in
+our private CD Baby jet on this day, Monday, February 2nd.
+
+I hope you had a wonderful time shopping at CD Baby. We sure did.
+Your picture is on our wall as "Customer of the Year". We're all
+exhausted but can't wait for you to come back to CDBABY.COM!!
+
+
+Thank you once again,
+
+Derek Sivers, president, CD Baby
+the little CD store with the best new independent music
+phone: 1-800-448-6369 email: cdbaby@cdbaby.com
+[URL=http://www.cdbaby.com]http://www.cdbaby.com[/URL]---
+
+
+
+-----------------------------------------------------------------------------
+
+
+
+Also nach drei Weizen... (Ronda, 14. Feb 2004, 01:37:02):
+... find ich den echt witzig. Ohne ists vermutlich nur halb so gut...
+
+Ronda
+
+Subject: Re: gas im bier
+From: "Tobias Grassl" <tobias-grassl@gmx.de>
+Newsgroups: de.sci.chemie
+Date: 10 Feb 2004
+
+"philip schoeneberg" <iyunlung@hotmail.com> schrieb:
+
+> hab da mal ne frage bezueglich der blaeschen im bier.
+> und zwar woher kommen die eigentlich?
+
+Im Bier leben ganz kleine Wesen. Man nennt sie "Bier-Mumpelgruempfe".
+Diese ernaehren sich ausschliesslich von Pilzgerichten, die nur aus Hefepilzen
+bestehen.
+Da Mumpelgruempe eine schlechte Verdauung haben, bekommen sie immense
+Blaehungen.
+
+> und welches gas ist es?
+
+Mumpelgrumpf-Blaehungs-Gas.
+
+> und die hefe wird so weit
+> ich gelesen habe auch entfernt..
+
+Klar, von den Mumpelgruempfen.
+
+> kleinen stellen am glas.
+
+Das sind die Mumpelgrumpf-Gaststaetten.
+
+> bitte um erleuchtung! :)
+
+Die gibts in jedem Elektroladen in Form von Taschenlampen. Blink damit mal
+in das Bier, vielleicht blinken die Mumpelgruempfe zurueck...
+
+scnr.
+
+Gruss
+Tobias
+
+-----------------------------------------------------------------------------
+
+
+
+Hacker (Muaddib, 15. Feb 2004, 19:31:00):
+Subject: Re: Hacker CD
+Date: Sun, 08 Feb 2004 16:48:20 +0100
+From: Philipp Letschert <phil@uni-koblenz.de>
+Newsgroups: de.org.ccc
+Message-ID: <pan.2004.02.08.15.48.20.266065@uni-koblenz.de>
+
+Hugo Schulz schrieb:
+
+| Ich will Hacker werden und will mir nun professionelle Software beschaffen,
+| ich habe im Internet folgendes gefunden:
+| http://www.hacker-cd.com/
+|
+| Was haltet ihr davon?
+
+Abstand.
+
+-----------------------------------------------------------------------------
+
+
+
+... (Maarg, 16. Feb 2004, 21:57:37):
+From:"Ralf Gunkel" <group.nospam@ralf-gunkel.de>
+Subject: Re: Qualitaetssicherungssystem ISO 9000
+Newsgroups: de.etc.bahn.stadtverkehr
+Date: Sun, 15 Feb 2004 22:07:54 +0100
+Message-ID: <c0on4p$6g6$06$1@news.t-online.com>
+
+"Alexander Beyrer" <Alex.Beyrer@t-online.de> schrieb
+
+> Ein (neudeutsch) Controlling ist auch nicht schlecht. Ich vermute, dass
+> diese Abteilung -zumindest in meinem Laden- bedeutend mehr kostet, als 
+> sie "unten" einspart.
+
+Du meinst:
+
+3 Methoden eine Firma zu ruinieren:
+
+1. mit Frauen und Suff
+   Das ist die angenehmste.
+
+2. Mit Beratern
+   Das ist die mit der besten Ausrede
+
+3. Mit ISO 9000/2001 und S*P
+   Das ist die sicherste.
+
+*scnr*
+
+
+-----------------------------------------------------------------------------
+
+
+
+Post. (Maarg, 19. Feb 2004, 00:08:43):
+From: Oliver Antwerpen <olli@giesskaennchen.de> 
+Newsgroups: de.alt.fan.fastfood 
+Subject: Re: McDonald's Bonrueckseiten-Aktion 
+Date:Sat, 14 Feb 2004 16:40:57 +0100 
+
+Alexander Koethe <a.koethe@gmx.de> wrote:
+> Hallo,
+> 
+> eben ist mir im McDonald's in Leonberg etwas passiert, was ich so noch
+> nie erlebt habe und Euch daher unbedingt erzaehlen muss:
+> [...]
+
+Hat mich an folgendes erinnert:
+
+Ich hatte eine Mitteilung im Briefkasten, dass ich ein Einschreiben
+bei der Post abholen soll. Ich also in's Auto und zur Post.
+Der Postmensch wollte dann meinen Personalausweis sehen, den ich nicht
+dabei hatte. Mein Fuehrerschein hat nicht gereicht. Jegliches Bitten
+war vergebens und ich hatte mich schon fast damit abgefunden, nochmal
+nach Hause zu muessen, um meinen Perso zu holen.
+Dann kam mir eine Idee: Auf der Rueckseite des Abholscheins konnte man
+eine Person mit der Abholung des Schreibens beauftragen. Kurz mit der
+Dame hinter mir geredet - und dann Ihren Namen eingetragen, sie holt
+das Schreiben, haendigt es mir aus und alle waren gluecklich.
+Ich bin bis heute nicht sicher, wie ich den Gesichtsausdruck des
+Schaltermenschen deuten soll...
+
+Olli
+
+-----------------------------------------------------------------------------
+
+
+
+[de.etc.bahn.bahnpolitik] Re: Mautausfaelle ... (Deepblue, 20. Feb 2004, 20:03:03):
+Ingo Dierck schrieb am 16 Feb 2004 :
+
+>> So hiess es gestern lt. Videotext aus Fraktionskreisen.
+>
+> Jetzt spinnen die doch total. Kann Stolpe nicht selber einen Kredit
+> aufnehmen? Und Bodewigs Kurtchen gleich mit.
+>
+> <schaeum> Oh, das macht mich boese. So boese. </schaeum>
+
+Wende dich an die, die es verbrochen haben, an die Grossmaeuler in der 
+deutschen Industrie.
+Das sie die Politiker aufs Kreuz gelegt haben, steht auf einem anderen 
+Blatt...
+Aber seit einiger Zeit ist wohl die deutsche Industrie an derselben 
+Stelle angekommen wie die amerikanische: Wenn an meinem Produkt ein 
+Problem auftritt, stell ich einen Rechtsanwalt mehr ein. Frueher[TM] 
+nahm man dafuer Ingenieure.
+
+Frank
+
+-----------------------------------------------------------------------------
+
+
+
+Schoene, neue digitale Welt... (Ronda, 21. Feb 2004, 01:18:50):
+Aus eigener - genussvoller - Erfahrung plaediere ich dafuer, dass Sachertorte
+weiter analog serviert wird,
+
+Ronda
+
+From: Andreas Kabel <akabel@penguin.slac.stanford.edu>
+Subject: Re: Spiegel Online
+Newsgroups: de.etc.sprache.deutsch
+Date:Tue, 17 Feb 2004 11:42:59 -0800
+Message-ID: <86brnxcx18.fsf@penguin.slac.stanford.edu>
+
+[...]
+> Demnaechst werden freilich *alle* Kulturgueter *im Normalfall* (auch) 
+> digital vorliegen,
+
+Bis auf Sachertorte.
+
+-----------------------------------------------------------------------------
+
+
+
+Helau (Foobar, 23. Feb 2004, 20:56:02):
+From: Happy Oyster <happy.oyster@ariplex.com>
+Newsgroups: de.etc.beruf.selbstaendig
+Subject: Re: Umzingelt von Besserwissern
+Date: Sat, 21 Feb 2004 02:38:18 +0100
+Message-ID: <tjdd305rogoclsimri2gfdikkjkspj9hog@4ax.com>
+
+On 19 Feb 2004 00:00:00, all2001@gmx.de (Wolfgang Allinger) wrote:
+
+Sehr geehrter Herr Allinger, 
+
+
+>Und nu der neueste Karnevalshit:
+
+wie trennt man das ? 
+
+
+Mit freundlichem Gruss
+
+Aribert Deckers
+
+
+-----------------------------------------------------------------------------
+
+
+
+Nein, nein! (Ronda, 24. Feb 2004, 00:13:06):
+... hier gehts um Newsgroups - nicht die MPA!
+
+Betreff: Re: Kausalitaetsbedingte Dummheit
+Datum: Sat, 21 Feb 2004 07:25:21 +0100
+Von: Johannes Pietsch <Johannes.Pietsch@gmx.de>
+Newsgroups: de.alt.gruppenkasper,de.talk.bizarre
+Follow-Up an: de.alt.gruppenkasper
+Message-ID: <c16to0$oco$02$1@news.t-online.com>
+
+SN: Quote entfernt
+
+Neulich in Sieglar:
+
+
+Chef:      Herrgott, Heinz, was ist denn bloss los mit Dir! Wiiieee
+           oft habe ich Dir gesagt, Du sollst aeaeaeaerst denken und dann
+           posten. Und jetzt guck Dir das an. Schon wieder so ein voellig
+           hirnverbranntes Posting, ohne Sinn und Verstand, und daaaaa,
+           wieder ein beklopptes Crossposting, und dann auch noch ohne
+           Follow-up-to, und dort ein Rechtschreibfehler, und da, und
+           da...
+
+Heinz:     Aeh, aeh...
+
+Chef:      Heinz, rede ich eigentlich gegen die Wand? Erst denken, dann
+           posten, habe ich Dir gesagt? Ich hab die Schnauze voll, es
+           reicht mir jetzt endgueltig...!
+
+Kollege:   Aber Chef...
+
+Chef:      WAS IST???
+
+Kollege:   Der Heinz kann gar nicht denken und posten.
+
+Chef:      Was? Der kann gar nicht denken und posten?
+
+Kollege:   Nein, der Heinz kann wirklich nicht denken und posten.
+
+Heinz:     Werde ich jetzt entlassen?
+
+Chef:      Verdammt, und ich hab das all die Jahre nicht bemerkt.
+
+
+Voiceover: Ueber vier Millionen Menschen in Deutschland koennen nicht
+           richtig denken und posten.
+
+
+Chef:      HEINZ! Da muessewa was machen.
+
+
+           *kling* *BINGELING*
+
+
+Voiceover: Schreib Dich nicht ab! Lern denken und posten!
+
+-----------------------------------------------------------------------------
+
+
+
+[de.admin.net-abuse.mail] Gerade in der Sueddeutschen gefunden... (Deepblue, 27. Feb 2004, 20:58:53):
+...kein extrem wichtiges Thema, aber eine supergute Erklaerung, was Spam ist:
+<zitat>
+Eine Spam-Mail muss man sich vorstellen wie den Besuch von ein paar 
+Zeugen Jehovas: Beide kommen ungebeten, verschaffen sich Eintritt, ohne 
+dass man recht verstuende, wie sie das geschafft haben, versprechen einem 
+Obskures, und wenn sie sich erstmal niedergelassen haben an der 
+heimischen Festplatte, kriegt man sie kaum wieder los. Wie das Jahr fuer 
+die Zeugen Jehovas war, wissen wir nicht, wahrscheinlich hart und 
+traurig, schliesslich ist die Welt wieder nicht untergegangen.
+</zitat>
+
+Der ganze Artikel:
+http://www.sueddeutsche.de/sz/feuilleton/red-artikel1571/
+
+
+-----------------------------------------------------------------------------
+
+
+
+[bln.jugend.talk] Re: Neuer Thread (Deepblue,  2. Mar 2004, 21:05:59):
+From: uwp@dicke-aersche.de (Udo Wolter)
+Subject: Re: Neuer Thread
+Newsgroups: bln.jugend.talk
+Date: 27 Nov 2003 16:22:04 GMT
+Message-ID: <bq58bc$l0o$2@mamenchi.zrz.TU-Berlin.DE>
+
+Michael Diederich <dev-null@md-d.org> wrote:
+>>Seelische Unterstuetzung, koerperliche Ertuechtigungen zwischen einzelnen
+>>SSH Sessions usw. Und irgendwer muss ja auch mal fuer uns Studenten was
+>>vernuenftiges kochen, sonst wuerd ich nur noch Tiefkuehlbaguettes essen.
+>Ich habe mir letzte Woche mal geschnittene Maultaschen in der Pfanne
+>gebraten, so mit Speck/Schicken und Eiern.. Das ist lecker, wenn auch
+>einiges an Aufwand (fuer studentische Verhaeltnisse)
+
+Pfff, ist doch simpel:
+
+apt-get install geschnitteneMaultaschen Pfanne Speck Schinken Eier
+Reading Package Lists... Done
+Building Dependency Tree... Done
+The following extra packages will be installed:
+OelOfenStrom/Gas
+The following NEW packages will be installed:
+geschnitteneMaultaschenPfanneSpeckSchinkenEier
+0 upgraded, 8 newly installed, 0 to remove and 0 not upgraded.
+Need to get 57.6kg of food.
+Get:1 http://shop.frass.de testing/main Oel [1.0kg]
+Get:2 http://shop.mediamarcht.de testing/main Ofen [50.5kg]
+Get:3 http://shop.gelbzeug.de testing/main Strom/Gas [1.1kg]
+Get:4 http://shop.frass.de testing/main geschnitteneMaultaschen [0.3kg]
+Get:5 http://shop.household.com testing/main Pfanne [3.6kg]
+Get:6 http://shop.frass.de testing/main Speck [0.2kg]
+Get:7 http://shop.frass.de testing/main Schinken [0.4kg]
+Get:8 http://shop.frass.de testing/main Eier [10.0Pc]
+Fetched 57.6kg in 130s (0.4kg/s)
+Selecting previously deselected package Oel
+...
+cd /usr/bin
+./essen > /tmp/out
+cat /tmp/out
+ruelps
+
+Mermgfurt,
+Udo
+
+-----------------------------------------------------------------------------
+
+
+
+[de.etc.sprache.deutsch] Re: Warum "Studierende" ?? (Deepblue,  2. Mar 2004, 21:08:55):
+From: Matthias Opatz <spam-cemetery@onlinehome.de>
+Subject: Re: Warum "Studierende" ??
+Newsgroups: de.etc.sprache.deutsch
+Date:Thu, 11 Dec 2003 22:52:53 +0100
+Message-ID: <1sbc1vhvsjv8r$.vqll9rkyu1oy.dlg@40tude.net>
+
+Stefan Ram schrieb:
+> "Stefan Kunze" writes:
+
+[Warum verdraengen Studierende Studenten?]
+>> Kennt jemand die Hintergruende? Vielleicht etwas in Richtung pc?
+> 
+>EinigePersonenschliessen,dass"/der/Student"einen
+>Mannbezeichne,
+
+Das ist erst der Anfang.
+Bald werden wir auch Volksvertretende, Installierende, Lehrende,
+Verarztende, Brieftragende, Schriftstellende und Postende haben. 
+
+Matthias
+
+-----------------------------------------------------------------------------
+
+
+
+[oecher.talk] Re: GEZ-Mailings? (Deepblue,  6. Mar 2004, 18:26:24):
+Subject: Re: GEZ-Mailings?
+From: Oliver Kern <olivers.muell@nurfuerspam.de>
+Newsgroups: oecher.talk
+Date: Thu, 26 Feb 2004 20:27:20 +0100
+Message-ID: <gfycubwel7my.1lsytbqzylvfl.dlg@40tude.net>
+
+Also: Es war einmal am 26.2.2004, da beglueckte uns Klaus Suntrop mit
+folgenden, gueldenen Worten:
+
+> lustige Faelle bei denen ein Hausbewohner aus Spass den Namen seines 
+> Stofftiers an die Klingel gepappt hat (nicht um die GEZ zu aergern), 
+> welches dann auch prompt Post von der GEZ bekommen hat, 
+
+Jo, so einen hab ich auch:
+
+In der WG eines Freundes stand ein Fernseher, fuer den sich niemand so
+richtig zustaendig fuehlte, es sei denn, es kam gerade Star-Trek. Bis
+der GEZ-Mann kam. Der schrieb alle 7 Bewohner der WG anhand der
+Namensschilder an den Zimmertueren auf. Einschliesslich des
+Namensschildes "G. Pinkeln". Er bemerkte nicht mal die
+Lueftungsschlitze an der Tuer.
+Fortan wurden die Gebuehren dann von Herrn Gerhard Pinkeln beglichen.
+Die GEZ hat meines Wissens nie mehr gefragt.
+
+Da frag ich mich: War er zu bloed, zu stolz oder ist es der GEZ einfach
+egal, wer den Blutzoll entrichtet...?
+
+oliver 
+
+-----------------------------------------------------------------------------
+
+
+
+Schweizer (Foobar,  8. Mar 2004, 19:02:13):
+From: Joe Saccone <no_email_@gmx.net>
+Subject: FYI: Stosszahn ueber ebay verkauft
+Newsgroups: de.alt.etc.auktionshaeuser
+Date:Sun, 29 Feb 2004 12:48:23 +0100
+Message-ID: <4042d02e.1478953@news.23annuitcoeptis5.org>
+
+Servus,
+
+aus der gedruckten Version von http://www.20min.ch/ vom Freitag,
+27.02.04:
+
+   Weil am Rhein
+   Einen rund 50 Zentimeter langen Elefantenstosszahn
+   entdeckten Zoellner letzte Woche beim Zollamt Weil am
+   Rhein-Otterbach. Ein Schweizer wollte den Stosszahn in
+   Weil bei der Post aufgeben, wie das Hauptzollamt Loerrach
+   gestern mitteilte. Der Mann hatte den Zahn im Internet-
+   auktionshaus Ebay versteigert und wollte ihn dem Kaeufer
+   senden. Der Schweizer wurde angezeigt und der Stosszahn
+   beschlagnahmt.
+
+Okay, der Stosszahn ist weg und es gibt eine Anzeige. Aber viel
+schlimmer wird wohl die negative Bewertung des wartenden Kaeufers
+ausfallen....   ;-)
+
+Gruss
+JoeS
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Schweizer (Gloinson,  8. Mar 2004, 19:08:38):
+~#! rn=Foobar rt=1078768933 rg=schmarrn.netdigest
+~#! tid=1078768933
+Was ist eigentlcih, wenn des Mannes Familie das Teil seit 70 Jahren in
+Familienbesitz hatte? Macht er sich dann auch strafbar, weil derzeit geltendes
+Gesetz Einfuhr verbietet? Oder Ausfuhr? Oder Handel? Elfenbein haelt sich ja
+relativ lange, eine Karotte am Tag und der Elf ist zufrieden.
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Schweizer (Foobar,  8. Mar 2004, 19:10:00):
+~#! rn=Gloinson rt=1078769318 rg=schmarrn.netdigest
+~#! tid=1078768933
+F'up2 de.soc.recht.misc ;o)
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Schweizer (Gloinson,  8. Mar 2004, 19:11:11):
+~#! rn=Foobar rt=1078769400 rg=schmarrn.netdigest
+~#! tid=1078768933
+Mach mal. Und dann einen EOD-XPost hierher bitte ;)
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: Schweizer (Foobar,  8. Mar 2004, 19:12:27):
+~#! rn=Gloinson rt=1078769471 rg=schmarrn.netdigest
+~#! tid=1078768933
+Sorry, ich lese de.soc.recht.misc nicht (mehr). :o)
+
+-----------------------------------------------------------------------------
+
+
+
+Windows und Bluescreens... (Ronda,  8. Mar 2004, 21:13:08):
+... nett. Ok, ok, ich mag Bildschirmschoner einfach ;-)))
+
+Ronda *hat grad C64-Screenshots im Bildschirmschoner: Elite, Donkey Kong, Pac
+Man... ;-) *
+
+From: Wolf Wiegand <wolfwiegand@yahoo.de>
+Newsgroups: de.org.ccc
+Subject: Re: Windows-Uptime: Mach auch Du den Pepsi-Test
+Date: Sat, 06 Mar 2004 22:21:49 +0100
+Message-ID: <c2dfde$1r6j9o$1@ID-141574.news.uni-berlin.de>
+
+Andreas Wiese schrieb:
+
+> Man soll es kaum glauben, ich kann mich an meinen letzten Bluescreen
+> unter Windows ueberhaupt nicht erinnern...  
+
+Ich schon. Bei meinem ehem. Arbeitgeber hatten $KOLLEGE und ich es uns 
+zum Sport gemacht, den jeweils anderen moeglichst schoen zu verarschen. 
+Mal am Monitor den anderen VGA-Eingang eingestellt ('Komisch, nicht mal 
+ein Reboot hilft.'), mal den Testrechner des Kollegen kreativ veraendert. 
+Solche Sachen halt, eine Zeitlang lag ich in Fuehrung. Das Golden Goal 
+kam dann allerdings von meinem Kollegen: Es war kurz vor Feierabend. Ich 
+wurde mal wieder durch das Telefon von meiner Arbeit abgelenkt. 
+Anscheinend war es allerdings ein nicht voellig sinnfreies Gespraech, denn 
+ich muss beim Telefonat >4 min lang meine Haende von der Tastatur 
+genommen haben. Auf einmal 'BING' - Bluescreen. Ich wunderte mich 
+zuerst, denn normalerweise passierte das nur, wenn ich die Lautstaerke in 
+der 'Lautstaerkeanzeige'(?) aendern wollte, ansonsten lief der Rechner 
+ueber Wochen hinweg stabil. Naja, Murphy halt. Also Reboot eingeleitet 
+und ab in die Kueche, erst mal eine rauchen. Als ich wiederkomme, wird 
+mir etwas unwohl. Dutzendhaft Meldungen, dass das Dateisystem beschaedigt 
+sei und NT probiere, es zu reparieren. Unmengen von Dateien werden als 
+unreparierbar defekt gemeldet. Und zwar genau die Dateien, die, sollten 
+sie nicht existieren, ein Boot-up von NT definitiv verhindern. Vor 
+meinem geistigen Auge sah ich die Unmengen von Konfigurationsdialogen 
+von Explorer und Visual Studio (als echter Windows-Admin speichert man 
+sein Profil natuerlich nicht auf einem Server, ist eh viel zu lahm), die 
+Berge von CDs, die ihrer Neuinstallation harren. Waehrend ich also 
+beinahe heulend vor meiner Workstation sass und ich $KOLLEGE2 von meiner 
+schweren Last berichtete ($CHEF hatte ich natuerlich auch schon gesagt, 
+dass ich heute 'etwas' laenger arbeiten werde), kam $KOLLEGE rein. Er 
+hoerte sich mein Geheul an, sagte 'Ach, das ist doch nicht so schlimm', 
+ging an meine Tastatur und drueckte die Ctrl-Taste. Der Bildschirm wurde 
+kurz schwarz, dann gruen, und in der Bildschirmmitte erschien der 
+NT-Dialog zur Eingabe meines Passwortes, um die Station zu entsperren. 
+Scheisse. Ich war tatsaechlich auf den %"$&!-Bluescreen-Bildschirmschoner 
+von sysinternals.com reingefallen.
+
+$KOLLEGE hat am naechsten Tag von mir das Fruehstueck ausgegeben bekommen, 
+als Preis fuer den ersten Platz in unserem Wettbewerb.
+
+Wolf
+
+-----------------------------------------------------------------------------
+
+
+
+Bielefeld und die Strassenbahn... (Ronda,  8. Mar 2004, 21:16:28):
+... die aber eigentlich eine U-Bahn ist! Die kuerzeste Deutschlands IMHO.
+
+Ronda *eine von IHNEN, da dort aufgewachsen*
+
+Newsgroups: de.etc.bahn.eisenbahntechnik
+Subject: Re: Ebula :  Neue Stoerquelle im Bahnverkehr
+From: Matthias Warkus <mawarkus@gnome.org>
+Date: Fri, 27 Feb 2004 13:50:48 +0100
+Message-ID: <slrnc3uf97.1f5.mawarkus@highwaystar.klinkenbuchse.de>
+
+27 Feb 2004 11:10:23 GMT, message by
+Martin Bienwald <martin.bienwald@gmx.de>:
+>  "Oliver Gro?" schrieb:
+> > " Folke Brockmann" <Folke.Brockmann@Verkehrsplanung.Org> schrieb im
+Newsbeitrag
+>  
+> >> Immerhin hat Bielefeld eine St?dtische Strassenbahn! ;-)
+>  
+> > Wie kann eine Stadt, die es ja gar nicht gibt, eine Stra?enbahn haben ???
+>  
+>  Altes Prinzip der Logik: aus einer falschen Praemisse lassen sich beliebige
+>  Folgerungen ziehen ...
+
+<debk>
+Eigentlich gibt es keine falschen Praemissen, nur negierte...
+Besser waere die Formulierung "aus zwei widerspruechlichen Praemissen
+lassen sich beliebige Folgerungen ziehen". Im Kalkuel sieht das dann so
+aus, dass man, wenn sowohl A als auch non-A schon vorgekommen sind,
+ein beliebiges C ohne Abhaengigkeiten einfuehren darf.
+
+Im genannten Fall geht es aber ohnehin um Quantorenlogik, und
+Allaussagen implizieren da normalerweise keine Existenz; es bedeute Bx
+"x ist Bielefeld" und Sx "x hat eine Strassenbahn":
+
+1. "Bielefeld existiert nicht":
+   \neg\exists x Bx
+2. "Bielefeld hat eine Strassenbahn":
+   \forall x (Bx \rightarrow Sx)
+
+1. wird zu 3. \forall x \neg Bx
+
+...und da verliessen sie ihn, mehr laesst sich nicht ableiten. Wenn ich
+jetzt ein c einfuehre, ergibt sich bei mir, dass c nicht Bielefeld ist,
+aber eine Strassenbahn haette, wenn es Bielefeld waere, und nicht mehr :)
+</debk>
+
+mawa
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Windows und Bluescreens... (Muadib,  8. Mar 2004, 23:56:04):
+~#! rn=Ronda rt=1078776788 rg=schmarrn.netdigest
+~#! tid=1078776788
+das ist nich witzig, ich hatte den bildschirmschoner auch auf meinem rechner
+und besorgte kollegen haben ihn dann abgeschaltet
+grrrrrrrrrrrrrrrr
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Windows und Bluescreens... (Zook,  9. Mar 2004, 09:18:28):
+~#! rn=Muadib rt=1078786564 rg=schmarrn.netdigest
+~#! tid=1078776788
+Worum waren die Kollegen besorgt?
+
+Zook.
+
+-----------------------------------------------------------------------------
+
+
+
+[arcor.misc] Re: Suchtexperte fordert spezielle Fachgeschaefte fuer Alkohol (Deepblue, 14. Mar 2004, 20:55:43):
+Arcor Newsticker <dpa@arcor-online.net> wrote:
+
+>Koeln (dpa) - Alkoholische Getraenke sollten nach einer
+>Forderung der Deutschen Hauptstelle fuer Suchtfragen nur noch in
+>speziellen Fachgeschaeften verkauft werden.
+
+Recht so! Nur ein Fachgeschaeft garantiert die qualiizierte
+Beratung: "Nehmense doch $SPRIT! Der ist im Angebot. Gleiche
+Menge, gleicher Preis, aber 7,5% Umdrehungen mehr."
+
+>In Tankstellen zum Beispiel haetten derartige Getraenke nichts
+>verloren, sagte DHS-Hauptgeschaeftsfuehrer Rolf Huellinghorst dem
+>Koelner Stadt-Anzeiger.
+
+Da ist allerdings was Wahres dran.
+
+>Eine Sensibilisierung beim Jugendschutz erhofft
+>sich der Suchtexperte von der Debatte ueber eine Sondersteuer
+>auf so genannte Alcopops.
+
+Alcopops sind eh nur was fuer Weicheier. Wer auf das Zeug steht,
+kauft eben die Bestandteile steuerbeguenstigt in verschiedenen
+Gebinden. Da kann er das meist jaemmerliche Mischungsverhaeltnis
+gleich noch etwas aufbohren.
+
+Obwohl: Damals[tm], als Alcopops noch 'Apfelkorn' hiessen, kam dem
+Zeug durchaus suchtpraeventive Wirkung zu. Eine Ueberdosis davon,
+und man war fuer lange Zeit vor jeder Gefahr des Alkoholabusus
+gefeit.
+
+>Mit dem Thema beschaeftigt sich morgen der Bundestag.
+
+Prost!
+
+-----------------------------------------------------------------------------
+
+
+
+Schoenen Urlaub! (Ronda, 15. Mar 2004, 23:32:46):
+From: Andreas Iwanowitsch <a.iwanowitsch@gmx.de>
+Newsgroups: de.alt.talk.unmut
+Subject: Re: Unmut =?iso-8859-1?Q?=FCber=20Reisebeschr=E4nkungen?=
+Date: Fri, 12 Mar 2004 08:30:12 +0100
+Message-ID: <c2rp57$20u9bl$3@ID-121512.news.uni-berlin.de>
+
+Torsten Mueller schrieb:
+
+> Unmut darueber, dass Deutsche immer einen verdammt begrenzten Horizont
+> haben. Eigentlich verreist man ja ohnehin nur in deutschsprachige
+> Laender, ins Zillertal meinetwegen oder noch nach Suedtirol
+
+Zwangslaeufig. Waehrend Amis voraussetzen, dass in jeder Ecke der Welt
+Englisch gesprochen und verstanden wird, kann der Deutsche nicht davon
+ausgehen, sich im Ausland verstaendlich machen zu koennen. Das schraenkt
+die Reisemoeglichkeiten empfindlich ein.
+
+> und da
+> sitzt man dann drei Wochen in seiner Ferienwohnung, wie schon letztes
+> Jahr und vorletztes Jahr. Wenn man doch mal nach ausserhalb verreist,
+> dann dahin, wo's warm ist, und im Norden ist es nie warm.
+
+So ist es. Kalt und regnerisch ist es auch hier, da koennte man gleich da
+bleiben und jede Menge Kohle sparen.
+
+> man Skandinavien
+
+Sommer: Regnerisch, Stechmuecken. Winter: Kalt, Schnee. Die Landschaft
+besteht aus Baeumen.
+
+> man Island
+
+Sommer: Kalt, regnerisch. Winter: Saukalt, Regnerisch. Die Landschaft
+ist kahl.
+
+> man UK
+
+Sommer: Lauwarm, regnerisch. Winter: Lauwarm, regnerisch. Das Essen ist
+miserabel, ausserdem faehrt man auf der falschen Seite.
+
+> man Irland
+
+Sommer: Lauwarm, regnerisch. Winter: Lauwarm, regnerisch. Die Landschaft
+besteht aus Wiesen, die Bevoelkerung aus Schafen.
+
+> man Sibirien
+
+Sommer: Lauwarm. Winter: Saukalt. Die Landschaft besteht aus Baeumen, die
+Bevoelkerung aus Ostblockstaatlern (--> Kriminalitaet) und Braunbaeren.
+
+> man Mittelasien
+
+Was verstehst Du unter Mittelasien? Etwa sowas wie:
+
+> man Indien
+
+Die werden demnaechst einen Krieg mit Pakistan anfangen. Ausserdem ist das
+Essen zu scharf.
+
+> man Mexico
+
+Es ist heiss, und die Luft ist duenn. Das Essen ist scharf, das Bier
+schmeckt merkwuerdig und ist teuer.
+
+> man Kanada
+
+s. unter Skandinavien, nur dass noch mehr Baeume vorhanden sind.
+
+> Australien brennt nur ein bisschen, meist im Suedosten. Es hat
+> allerdings den grossen Vorteil, dass man von dem ganzen primitiven
+> europaeischen Gesocks verschont wird, das "Urlaub" lediglich mit "drei
+> Wochen saufen und ficken" gleichsetzt.
+
+Dafuer hat man es mit australischem Gesocks zu tun, das dies 52 Wochen
+als Lebensmotto ausgewaehlt hat. Bis auf den Suedwesten, wo es brennt,
+besteht das Land aus Wueste, von einem kleinen Teilgebiet abgesehen, wo
+es Suempfe gibt, die von Krokodilen bewohnt werden.
+
+Ich bleibe lieber in der Pfalz.
+
+Andreas
+
+-----------------------------------------------------------------------------
+
+
+
+[feuerwehrmann.kommunikation] Re: Gelder fuer digitale n (Polizei-)Funk (Deepblue, 22. Mar 2004, 20:15:59):
+[SN: Bezogen auf unsinnige oder gescheiterte deutsche Projekte der
+juengeren Vergangenheit, wie z.B. Transrapid, UMTS und eben den besagten
+Tetra-Funk]
+
+Ingo Horn wrote:
+
+> Irgendwie machts in
+> Deutschland dauerhaft keinen spass mehr, Ingenieur zu sein...
+
+Von der technischen Anforderung her (und teilweise auch deren techn.
+moegliche Realisierung) braucht man sich fuer keins dieser
+Projekte/Produkte zu schaemen.
+
+Zitat eines meiner ehem. Profs:
+Ingenieure sind die Kamele, auf denen die BWLer zum Erfolg reiten.
+
+Das Problem in Deutschland ist derzeit wohl eher, dass die BWLer zu bloed
+zum Reiten sind, aller Welt erzaehlen, dass sie fliegen koennen, und/oder
+die Kamele mit immer weniger Wasser, immer schneller laufen lassen
+wollen.
+
+-----------------------------------------------------------------------------
+
+
+
+Ich habs endlich verstanden... (Ronda, 22. Mar 2004, 22:43:04):
+... wie das mit den Koerben und den Frauen funktioniert...
+
+Ronda *behauptete relativ lange, BB wie "BuegelBrett" zu haben...*
+
+From: Vinzent 'Gadget' Hoefler <nntp-2004-03@t-domaingrabbing.de>
+Subject: Re: Virtuelle Tastatur now?
+Newsgroups: de.alt.sysadmin.recovery
+Date: Mon, 22 Mar 2004 11:23:42 +0100
+Message-ID: <qdft5054ucc551p1v0rmq5rhtfs7faetai@jellix.jlfencey.com>
+
+Gabriele Conrad wrote:
+
+> Marc Haber schrieb:
+>
+>> Ich glaube, bei BHs wird das Koerbchen bei Verdoppelung des Buchstabens
+>> groesser.
+>
+> Bullshit. AA ist kleiner als A, DD ist groesser als D. Das folgt keinem
+> logischen Prinzip.
+
+Dochdoch, die Standardgroessen sind ja:
+
+A - Acceptable
+B - Beautiful
+C - Colossal
+D - Dramatic
+E - Enormous
+
+Demzufolge muesste "AA = Almost Acceptable" und "DD - Dangerously
+Dramatic" gelten.
+
+
+Vinzent.
+
+-----------------------------------------------------------------------------
+
+
+
+[bln.verkehr] Re: Jagd auf angebliche Schwarzfahrer (Deepblue, 26. Mar 2004, 21:19:09):
+[SN: Bert antwortete auf einen Poster, der eine begin-end-Konstruktion in
+seinerSignaturehatte.]
+"Bert Knoop" <b.knoop@gmx.com> wrote:
+
+>Was haengst du eigentlich fuer eine komische Datei bei deinen Postings an???
+>"schulmaedchentagebuch.txt" klingt nicht gerade serioes?
+>Das ist mindestens das 2. Posting.
+>Wenn du diese Datei absichtlich anhaengst, bitte ich dich, das zu
+>unterlassen. Wenn dieser Anhang nicht beabsichtigt ist, pruefe deinen Rechner
+>auf Viren und Wuermer.
+
+Das solltest Du allerdings dringend mit DEINEM Rechner tun, denn an
+Christians Posting haengt definitiv keine Datei.
+
+Dein Rechner ist wahrscheinlich mit einem Virus namens "Outlook
+Express" infiziert, welcher ein- und ausgehende Postings willkuerlich
+manipuliert und verstuemmelt, und zudem einen idealen Naehrboden fuer
+zahlreiche Wuermer bildet. Trotz vieler Warnungen seit Jahren grassiert
+das Ding leider immer noch.
+
+Hergen
+
+-----------------------------------------------------------------------------
+
+
+
+[de.rec.film.misc] Re: Was nervt euch im Kino? (Deepblue, 26. Mar 2004, 21:25:07):
+Alan Tiedemann (at__0815@hotmail.com) wrote:
+
+> Ja, nach der Werbung, vor dem Film. Licht an, "Moechte noch jemand
+> ein Eis?" - und dann geht's los. Kann durchaus mal laenger als fuenf
+> Minuten dauern. Echt aetzend.
+
+Hier gab's mal ein Kino, da war das richtig kultig, weil die 
+Eisverkaeuferin das Talent zu einer Alleinunterhalterin hatte. Da war 
+auch immer rege Nachfrage nach Eis, allein um die Sprueche zu hoeren. 
+
+Bis auf diesen einen Abend, als kurz nach dem Leinwand-Hinweis "Pause" 
+die tiefe Stimme eines Kutte-tragenden, finsteren und massigen 
+Klischee-Bikers durch den Saal knurrte "Wer jetzt n Eis kauft kricht 
+nachher aufs Maul". Das kam an. Die Verkaeuferin konnte sich die Stille 
+im Saal und den Nullabsatz wohl nicht erklaeren ;-)
+
+-----------------------------------------------------------------------------
+
+
+
+Spritpreis? (Vanion, 29. Mar 2004, 22:27:02):
+From: Lutz Schulze <lschulze@netzwerkseite.de>
+Subject: Re: Benzipreise gefallen 2004?
+Newsgroups: de.etc.finanz.misc
+Date:Sat, 27 Mar 2004 14:06:00 +0100
+
+...
+
+Ich halte es fuer ein oft nicht ausreichend gewuerdigtes Ergebnis
+rot-gruener Politik, dass unser Kraftstoffpreis mittlerweile nahezu
+unabhaengig vom Weltmarkt fuer Rohoel ist.
+
+V*
+
+-----------------------------------------------------------------------------
+
+
+
+Das duerfte selbst Zivis Spass machen...? (Ronda, 12. Apr 2004, 23:46:55):
+Message-ID: <yks4qrutr0k.fsf@lmr.khm.de>
+Subject: Re: Bilder!
+Date: Thu, 08 Apr 2004 17:42:51 +0200
+From: Thorsten Lange <lange@lmr.khm.de>
+Newsgroups: de.alt.sysadmin.recovery
+
+Peter Fetzer writes:
+> > P: "Wir suchen eine langhaarige Person mit Armee Klamotten "
+> > P: "und Bart."
+>
+> So muesste mal einer nach Urlaub oder Einsatz an der Wache auftauchen.
+> :=)
+
+Kein Problem - fuer Reservisten. :-)
+
+Ein Kollege erzaehlte mal von einer netten Beobachtung waehrend seiner
+Wehrdienstzeit: Ein Unteroffizier hatte gerade begonnen, einen Uniform
+und Vollmatte tragenden Herrn maechtig anzuscheissen... Der hob einfach
+nur seine Haarpracht von den Schulterklappen, stellte den
+Unteroffizier ins Achtung, hielt ihm eine Standpauke uns liess ihn dann
+wegtreten.
+
+Der Vollmattentraeger war Reservist...
+
+...und Offizier...
+
+...genauer gesagt: Major.
+
+Bye,
+Thorsten
+
+-----------------------------------------------------------------------------
+
+
+
+Romantik? (Ronda, 13. Apr 2004, 00:40:16):
+From: Bernhard Nowotny <bnow@gmx.de>
+Newsgroups: de.alt.folklore.urban-legends
+Subject: Re: =?iso-8859-1?Q?Kr=F6tenzeit?=
+Date: Sat, 10 Apr 2004 12:27:10 +0200
+Message-ID: <4077CBFE.7EDDF1F3@myspot.de>
+
+Rene Marth wrote:
+> 5. Man pumpe das Tier auf
+> 6. Man entzuende den Klebstoff
+> 7. Man setze das Tier zurueck in den Teich
+> 8. Man erfreue sich an einem beleuchtetem Motorboot
+> a) Besonders romantisch in der Daemmerung
+> UL?
+
+Ich halte es fuer eine UL, dass die uebliche Zielgruppe von
+$ROMANTIK das auch so empfindet.  :)
+
+Servus,
+
+
+Bernhard
+
+-----------------------------------------------------------------------------
+
+
+
+Schlicht und schoen. (Ronda, 14. Apr 2004, 22:52:34):
+MID:    <dq6j701rvfcaflh5kalcbldo6q32uao2ja@4ax.com>
+Date:   11.04.04
+Group:  de.rec.fotografie
+From:   didis.mehlbox@web.de (Dieter Lefeling)
+
+Tom Kurpjuweit schrieb:
+
+> Ich will mal einen Thread ueber das im Subjekt stehende Thema
+> lostreten: Was ist die groesste Panne, die Euch je im Bezug auf die
+> Fotografie passiert ist.
+
+Die "groesste"...? Hmmm... 8-)
+...aber das hier ist auch hinreichend daemlich:
+
+Provisorische Laborsitzung in der Kueche. Gerade ist ein grosses Blatt
+Papier aufwendig unter Einsatz aller Finger belichtet und soll in den
+Entwickler, da duedelt nebenan das Telefon. Mist - wohin jetzt mit dem
+Blatt? Wieder in schwarze Folie einwickeln und zurueck in die Papier-
+schachtel? Dauert zu lange und ist zu fummelig. Der Kuechenschrank? Ist
+nicht lichtdicht. Papierkassette? Hab' ich nicht. Aber *schnips* - Idee!
+Da ist doch noch der Kuehlschrank! Also Tuer auf, uuund... #-)))
+
+Dieter
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Schlicht und schoen. (Zook, 14. Apr 2004, 23:09:46):
+~#! rn=Ronda rt=1081975954 rg=schmarrn.netdigest
+~#! tid=1081975954
+Erinnert mich an die Architektenpanne in einem Labor einer mit bekannten
+Universitaet: Die Tueren zur Dunkelkammer hatten Bullaugenfenster.
+
+Zook.
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Schlicht und schoen. (Zook, 14. Apr 2004, 23:11:14):
+~#! rn=Zook rt=1081976986 rg=schmarrn.netdigest
+~#! tid=1081975954
+Ahja, ich vergas: Zwischen den einzelnen Dunkelkammern waren aufwaendige
+Schleusen, damit da kein Licht durchfallen kann... aber jede Dunkelkammer
+hatte ein Bullaugenfenster zum Gang, auf dem das Licht per Bewegungsmelder
+automatisch angeht.
+
+Zook.
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Schlicht und schoen. (Arathorn, 14. Apr 2004, 23:11:40):
+~#! rn=Zook rt=1081976986 rg=schmarrn.netdigest
+~#! tid=1081975954
+Sehr nett ist auch die Idee eines Bekannten, der meinte, wenn er eine Tube
+schwarze Abtoenfarbe in einen Eimer weisse Farbe mischt, koennte er damit
+seine Dunkelkammer schwarz anstreichen.
+
+Das allerbeste daran ist, dass er eigentlich eine Ausbildung an einer
+Design-Schule gemacht hat, incl. Farbenlehre...
+
+Arathorn.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Schlicht und schoen. (Zook, 14. Apr 2004, 23:13:29):
+~#! rn=Arathorn rt=1081977100 rg=schmarrn.netdigest
+~#! tid=1081975954
+Aber warum, es heisst doch "Abtoen"-Farbe ;)))
+
+Zook grinst.
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Schlicht und schoen. (Orktoeter, 14. Apr 2004, 23:22:55):
+~#! rn=Zook rt=1081976986 rg=schmarrn.netdigest
+~#! tid=1081975954
+Das ist ja "nur" aergerlich.. die TU Wien hat es geschafft, von einem eigenen
+Architekturprof. ein Hochhaus (incl. Laboren fuer die Chemiker) planen (und
+bauen) zu lassen, das nur ein Treppenhaus hat... Sie haben dann aussen eine
+Notfalltreppe angebracht.
+
+OrkT.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Schlicht und schoen. (Gloinson, 15. Apr 2004, 02:29:37):
+~#! rn=Orktoeter rt=1081977775 rg=schmarrn.netdigest
+~#! tid=1081975954
+Fotografie war das Thema? Achja, erste Klassenfahrt. Ich verleih einen Film,
+der Apparat der Tante frisst den aber nur halb auf und spuckt ihn wieder aus.
+Zwei Tage spaeter habe ich selbst Filmnot und die Preise am Ort sind horrend.
+Naja, wozu hat man noch ein, zwei Schwarzweiss-Kapseln? Also dem
+Zimmerbewohner samt anwesender Maedchen bei Todesstrafe verboten das Licht in
+der Toilette anzumachen (man ahnt was kommt), dorthin verzogen, Metallkapsel
+geknackt und angefangen mit Nagelschere eine Lasche zurechtzuschnippeln um den
+Farbfilm auf die Patrone zu ziehen. Tja, dann soffen sie draussen ploetzlich
+Bruederschaft, gingen sich maechtig an die Waesche und schmissen zu zweit den
+Kerl beim Knutschen an die Wand. Und den Schalter. Gnagnagnagna. Die waren
+dann zwei Tage sehr kleinlaut.
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: Schlicht und schoen. (Pilgrim, 16. Apr 2004, 11:32:05):
+~#! rn=Gloinson rt=1081988977 rg=schmarrn.netdigest
+~#! tid=1081975954
+Oh ... 
+Hier in Krakau steht ne 20stoeckige Bauruine (Rohbau) ... war ein Neubau der
+Akkademie Oekonomie und Wirtschaftswissenschaften ... tja, dient jetzt als
+Beispiel, wie manns nicht machen sollte ;-)
+
+*r
+
+-----------------------------------------------------------------------------
+
+
+
+Nichts fuer Stones-Fans (Ronda, 20. Apr 2004, 22:29:04):
+From: Bernd Gramlich <bernd@tenuki.de>
+Newsgroups: de.alt.talk.dunkle-seite
+Subject: Re: Besonders Dunkel [tm]
+Date: Mon, 19 Apr 2004 13:27:40 +0200
+Message-ID: <c3d06c.2p.ln@tenuki.de>
+
+Silke Breul wrote:
+
+> Bernd Gramlich meinte:
+>> Silke Breul wrote:
+>>> Bernd Gramlich meinte:
+>>>> Silke Breul wrote:
+>>>>> Bernd Gramlich meinte:
+>>>>> 
+>>>>>>>>>>>>>>> Ein Schelm wer Boeses dabei denkt... ;-)
+>>>>>>>>>>>>>> Du Schelm!
+>>>>>>>>>>>>> <entruestet>ICH?</entruestet>
+>>>>>>>>>>>> Wer sonst?
+>>>>>>>>>>> Du?
+>>>>>>>>>> Das waere aber nichts neues. ;)
+>>>>>>>>> Ich waere aber eine Schelmin. Und dieses Wort gibt es bestimmt
+>>>>>>>>> nicht. (Sieht ja fast aus wie eine Krankheit.)
+>>>>>>>> Moechtest Du eine Lizenz dafuer?
+>>>>>>> Ist das mit einer Bedingung verknuepft?
+>>>>>> Zehn besonders Dunkle [tm] Postings genuegen mir als Kaufpreis.
+>>>>> Besonders Dunkel[tm].
+>>>>> (Dies ist das erste besonders Dunkle [tm] Posting.)
+>>>> Aussergewoehnlich Dunkel [tm] daran finde ich, dass Du gar nicht
+>>>> einmal ans Feilschen denkst.
+>>> Besonders Dunkel [tm].
+>>> (Dies ist das zweite besonders Dunkle [tm] Posting.)
+>>> Soll ich Dir mehr bieten? ;-)
+>> Du verwechselst Feilschen mit Versteigern.
+> 
+> Besonders Dunkel [tm].
+> (Dies ist das dritte besonders Dunkle [tm] Posting.) 
+> 
+> Ist es beim Feilschen verboten, den Preis nach oben zu feilschen?
+
+Eigentlich soll man das als Kaeufer sogar. Allerdings wird dabei
+stillschweigend erwartet, dass man als Einstiegspunkt einen geringeren
+Preis als den des Verkaeufers waehlt.
+
+Das erinnert mich an eine nette Anekdote aus dem Sommer 1998. Meine
+Freundin aus Kanada und ich waren fuer einen Kurzbesuch in Berlin. Nach
+einer ausfuehrlichen Stadtbilderklaerung wollte ich ihr auch noch das
+Olympiastadion zeigen, das sie besonders interessierte. Dummerweise
+gastierten an diesem Abend gerade die Rolling Stones dort. Also blieb
+uns nichts anderes uebrig, als auf dem Schwarzmarkt vor dem
+Stadioneingang ein Paar Karten zu erwerben.
+
+Das Angebot war sehr ueppig, weil offenbar viele Fans die Begeisterung
+ihrer Freunde stark ueberschaetzt hatten. Man bekam von ueberall her
+Karten gezeigt, und die Leute waeren schon zufrieden gewesen, wenn sie
+den aufgedruckten Einkaufspreis wieder zurueckbekommen haetten. Das war
+also eine ideale Gelegenheit, meine Technik des unbarmherzigen
+Feilschens wieder einmal anzuwenden. Ich stellte mich breitbeinig
+zwischen S-Bahnausgang und Stadion und verkuendete lautstark, dass ich
+zwei gute Tribuenenkarte zu genau der Haelfte ihres nominellen Werts
+kaufen wolle. Etliche Moechtegernverkaeufer standen etwas verzweifelt um
+mich herum und ueberlegten angestrengt, ob sie sich auf mein
+unmoralisches Angebot einlassen sollten. Die Minuten bis zum
+Konzertbeginn verrannen schmerzhaft fuer sie alle (und fuer meine
+Freundin, die im Gegensatz zu mir die Stones recht gern hatte), bis
+sich einer von ihnen ein Herz nahm und mit mir zu feilschen begann.
+Ausgehend vom nominellen Wert kam er mir Mark um Mark entgegen, aber
+ich bewegte mich keinen Millimeter von meiner Maximalforderung weg. Auf
+halbem Weg gab er schliesslich auf, rief "Was soll's!" und liess sich auf
+meinen Preis ein. Ein Raunen kam von seiner und meiner Freundin und von
+der Menge um uns herum, aber genau genommen waren eigentlich alle
+zufrieden.
+
+Die Karten waren echt klasse. Man hatte einen tollen Blick auf das
+gesamte Stadion, so dass ich wunderbar dessen Geschichte erklaeren
+konnte. Ausserdem waren wir durch das Dach gut geschuetzt und konnte
+schmunzelnd mit ansehen, wie die doofen Stones triefnass geregnet
+wurden.
+
+Irgendwie war das mein bisher schoenstes Sightseeing.
+
+-----------------------------------------------------------------------------
+
+
+
+Neulich im IRC ... (Amaryllis, 21. Apr 2004, 18:07:11):
+[leicht gek|rzt]
+
+From: Christoph Biedl <cbiedl@gmx.de>
+Date: Mon, 19 Apr 2004 21:16:34 +0200
+To: $Mailingliste
+Subject:  Neulich im IRC ...
+
+Kann's mir mal wieder nicht verkneifen, human gateway zu spielen ...
+
+21:10 <@foo>     oh, gerade Wer wird Millionaer: "Zu wem begab sich
+                 Heinrich IV. 1077 auf seinem Gang nach Canossa?"
+21:10 <@foo>     a) Koenigin Elisabeth I.
+21:10 <@foo>     b) Maria von Medici
+21:10 <@foo>     c) Kaiser Friedrich II.
+21:10 <@foo>     hmm, jetzt sind die Antworten weg
+21:11 <@foo>     d) Papst Gregor VII.
+21:12 <@barbaz>  e) Ulli Horlacher
+21:12 <@foo>     sooo alt ist der? :)
+
+Chri- "names changed to protect those who deserve it" stoph
+
+-----------------------------------------------------------------------------
+
+
+
+Manchmal habe ich das Gefuehl, ... (Ronda, 29. Apr 2004, 23:58:25):
+... dass der Vorname doch Einfluss auf den Charakter hat...
+
+Ronda *nix fuer ungut, A* :-) *
+
+From: Adrian Suter <adrian.usenet@wortrei.ch>
+Newsgroups: de.alt.sysadmin.recovery
+Subject: Re: Fragebogen
+Date: Mon, 26 Apr 2004 11:41:01 +0200
+Message-ID: <c6ilf9$caa8t$1@ID-807.news.uni-berlin.de>
+
+Achim Grolms <achim@grolmsnet.de> scripsit:
+
+>Es nervt aber, wenn auf Parties immer nur
+>Heavy Metal gespielt wird!
+>
+>Man kann auch mal an die anderen denken und 
+>Thrash Metal, Speed Metal oder Death Metal auflegen! 
+
+Was mich immer wieder erstaunt, ist, dass jede minimale Abweichung gleich
+eine neue Stilbezeichnung braucht.
+
+Vielleicht sollte ich das auch tun. Vielleicht sollte ich sagen, ich mag
+gern "Early Vienna Minimal Slow Classic" statt "Streichquartette von Haydn,
+besonders die langsamen Saetze".
+
+Adrian
+
+-----------------------------------------------------------------------------
+
+
+
+Re^5: Schlicht und schoen. (Kellybundy,  1. Mai 2004, 12:03:20):
+~#! rn=Pilgrim rt=1082107925 rg=schmarrn.netdigest
+~#! tid=1081975954
+Passt grad so schoen fuer Oekonomie :)
+
+-----------------------------------------------------------------------------
+
+
+
+Kondome (I) (Ronda,  4. Mai 2004, 00:50:50):
+From: Hilko Bengen <bengen+usenet040501@hilluzination.de>
+Newsgroups: de.alt.sysadmin.recovery
+Subject: Re: rant: Alles E-Mail, oder was?
+Date: Sat, 01 May 2004 19:11:23 +0200
+Message-ID: <87hdv0843o.fsf@ataraxia.int.hilluzination.de>
+
+Florian Weimer <fw@deneb.enyo.de> writes:
+
+> Marc Haber <mh+usenetspam0339@zugschl.us> writes:
+>> Dietz Proepper <dietz-news@rotfl.franken.de> wrote:
+>>>Marc Haber wrote:
+>>>> Das waere als Lehrer in einer gemischtgeschlechtlichen Schulklasse
+>>>> des angemessenen Alters sicher meine geringste Sorge.
+>>>
+>>>Nein. Du weist darauf hin dass Nachwuchs unerwuenscht ist und
+>>>ueberpruefst die Vorkehrungen (getrennte Zimmer) stichprobenartig.
+>>
+>> Ist das nur in Uebereinstimmung mit der Dienstvorschrift, oder ist
+>> das auch gerichtsfest?
+>
+> Wenn es so gehandhabt werden wuerde wie der Internet-Zugang, muesste
+> die Schule kommerzielle Filter austeilen.
+
+Kondome?
+
+-----------------------------------------------------------------------------
+
+
+
+Kondome (II) (Ronda,  4. Mai 2004, 00:51:18):
+[SN: auf das wesentliche gekuerzt]
+
+From: Mathias.Boewe@t-online.de (Mathias Boewe)
+Newsgroups: de.alt.recovery.scientist
+Subject: Re: Wat isn "scientist"
+Message-ID: <1gd3nys.1wfo9odh9yz78N@Mathias.Boewe.dialin.t-online.de>
+Jakob Creutzig <creutzig@mathematik.tu-darmstadt.de> wrote:
+
+OR:
+
+Der Kommilitone hatte maechtig Aerger mit seinem Rezipienten, der offene
+Scheunentore hatte und deshalb nicht zu evakuieren war. Spaetestens bei
+10^-5 mbar war Ende im Gelaende. Als Uebeltaeter waren bald ungenutzte
+Stutzen entlarvt, die mit Blindflansch verschlossen waren. Dichtloeten
+ging nicht, weil die spaeter moeglicherweise noch gebracht wurden.
+
+Dann kam ihm der Geistesblitz, dass es doch elektronisch auf Dichtheit
+gepruefte "Stutzenstulpen" gibt - also ab in das naechste Geschaeft, wo man
+sowas kriegen kann, was in diesem Fall eine Apotheke war. Es entwickelte
+sich folgender Dialog zwischen ihm und der sehr jungen Dame hinter dem
+Tresen:
+
+"Guten Tag. Ich haette gerne klassische Kondome, also solche ganz ohne
+Beschichtungen. Haben sie sowas?"
+
+"<zart erroetend> Ich schau mal nach. [...] Ja, die haben wir."
+
+"Welches sind denn die groessten Packungen, die sie haben?"
+
+"<zart erroetend> Ich schau mal nach. [...] Wir haben Vierer- und
+Zwanzigerpackungen"
+
+"Hmm, zwanzig klingt gut. Davon haette ich gerne fuenf Packungen. Wieviel
+kostet das? Ach ja, ich braeuchte noch eine Quittung, ausgestellt fuer das
+Institut fuer Metallphysik..."
+
+Mathias
+
+-----------------------------------------------------------------------------
+
+
+
+Kondome (keine) (Ronda,  4. Mai 2004, 00:52:12):
+From: "Hermann Thomas" <boss@hermannthomas.de>
+Subject: Sprache der Werbung
+Newsgroups: de.etc.sprache.deutsch
+Date:Fri, 30 Apr 2004 17:31:36 +0200
+Message-ID: <c6trj4$ev74k$1@ID-39934.news.uni-berlin.de>
+
+Bei Aldi Sued gibt's ab 6.5. "Funktionssocken". Ich habe mir die beim
+letzten Mal schon gekauft und: sie funktionieren tatsaechlich! Man kann
+sie anziehen, sie waermen ein wenig, man schwitzt darin, sie werden
+schmutzig, man laeuft Loecher hinein usw. ;-))
+
+-----------------------------------------------------------------------------
+
+
+
+Nix fuer Leibi... (Ronda, 14. Mai 2004, 01:44:45):
+... und andere Katzenfans...
+
+From: Hannes Birnbacher <hannes.birnbacher@gmx.de>
+Subject: Re: Wasserfleck auf Parkett
+Newsgroups: de.etc.haushalt
+Date: Mon, 10 May 2004 06:56:09 +0200
+Message-ID: <20040510065609.07f4d046.hannes.birnbacher@gmx.de>
+
+Antwort auf die Nachricht vom Mon, 10 May 2004 04:16:48 +0200 von
+Juergen Fahnenschreiber:
+
+>
+> Ich hab hier 'nen Wasserfleck (Katze hat Blumentopf umgeworfen)
+> auf dem Parkett.
+> Wie krieg ich den wieder raus?
+
+Ich haett' da einfach ein Katzenfell drueber gebreitet.
+
+-----------------------------------------------------------------------------
+
+
+
+Wer klaut... (Ronda, 15. Mai 2004, 20:25:00):
+... eigentlich nur die Aussenspiegel?! Aber egal, nette Story...
+
+
+Subject: Re: Mercedes und die elektrische Bremse...
+Date: Sat, 15 May 2004 00:03:28 +0200
+From: Christian Luetgens <2004-05@christian-luetgens.de>
+Newsgroups: de.etc.fahrzeug.auto
+
+Am Fri, 14 May 2004 18:59:33 +0200 schrieb Frank Klatte
+<Frank@welt-der-pferde.de>:
+
+>hab heute auf der Titelseite der Auto-Bloed ein nettes Bild gesehen - 
+>Mercedes-Tacho mit der Meldung "Bremse defekt. Bitte Anhalten". 
+
+Kollegen meiner Freundin hatten im Firmen-Mercedes mal die Meldung
+"Aussenspiegel fehlt". Sie haben nachgesehen, und - es stimmte: Die
+Aussenspiegel waren tatsaechlich gestohlen.
+
+Also: Die Mercedes-Fehlermeldungen sollte man durchaus beachten. ;)
+
+
+Bye,
+Christian
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Wer klaut... (Imda, 16. Mai 2004, 15:04:17):
+~#! rn=Ronda rt=1084645500 rg=schmarrn.netdigest
+~#! tid=1084645500
+Nu,das hoert sisch fuer mich eher an wie abgefahren und ne Notluege gebraucht.
+ne 
+
+-----------------------------------------------------------------------------
+
+
+
+de.alt.mud hats auf de.alt.netdigest geschafft... (Ronda, 27. Mai 2004, 23:31:06):
+Subject: Re: Rechtliche Fragen im Mud
+From: Patrick Borer <pa.borer@bluewin.ch>
+Date: Tue, 25 May 2004 03:10:07 +0200
+Newsgroups: de.alt.mud
+Message-ID: <GED40B28814@510039220786-0001.dialin.t-online.de>
+
+[SN: Manuela fragte in die Runde, wer fuer rechliche Fragen beim Betrieb 
+eines MUD verantwortlich sei.]
+
+Manuela Mex <m.mex@gmx.de> schrieb:
+
+(...)
+>- Was darf ein Anbieter absolut NICHT?
+
+Wenn man die Gesetze *aller* Laender beruecksichtigt, sieht das MUD dann
+etwa so aus:
+
+=== LEGALES MUD ===
+
+Herzlich willkommen im Legalen MUD!
+
+Das erste MUD, das gegen kein Gesetz aller 194 Staaten unseres
+schoenen Planeten verstoesst! Ausserdem achten wir sehr darauf,
+niemanden zu veraergern. Viel Spass!
+
+===================
+
+Waehle einen Namen...
+
+>superman
+
+Dieser Name ist ein registriertes Warenzeichen. Bitte waehle einen
+anderen Namen.
+
+>gandalf
+
+Dieser Name ist ein registriertes Warenzeichen. Bitte waehle einen
+anderen Namen.
+
+>claude
+
+Aus Ruecksicht auf die Gefuehle der USA akzeptieren wir keine
+franzoesischen Namen mehr. Bitte waehle einen anderen Namen.
+
+>william
+
+Aus Fairness gegenueber Frankreich akzeptieren wir auch keine
+englischen Namen mehr. Bitte waehle einen anderen Namen.
+
+>max
+
+Kaiser Maximilian I. hat 1499 gegen die Schweizer Krieg gefuehrt. Aus
+Ruecksicht auf Schweizer Mudder akzeptieren wir diesen Namen nicht.
+Bitte waehle einen anderen Namen.
+
+>godzilla
+
+Dieser Name ist ein registriertes Warenzeichen. Bitte waehle einen
+anderen Namen.
+
+>qrvtzjkhkl
+
+Willkommen, Qrvtzjkhkl!
+
+Du stehst in einem Raum. Ausgaenge: Norden und Suedosten.
+
+>betrachte boden
+
+Ein Boden.
+
+>betrachte wand
+
+Es gibt hier eine Wand.
+
+>rufe hallo
+
+Leider gibt es im LEGALEN MUD keine Kommunikationskanaele. Man koennte
+ja etwas Illegales aeussern.
+
+>sage mistmud
+
+Leider gibt es im LEGALEN MUD keine Kommunikationskanaele, dazu
+gehoert auch "sage".
+
+>so
+
+Du stehst in einem Raum. Ausgaenge: Westen und Nordwesten.
+
+>w
+
+Du stehst in einem Raum. Ausgaenge: Sueden und Osten.
+
+>s
+
+Du stehst in einem Raum.
+Hier steht ein Monster.
+Ausgaenge: Westen und Norden.
+
+>betrachte monster
+
+Das ist ein Monster. Es ist geschlechtslos, da ein weibliches Monster
+gegen saudi-arabische Gesetze verstossen koennte, wir aber deswegen
+nicht das maennliche Geschlecht bevorzugen moechten. Egal welches
+Aussehen wir ihm geben wuerden, es koennte irgendwo Anstoss erregen.
+Daher hat es kein Aussehen. Wir bitten um Verstaendnis. Du kannst dem
+Monster zunicken.
+
+>nicke monster
+
+Das Monster reicht dir einen Zettel.
+
+>betrachte Zettel
+
+Du kannst ihn lesen.
+
+>lies zettel
+
+Auf dem Zettel steht:
+Entschuldigung, liebe Spieler - urspruenglich hatten die Raeume des
+LEGALEN MUDS umfangreichere Beschreibungen. Da wir nicht alle Gesetze
+aller 194 Staaten kennen, haben wir sie vorsichtshalber weitgehend
+entfernt. Man weiss ja nie!
+
+>grummel
+
+Du grummelst.
+
+>toete monster
+
+Im LEGALEN MUD kann niemand getoetet werden. Wir wollen ja nicht, dass
+es in Deutschland als gewaltverherrlichend verboten wird.
+
+>ende
+
+Auf Wiedersehen im LEGALEN MUD!
+
+
+Patrick Borer
+
+-----------------------------------------------------------------------------
+
+
+
+"Freunde" oder so was aehnliches (Ronda, 31. Mai 2004, 01:10:29):
+Man beachte auch den letzten Absatz. Ich bin mir nicht sicher, ob mich mehr
+irritiert, dass der Typ sich an der Kasse beim MM rasiert - oder dass er damit
+wohl der einzige MM-Verkaeufer ist, der mit einem elektrischen Geraet umgehen
+kann...?
+
+Ronda
+
+From: Sascha Beutler <usenet@nulldezibel.de>
+Subject: Re: Eisverkaeufer
+Newsgroups: de.rec.tv.misc
+Date:Wed, 26 May 2004 19:47:06 +0200
+Message-ID: <13hpl7v7xtkdt$.16js0g7eeig0z.dlg@40tude.net>
+
+On 26 May 2004 09:50:50 GMT, Martin Schmidt wrote:
+
+>> Kurze Zeit spaeter wurde das Eisverkaufen im Kinosaal entgueltig 
+>> abgeschafft ;-)
+
+> Hier in Berlin gibt's das in einigen Kinos immer noch. Und wirklich 
+> stoeren tut's ja nicht.
+
+Im Gegenteil kann man dabei wirklich was verpassen, zumindest wenn man
+meinem Freund Matze begegnet:
+
+Wir hatten (*) in der Clique einen Freund namens Robert. Dieser war
+trotz gutem Aussehens und nettem Charakter schon ewig Single und
+beklagte sich staendig ueber diesen Zustand. Er war halt recht schuechtern.
+Im Kino war dann die Ruhe, die eintritt, wenn der Eisverkaeufer den Saal
+betritt, der Zeitpunkt fuer Matzes Auftritt. Er stand auf und sagte laut
+durch den Saal:
+
+"Meine Damen, darf ich kurz um ihre Aufmerksamkeit bitten. Neben mir
+sitzt Robert, ein gutaussehender und netter Berliner Single. Robert,
+steh doch mal auf (aber Robert sank im Gegenteil nur noch tiefer in
+seinen Sitz hinein). Wenn sie sich mit ihm treffen moechten, haben sie
+nach dem Film Gelegenheit, ihn kennenzulernen."
+
+Die Kroenung war dann das Ehepaar mit der (leider fuer Robert doch zu
+jungen Tochter), welches sich auf ihre Plaetze setzen wollten und dabei
+in der Naehe von Robert verbeikamen. Auf die Frage des Vaters zur
+Tochter: "Na, willst du neben Robert sitzen." folgte prompt das "Neeee."
+
+(*) Leider haben wir mit ihm kaum noch etwas zu tun, er hat sich aus der
+Clique zurueckgezogen, seit er wieder eine Freundin hat.
+
+Ich glaube, Roberts dringenster Wunsch in dem Moment war, unsichtbar zu
+sein. Aber Matze macht oefters solche Dinge. Dass er sich an der Kasse
+des Mediamarktes nebenbei mit dem Akurasierer rasiert, weil er davor zu
+wenig Zeit hatte, ist eher normal.
+
+ciao - Sascha
+
+-----------------------------------------------------------------------------
+
+
+
+Jau, ich liebe Web-Portale und so ;-) (Ronda, 31. Mai 2004, 01:13:57):
+Newsgroups: de.alt.sysadmin.recovery
+Subject: Bestes Web-Interface *ever*
+From: Thorsten Lange <lange@lmr.khm.de>
+
+Moin, moin!
+
+Letztens hatte ich da noch ein nettes Erlebnis, das ich Euch nicht
+vorenthalten moechte:
+
+Zum hier vorhandenen Spielzeug gehoert seit einiger Zeit ein
+DVB-Satelliten-Modulator, so ein 1-HE-Dings mit nervig lauten Lueftern,
+einem LC-Display mit ca. 2x30 Zeichen, ein paar Folientasten und einem
+halben Dutzend Blinkenlights auf der Front. Das ganze sieht ungefaehr
+so aus:
+
+ -------------
+| bla bla bla | |5| |6| |7| |8| |9| |CLR| |ESC| | ? |
+|             | |0| |1| |2| |3| |4| | < | | OK| | > |
+ -------------
+
+Also eigentlich alles, was man so braucht. Nun war $KOLLEGE die
+Bedienung darueber zu umstaendlich und sann auf Abhilfe. Da auf der
+Rueckseite auch eine mit "Ethernet" beschriftete RJ-45 Buchse auf
+Anschluss wartet und das Manual irgendwas von "Web-Interface" faselt,
+bat mich $KOLLEGE also, dem Modulator eine IP-Adresse zuzuteilen,
+damit er dieses fortan benutzen koenne. Nun, IP-Adressen sind stets
+ausreichend vorhanden, das ist also schnell getan. Nun noch flugs den
+Browser gestartet - und was ist zu sehen?
+
+Eine recht leere Seite mit weissem Hintergrund. Drauf sind nur ein
+bisschen Text und eine Handvoll Hyperlinks zu sehen:
+
+
+bla bla bla
+
+_5_  _6_  _7_  _8_  _9_  _CLR_  _ESC_  _?_
+_0_  _1_  _2_  _3_  _4_   _<_    _OK_  _>_
+
+
+Yep. Made my day.
+
+Bye,
+Thorsten
+
+-----------------------------------------------------------------------------
+
+
+
+Veganer und so (Alboin,  3. Jun 2004, 15:35:00):
+Gefunden im Forum von www.vegan.de
+
+
+  ein Freund wurde Ksefresser
+autor/in   Tina
+datum   29.04.04 | 10:01
+beitrag   Hallo !!!
+Mu was loswerden!!!
+Mein Kumpel wurde nach fast 9 Jahren veganer Ernhrung zum Vegetarier.
+Ich find es voll bescheuert, da er von uns der war wo am rgsten fr alles
+was mit Tierrecht zusammen hngt sich einstzte. Letzte Woche hat er sich
+auch Leder Schuhe gekauft da die so billig waren .... blablabla.....
+Und kommt mit B12 Prob. an die er nicht hat . Als das ganze anfing htte ich
+ihn gern erschlagen.
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Veganer und so (Boing,  3. Jun 2004, 15:38:10):
+~#! rn=Alboin rt=1086269700 rg=schmarrn.netdigest
+~#! tid=1086269700
+Und wo ist da der Witz, ausser dass alle Umlaute fehlen?
+  Boing
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Veganer und so (Alboin,  3. Jun 2004, 15:39:14):
+~#! rn=Boing rt=1086269890 rg=schmarrn.netdigest
+~#! tid=1086269700
+ich fands einfach lustig wie die einem der nur zum Vegetarier absteigt gleich
+grollen.
+
+und ja sorry fuer die Umlaute
+
+Al
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Veganer und so (Kellybundy,  5. Jun 2004, 15:47:26):
+~#! rn=Alboin rt=1086269954 rg=schmarrn.netdigest
+~#! tid=1086269700
+Es gibt nix militanteres als Veganer. Komisch nur, dass die dauernd wegen
+irgendwelcher WehWehchen beim Arzt sind, auch wenn sie noch so beteuern, dass
+sie keinen Bxx- Eisen- oder sonstigen Mangel haben...
+Blondchen kennt da einige
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: Veganer und so (Zook,  6. Jun 2004, 15:53:23):
+~#! rn=Kellybundy rt=1086443246 rg=schmarrn.netdigest
+~#! tid=1086269700
+Was ist Bxx?
+
+Zook.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^5: Veganer und so (Croft,  6. Jun 2004, 15:57:37):
+~#! rn=Zook rt=1086530003 rg=schmarrn.netdigest
+~#! tid=1086269700
+Vitamine die mit B anfangen, so wie B1, B2, B6 oder B12.
+
+Croft
+
+-----------------------------------------------------------------------------
+
+
+
+Westfalen (Maarg, 13. Jun 2004, 21:11:05):
+Subject: Re: Fragebogen
+Date: Thu, 10 Jun 2004 19:37:02 +0200
+From: Mirko Liss <mirko.liss@web.de>
+Reply-To: mirkoliss@web.de
+Newsgroups: de.alt.sysadmin.recovery
+
+Rainer Kersten:
+> Vinzent 'Gadget' Hoefler wrote:
+>> Ja, schon. Aber Du verwechselst gerade Romantik mit Recovery, glaube
+>> ich.
+>
+> Westfalen kennen den Unterschied nicht.
+
+Romantik bedeutet, dass man der Liebsten Blumen und frische Broetchen
+mitbringt, wenn man morgens um halb 5 von der Arminia-Aufstiegsfeier[1]
+heimkehrt.
+
+Recovery bedeutet, dass sich die Liebste zwar im Schlafzimmer
+eingeschlossen hat, aber bereits eine Flasche Wasser und Aspirin
+griffbereit neben dem Sofa stehen.
+
+
+[1] Sie findet regelmaessig jede zweite Saison statt.
+
+
+
+-----------------------------------------------------------------------------
+
+
+
+de.alt.netdigest macht doch Sinn... (Ronda, 14. Jun 2004, 22:26:26):
+... oder wie man vielleicht die GEZ doch loswerden kann. Falls das folgende
+stimmt...
+
+From: rainerwillis@gmx.de (Rainer Willis)
+Newsgroups: de.soc.recht.misc
+Subject: Re: Mal wieder GEZ (sorry ;)
+Date: 8 Jun 2004 04:24:30 -0700
+Message-ID: <6bd23a40.0406080324.20c247f@posting.google.com>
+
+Mario Rahm wrote:
+
+> "Peter Wilson" <ireallyhatespam@t-online.de> schrieb ...
+> > ich habe eine Zweitwohnung zwecks Studium und komme heute wieder hier
+> > hin und finde eine nette Aufforderung in meinem Briefkasten, ich moege
+> > mich doch bitte anmelden.
+> 
+> Von wem? Der GEZ?
+> 
+> > Das Problem ist, dass ich nichtmal bei der
+> > Stadt die Zweitwohnung angemeldet habe, insofern duerfte es da sicherlich
+> > Aerger geben.
+> 
+> Noe, warum? Habe mich auch Mal erst 1,5 Jahre nach dem Umzug
+> umgemeldet.
+
+Hallo Mario, hallo Peter,
+
+ich hab 16 Jahre lang in meiner Hamburger Wohnung gewohnt ohne mich
+umzumelden, da hat nie ein Hahn nach gekraeht.
+
+> > (mich sozusagen "legal" hier aufhalte).
+
+Deine Gesetzestreue in Ehren, Peter, aber mach mal halblang.
+
+> > Gibt es da
+> > Aerger mit der GEZ wenn man sich nachtraeglich abmelden will?
+> 
+> Abmelden? Bei der GEZ? Lach!
+> 
+> Das haben schon viele probiert. Das Wort "Abmelden" kennen
+> die GEZler nicht. Die kennen nur "Anmelden".
+
+Und da muss ich zu meiner eigenen Ueberraschung widersprechen: ich
+hatte mir vor meinem Umzug das Abmeldeformular ausgedrucken lassen,
+ausgefuellt und an die GEZ geschickt. Unter "Gruende" hatte ich
+geschrieben: Umzug, es werden hier keine empfangsbereiten Geraete mehr
+betrieben.
+14 Tage spaeter fragt die GEZ an ob es "Sonstige Gruende" gebe.
+Ha, dachte ich, dann kann der Spass ja losgehen, und schrieb:
+
+"Betr.: Ihr Schreiben vom 06.05.04
+
+Sehr geehrte Damen und Herren,
+ich hatte das von Ihnen im Internet bereitgestellte Abmeldeformular
+ausgedruckt, vollstaendig ausgefuellt und an Sie geschickt.
+
+Nun schreiben Sie: 
+"Bitte haben Sie Verstaendnis dafuer, dass wir die gewuenschte Abmeldung
+zunaechst noch nicht durchgefuehrt haben, da wir weitere Angaben
+benoetigen."
+ 
+1. Frage: Warum haben Sie diese "weiteren Angaben" nicht schon im
+Formular gefordert?
+2. Frage: Warum werde ich zum zweiten Mal nach Dingen befragt, die ich
+bereits beantwortet habe?
+3. Frage: Wie viele "Sonstige Gruende" moechten Sie in etwa noch wissen?
+4. Frage: Was geht es Sie an, wo ich hinziehe? 
+ 
+Auf jeden Fall werde ich alle Abbuchungen zurueckbuchen lassen, die Sie
+nach dem 1. Mai, meinem Kuendigungstermin, vorgenommen haben.
+
+Apropos Internet: ich werde den Inhalt unserer Korrespondenz in
+geeigneten newsgroups und threads verbreiten.
+
+Mit freundlichem Gruss"
+
+Dann hab ich Schiessscharten ausgestemmt, einen Graben ums Haus
+gezogen und voller Kampfeslust jeden Morgen meine Ritterruestung
+angelegt.
+
+Und was macht die GEZ? Sie bestaetigt mir in einem freundlichen
+Schreiben die Abmeldung! Dazu, ich hab es mehrfach geprueft, eine
+*voellig korrekte* Endabrechnung.
+
+Ich war gut vorbereitet, wie koennen die mich so auflaufen lassen? Ich
+kam mir jedenfalls ziemlich albern vor, als ich nach der Lektuere aus
+Gewohnheit das Visier wieder runterklappte...
+
+Psychoterror nenn ich sowas!
+:-)   
+ 
+Gruss, Rainer
+
+-----------------------------------------------------------------------------
+
+
+
+Das bisschen Haushalt... (Ronda, 14. Jun 2004, 22:39:13):
+[SN: Quoting ergaenzt, da insgesamt recht amuesant zu lesen :-]
+
+From: Georg Mildenberger <georg.mildenberger@gmx.de>
+Subject: Re: FAQ vorhanden? Ansonsten: Student mit Studentenfragen!
+Newsgroups: de.etc.haushalt
+Date: 10 Jun 2004 08:47:04 GMT
+Message-ID: <2iqlg8Fqe959U2@uni-berlin.de>
+
+
+Am 10 Jun 2004 08:47:04 GMT schrieb Georg Mildenberger:
+
+Hallo Cartsten,
+
+Carsten Otto fragte: 
+
+> Hallo!
+> 
+> Ich habe bisher noch keinen Hinweis auf eine FAQ gesehen. Bitte schreibt
+> mir, wenn es doch eine gibt - die Fragen wurde vermutlich schon oefters
+> gestellt.
+> 
+> Ich wohne seit Oktober nicht mehr bei meinen Eltern, habe also nun keine
+> putzende (und kochende) Mutter, die mir staendig zur Verfuegung steht. Ich
+> bin zwar meiner Meinung nach weit davon entfernt, so wenig bzw. schlecht
+> zu putzen, dass sich keiner in meine Wohnung traut - trotzdem habe ich
+> einige Zweifel. Daraus resultieren folgende konkrete Fragen, fuer
+> allgemein Tipps bin ich allerdings auch dankbar.
+> 
+> 1) Wie oft sollte ein Duschvorhang gereinigt werden, damit keine
+> gesundheitlichen Probleme entstehen koennen? Ich bin faul genug, um ein
+> paar Flecken oder ein wenig (!) Geruch zu ertragen :>
+> 
+> 2) _Wie_ reinigt man einen Duschvorhang am besten? Meiner ist aus recht
+> "starkem" Plastik, Waschmaschine kann ich mir da nicht vorstellen - da
+> bin ich aber offen. Als Praeventivmassnahme habe ich irgendwann einmal
+> aufgeschnappt, dass der Vorhang bis er trocken ist am besten moeglichst
+> weit ausgebreitet (also "Dusche geschlossen") aufgehangen werden sollte -
+> liege ich da richtig?
+> 
+> 3) Wie oft putzen normale Leute (wovon hier hoffentlich einige Anwesend
+> sind :) die verschiedenen Raeume? Mich interessiert dabei vor allem ein
+> vernuenftiges Mittelmass, so dass ich meinen Zeitbedarf fuer das Putzen
+> moeglichst minimal halten kann, ohne zu wenig zu putzen.
+> 
+> 4) Welche Tipps habt ihr ansonsten fuer einen in dieser Hinsicht extrem
+> unerfahrenen jungen Menschen? Ich denke mal, dass jeder Student (oder
+> auch Nichstudent) diese Phase "durchgemacht" hat...
+
+einfach erwachsen werden ;-)
+
+Mal im Ernst; Es ist Deine Wohnung. Du brauchst keine Angst zu 
+haben, dass Du vom zu wenigen Putzen krankt wirst, so lange Du 
+nicht Schimmel kriegst oder massiven Ungefzieferbefall.
+Iss nichts was krabbelt, merwuerdige Flecken oder Grundfarben 
+aufweist oder deutlich von der ueblichen Form, Konsistenz, Geruch 
+der entsprechenden Ware abweicht. Pass auf, dass Konservendosen 
+nicht angerostet sind oder Ausbeulungen nach aussen aufweisen.
+Dann sollte ein Ueberleben moeglich sein.
+In meiner ersten Weg (3 Jungs) wurde so lange nicht gespuelt, bis 
+kein sauberes Geschirr mehr da war (wir hatte eine Menge aus dem 
+Sperrmuell). Dann war Pizza aus dem Karton oder auswaerts Essen 
+angesagt. Wenn der Schimmel aus dem Waschbecken herauskrock, dann 
+kam die Grossreinigung. Koennte man auch ueberleben.
+
+Wichtiger Hinweis: Sauerkraut und Tomatensosse nicht zu lange in 
+ALukochgeschirr aufbewahren, sonst hat man nachher ein extra Sieb!
+
+Ansonsten: Wenn Du das Gefuehl hast, es sei zu dreckig, dann putze.
+Wenn Du das Gefuehl hast, Menschen, die Du gerne zu Gast haettest, 
+gruseln sich und bleiben weg, dann putze.
+Zwischen zwei Liebhabern/innen sollte man die Bettwaesche wechseln, 
+das gilt als hoeflich. (Und natuerlich sich selbst waschen.)
+
+Du kannst Deinen Haushalt wohl kaum so fuehren wie Mama. Das Gute 
+ist, Du musst es auch gar nicht.
+
+Viel Spass beim Ausprobieren.
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Das bisschen Haushalt... (Maharet, 14. Jun 2004, 22:39:45):
+~#! rn=Ronda rt=1087245553 rg=schmarrn.netdigest
+~#! tid=1087245553
+Das Zeug ist immer so lang. Gibts das nicht kuerzer? 
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Das bisschen Haushalt... (Ronda, 14. Jun 2004, 22:41:33):
+~#! rn=Maharet rt=1087245585 rg=schmarrn.netdigest
+~#! tid=1087245553
+Noe. Ungekuerzt geklaut.
+
+Ronda *kurzfassend*
+
+-----------------------------------------------------------------------------
+
+
+
+Ein kurzer fuer Maharet (Vanion, 14. Jun 2004, 22:53:43):
+Sascha Wirfler wrote:
+
+>> Hallo Gruppe,
+>>
+>> in einer N24-Dokumentation gestern hie>> es, der "Rote-Fleck-Sturm"
+>> des Jupiter tobe seit etwa 300 Jahren.
+>>
+>> Frage: Woher wei>> man das? Fotos aus dem Jahr 1700, auf welchen
+>> Jupiter ohne Fleck zu sehen ist, d|rften etwas schwer aufzutreiben
+>> sein.
+
+
+Frueher, als es noch keine Fotos gab, konnte man
+zeichnen und mit Worten beschreiben was man sah.
+
+Manche koennen das sogar noch heute ...
+
+Helmut Faugel
+--
+PS: Den mit dem Haushalt solltest Du aber trotzdem lesen. Lohnt sich. :)
+
+V*
+
+-----------------------------------------------------------------------------
+
+
+
+Mal direkt... (Ronda, 18. Jun 2004, 23:23:46):
+... aus de.alt.recovery.webauthor, aber vielleicht schaffst die News ja noch
+nach d.a.n...
+
+Am Mittwoch, 16. Juni 2004 11:14 schreibselte Can Filip Sakrak:
+
+> Jockel Hofmann schrieb:
+> 
+>> Marxismus - Leninismus - Aldismus.
+> 
+> Aldismus - Realismus - Collectivismus.
+
+NACK
+
+Aldismus - Realismus - Lidlismus - Normismus.
+
+:-) Jockel
+
+-----------------------------------------------------------------------------
+
+
+
+Och... (Ronda, 18. Jun 2004, 23:30:10):
+... ich geh heute mal in anderen Newsgroups hausieren... also nun aus
+de.alt.recovery.scientist:
+
+begin quoting Andreas Iwanowitsch <a.iwanowitsch@gmx.de>:
+[...]
+> Pruefer 1 stellt eine Frage, Pruefling beantwortet sie nach bestem Wissen
+> und Gewissen. Pruefer 1 zu Pruefer 2: "War das eben richtig, was er gesagt
+> hat?" Pruefer 2: "Wie war denn die Frage?"
+
+Am Ende vom Chemiepraktikum fuer uns Physiker stand bei uns auch eine
+kleine muendliche Pruefung.  Die endete bei mir etwa so:
+
+Pruefer: "Ist Ihnen die Lewis-Saeure-Base-Theorie ein Begriff?"
+Ich:    "Ja."
+Pruefer: "Gut, danke."
+
+
+Ciao,
+  Stefan
+
+-----------------------------------------------------------------------------
+
+
+
+Es gab... (Ronda, 23. Jun 2004, 00:11:49):
+... einige Beschwerden, de.alt.netdigest-Artikel waeren so lang. Nicht
+immer...
+
+From: Daniel Temme <nalosspamdoch@dafb.de>
+Newsgroups: de.alt.talk.dunkle-seite
+Subject: Re: <2004-06-15> Offizielle FAQ der Newsgroup
+de.alt.talk.dunkle-seite
+Message-ID: <1818731.hZgebYgTMh@dafb.de>
+
+Thomas Huehn wrote:
+
+> Gleichschaltung scheint hier oberstes Gebot zu sein.
+
+Gleichschaltung ist so ein haessliches Wort. Ich persoenlich bevorzuge
+die Formulierung unidirektionale Konsensorientiertheit. Alles andere
+waere doch auch Widerstand.
+
+Daniel
+
+-----------------------------------------------------------------------------
+
+
+
+Kurz und nett. (Ronda, 30. Jun 2004, 21:53:17):
+From: "Steffen M. Banhardt" <usenet-nospam-expire04-06-30@steffenbanhardt.de>
+Subject: Re: KAFKA
+Newsgroups: de.etc.sprache.deutsch
+Date:Sat, 26 Jun 2004 23:00:14 +0200
+Message-ID: <iyp90dl2q59l$.dlg@steffenbanhardt.de>
+
+Statistiken im Mathe-Unterricht: "Unsere Zaehlung ergab, dass 80% aller
+Autos gelb sind. Weitere 17% sind weiss, silbern, rot oder schwarz." -
+"Wo habt ihr denn gezaehlt?" - "In der Poststrasse. Wieso?"
+
+-----------------------------------------------------------------------------
+
+
+
+Bublath-Skala... (Ronda,  4. Jul 2004, 20:00:14):
+... nun auch fuer MPA-Artikel zum Lichtsystem oder so?
+
+[SN: Gekuerzt. Diskutiert wird die Einfuehrung der nach unten offenen
+ Bublath-Skala zur messung des "Uaaaaaah"-Gehalts "Wissenschaftlicher"
+ Aeusserungen. Auch der gesamte Thread ist lesenswert]
+
+Subject:    Re: Bublath-Skala
+Date:       17 Jun 2004 14:00:55 GMT
+From:       Michael Kirchner <2004-06@usenet.hirnreck.de>
+Newsgroups: de.alt.recovery.scientist
+Msg.-ID:    <45aff790508a69d9c553fed883385e84@fqdn.hirnreck.de>
+
+Dave Kliczbor schrieb:
+
+> Der Bezugspunkt? Naja, bei einer sowohl nach oben wie unten
+> offenen Skala bietet sich natuerlich die 0 an. Bleibt noch
+> die Frage, wie man nun diese Skalenmitte definiert. Sei 0 =
+> Bublath, da er der Namensgeber ist? Oder definiere man die
+> 0 als "gerade noch ertraeglich" (Beispiel?) und gebe Bublath
+> z.B. die -100 -- womit man direkt auch noch die 
+> Granularitaet definiert haette. 100 Bublath sei demnach der
+> Abstand von "gerade noch ertraeglich" zu Bublath selbst.
+
+Hm, ich hatte eher an definierte Kriterien der Auswirkung
+gedacht. So etwa:
+
+1 bub: Leichtes Knurren beim Fachwissenschaftler
+2 bub: Fachwissenschaftler schlaegt Haende ueber dem Kopf
+zusammen
+3 bub: Erste Anzeichen von Nervoesitaet beim
+allgemeinwissenschaftlichen Publikum
+4 bub: Beginnendes Koerperliches Unwohlsein, skeptische
+Naturen suchen nach der Versteckten Kamera
+5 bub: Einstein beginnt im Grab zu rotieren, Hauptsaetze der
+Thermodynamik beginnen zu versagen
+6 bub: Das Stadium von Unwissenschaftlichkeit wo es einem die
+Sprache verschlaegt und sich fragt, ob es ueberhaupt Sinn
+hatte, sich mit dem ganzen Zeug abzugeben.
+7 bub: Newton beginnt im Grab zu rotieren.
+8 bub: Klevere Marketingmenschen fragen, ob es schon ein
+lieferbares Produkt gibt.
+9 bub: Bublath beginnt "vereinfachte" Animationen zur
+Verdeutlichung der Vorgaenge zu zeigen.
+14 bub: Die Luecken in den Hypothesen werden so gross, dass
+man kleine Galaxien hindurchfaedeln kann.
+
+etc.
+
+-----------------------------------------------------------------------------
+
+
+
+Fuer Akustik-Freaks (Ronda,  9. Jul 2004, 21:41:51):
+Date: 7 Jul 2004 23:04:13 GMT
+From: Benjamin Stenzel <labawaba@gmx.de>
+Newsgroups: de.rec.musik.hifi
+Subject: Re: Bose Satelliten aufruesten....
+
+Thomas Bersch <newsflash@gmx.de> wrote:
+
+> ich hab hier ein paar Bose Boxen stehen [...]
+>
+> So jetzt das Problem:
+
+Was denn, noch eins?
+
+SCNR
+
+Gruss
+Benjamin
+
+-----------------------------------------------------------------------------
+
+
+
+Newsmaster (Maarg, 12. Jul 2004, 18:46:33):
+From: "Benoit Panizzon" <quasar-27.1.03@spam.woody.ch>
+Newsgroups: de.admin.net-abuse.mail
+Subject: Re: T-Online mit falschen RIPE Infos
+Date: Sat, 10 Jul 2004 07:49:52 +0000 (UTC)
+Message-ID: <cco730$m9b$1@magma.woody.ch>
+
+Helmut Hullen <HHullen_BS@btx.dtag.de> wrote:
+
+> Und nach meinen bisherigen Erfahrungen wird die Beschwerde schnell und  
+> gut bearbeitet, auch bei Kunden, die "t-ipnet.de" nicht so nahe  
+> stehen.
+
+Hmm, nach meinen Erfahrungen eben leider nicht, sondern es brauchte auch schon
+mehrere Telefonanrufe bei den diversen T-Abteilungen, bis die sich einige
+waren wer denn genau zustaendig ist.
+
+Auch da wurde immer gesagt, es ist weitergeleitet. Dass die Person an welche
+alle diese Faelle weitergeleitet wurden gar nicht mehr bei der Abteilung
+arbeitete wusste man nicht und fand man erst heraus, als ich sehr hartnaeckig
+nachgefragt weis sich einfach nie etwas tat. (Naja, damals war's ja
+Aquadrat/Stardialer).
+
+Auch dass die T-Mails nie einen Namen des bearbeitenden Mitarbeiters enthalten
+obwohl ich mehrfach darum gebeten habe versteh ich nicht, denn dieses hab ich 
+in etwa so schon mal erlegt:
+
+T-Online 'Newsmaster': Hallo, wir wuerden gerne ein Newspeering mit Ihnen 
+machen. Einige Benutzer moechten gerne die von Ihnen betreute Hierarchie auf
+den T-Online Server lesen.
+
+Ich: Fein, teilen Sie mir die Peering-Daten und Bedingungen mit und
+bestaetigen Sie mir, dass sie mit den Regeln welche fuer diese Hierarchie
+gelten einverstanden sind.
+
+T-Online 'Newsmaster': Wir haben Sie gar nie wegen einem Peering Angefragt,
+mit wem hatten Sie kontakt?
+
+Ich: Leider steht unter der Mail nur 'Newsmaster'. Ich sende Ihnen die Anfrage
+weiter. Bitte klaeren Sie intern, wer das gesendet hat.
+
+T-Online 'Newsmaster': Wer das bei uns abgesendet hat, kann nicht ausfindig 
+gemacht werden. Es steht kein Name in der Mail.
+
+Ich: In Ihrer Mail steht auch nur 'Newsmaster'. Naja, ich betrachte den Fall 
+als erledigt.
+
+T-Online 'Newsmaster': Vor zwei Wochen haben wir Sie wegen einem Peering 
+angefragt. Sie haben nicht geantwortet, daher wollten wir nochmals nachfragen.
+
+Ich: Natuerlich habe ich geantwortet, nur wusste man nicht welcher Mitarbeiter
+diese Anfrage gesendet hatte, da kein Name in der Mail erwaehnt war. Wie ist 
+denn Ihr Name verrehrter Newsmaster?
+
+T-Online 'Newsmaster': Von welchem Mitarbeiter haben Sie diese Mail erhalten? 
+Von uns hat niemand eine Peering Anfrage gestellt.
+
+Ich: Wuerden Sie mir bitte Ihren Namen nennen? Es ist bereits das zweite mal 
+innerhalb eines Monates in welchem ich eine Peering Anfrage von Ihnen erhalte
+und niemand ausfindig machen kann, welcher Ihrer 'Newsmaster' diese abgesendet
+hat.
+
+T-Online 'Newsmaster': Ich weiss nicht welcher Kollege Ihnen das Mail gesendet
+hat. Dieser muesste Ihnen seinen Namen mitteilen.
+
+Naja, ich habe es schlicht aufgegeben...
+
+Gruss
+-Benoit-
+
+-----------------------------------------------------------------------------
+
+
+
+Nein, nicht aus de.alt.netdigest... (Ronda, 13. Jul 2004, 20:37:02):
+... das hier ist ernst. Bitterer Ernst...
+
+Ronda *die den bloeden Koeter bei Windows am liebsten erschiessen wuerde*
+
+From: Christoph Buenger via SAVE-Pressedienst <software@s-a-ve.com>
+Newsgroups: de.comp.software.announce
+Subject: [WIN][System: Sonstige] MeinFreund 2.0.4
+Von: "Christoph Buenger via SAVE-Pressedienst" <software@s-a-ve.com>
+Betreff: [WIN][System: Sonstige] MeinFreund 2.0.4
+Datum: Dienstag, 13. Juli 2004 20:29
+
+Programm: MeinFreund 2.0.4
+Kennung: CBU-008
+Beschreibung:
+Das Programm MeinFreund stellt einen kleinen frei waehlbaren lustig
+animierten 
+Helfer auf den Desktop, der bei einigen Ereignissen (z.B. neue Mail) 
+den von Ihnen festgelegten Text in deutsch vorliest und dabei noch 
+Animationen durchfuehren kann.  Ausserdem kann Ihnen Ihr Freund Webseiten, 
+Word-Dokumente, Chats,... oder frei eingebbare Texte vorlesen.  Auf Wunsch 
+sagt Ihnen Ihr Freund in waehlbaren Abstaenden die aktuelle Zeit an. 
+
+
+Kategorie: System: Sonstige
+Groesse: 7909 KB
+Betriebssystem: WIN/95/98/ME/NT/2000/XP
+Datum Update: 12.07.2004
+Download-Link: http://www.cbuenger.de/myfriend/MeinFreund.exe
+Art der Software: Shareware
+Preis der Vollversion/Einzellizenz: 14,90 EUR
+PAD-Url: http://www.cbuenger.de/myfriend/meinfreund_pad.xml
+
+Anbieter/Homepage:
+Christoph Buenger
+Christoph Buenger Software
+http://www.cbuenger.de
+
+
+-----------------------------------------------------------------------------
+
+
+
+Ja, ja, der Deutsche Amtsschimmel... (Ronda, 19. Jul 2004, 21:43:24):
+From: "Michael Muetterlein" <opatios@aldibaran.de>
+Newsgroups: de.alt.fan.aldi
+Subject: Re: Verbandkasten und Warndreieck
+Date: Sun, 18 Jul 2004 03:42:41 +0200
+Message-ID: <2lu378Fg6h7fU1@uni-berlin.de>
+
+Moin!
+
+"Georg Mildenberger" <georg.mildenberger@gmx.de> schrieb:
+> Hei, als ich den Personenbefoerderungsschein-Krankentransport machen
+> wollte, damit ich beim BRK KTW/RTW fahren durfte, verlangte der
+> Beamte einen Nachweis ueber einen frischen Erste-Hilfe-Kurs. Ich
+> hatte das Testatheft vom RK dabei, da stand eine frische San-
+> Ausbildung drin und die zum Rettungsdiensthelfer (gab es damals
+> noch, sone Art kleiner RS). Keine Chance. Schliesslich schrieb der
+> Chefausbilder vom RK einen Zettel, dass die Ausbildung auch einen
+> Erste-Hilfe-Kurs umfasst, dann ging es, aber widerstrebend...
+
+Da schrieb mal jemand von einem Rettungsassistenten (und
+Ersthelfer-Ausbilder), der seinen Motorradfuehrerschein machen wollte 
+und eine EH-Bescheinigung vorlegen sollte. Dem ging's aehnlich wie Dir.
+Schliesslich hat er eine jungfraeuliche EH-Bescheinigung ausgepackt, sie
+ausgefuellt und selbst unterschrieben, vor den Augen des 
+Sachbearbeiters... "Aber das geht doch nicht!" - "Doch, das geht, ich 
+bilde schliesslich EH selbst aus- da werd ich es wohl koennen..."
+
+MfG
+Michael
+
+-----------------------------------------------------------------------------
+
+
+
+Menno! (Ronda, 20. Jul 2004, 22:59:06):
+Und ich dachte, am Ende kommt raus, dass der Typ grad mit seiner Freundin
+Schluss macht...
+
+From: Tobias Hagen <tobias.hagen@gmxpro.net>
+Date: Thursday 24 June 2004 18:55:33
+Groups: fhf.jokes
+
+30. Dezember, muede und abgespannt von der Arbeit fuhr ich in die
+Wohnung meiner Freundin. Dort war es aufgeraeumt, im Kuehlschrank war
+etwas zu essen. Nachdem ich mir den Magen vollgeschlagen hatte,
+machte ich es mir auf dem Sofa bequem.
+
+In diesem Moment klingelt es an der Wohnungstuer. Ich gehe zur Tuer und
+blicke durch den Spion. Dort stand ein etwa 40 Jahre alter, gut
+gekleideter Mann.
+
+Kaum hatte ich die Tuer geoeffnet, fing der gute Mann auch schon an:
+GEZ-Scherge: "Guten Tag, mein Name ist Lars Laestig, ich bin ihr
+Rundfunkgebuehrenbeaufftragter.....blabla......blabla"
+
+GEZ? Wirklich ein GEZ-Scherge? Oh je...
+
+GEZ-Scherge: "..........blabla........sind sie FRAU ANJA K.?"
+
+Hat der mich wirklich gerade gefragt ob ich Frau Anja K. (meine
+Freundin) bin? (Ich sehe nun wirklich nicht wie eine Frau aus, zudem
+trug ich einen deutlich sichtbaren 3-Tagesbart)
+
+Das verschlug selbst mir die Sprache. Stille machte sich im Hausflur
+breit. Ploetzlich traf mich der Hammer der Erkenntnis: Es gibt ein
+Leben nach dem Gehirntod, der Beweis steht vor dir. Pack den Typen
+ein und der naechste Nobelpreis ist dir sicher. Ich entschied mich
+dagegen, denn der gute Mann war sicher nicht stubenrein und ich
+antwortete ihm stattdessen, dass ich Gina W. sei, die uneheliche
+Tochter von Frau K.
+
+GEZ-Scherge: "Nagut lassen wir das. Sie wissen
+sicher.......blabla........verpflichtet
+..........blabla........anzumelden......"
+
+Ich unterbrach den Redefluss des GEZ-Schergen nur ungern, aber ich
+teilte ihm mit, dass ich mal auf die Toilette muesste, versprach ihm
+aber, dass ich gleich wieder da bin und schloss die Tuer hinter mir.
+Nach 5 Minuten gab es die ersten zarten Klingelversuche.
+
+Nach weiteren 3 Minuten klingelte er Sturm und ich oeffnete wieder die
+Tuer.
+
+GEZ-Scherge: "Was haben sie denn solange gemacht?"
+
+Wahrheitsgemaess antwortete ich ihm, dass ich ein lauwarmes Bier
+getrunken habe. Ausserdem mussten mal wieder meine Fussnaegel
+geschnitten werden.
+
+GEZ-Scherge: "So eine Frechheit, sowas habe ich ja noch nie
+erlebt...."
+
+Ich musste dem guten Mann leider Recht geben und versprach meine
+Freundin noch heute Abend darauf anzusprechen, warum sie das Bier
+nicht in den Kuehlschrank gestellt hatte. Wirklich eine Frechheit. Nun
+lief dieser geistige Tiefflieger rot an und rastete aus.
+
+GEZ-Scherge: "Wenn sie noch weiter so ein Kasperltheater
+veranstalten, kann ich auch andere Seiten aufziehen. Ein Anruf von
+mir und die Polizei durchsucht ihre Wohnung......blabla....... das
+wird sehr teuer fuer sie......blabla".
+
+Logisch, mit Bundesgrenzschutz und Sondereinsatzkommando.
+
+Sichtbar eingeschuechtert versprach ich nun, effektiv mitzuarbeiten
+und mein Kasperltheater bleiben zu lassen.
+
+GEZ-Scherge: "Besitzen sie einen Fernseher oder ein Radio?"
+
+Freundlich gab ich dem Mann Auskunft. "Ja klar, ich besitze 2
+Fernseher, 3 Radios, noch ein Radio in meinem Buero und zwei in meinen
+Autos."
+
+GEZ-Scherge: "Haben sie diese angemeldet?"
+
+"Nein, bisher leider nicht."
+
+GEZ-Scherge: "Wie lange besitzen sie diese Geraete schon?"
+
+"Ca. 10-12 Jahre."
+
+Uiiiii, jetzt war er am Sabbern, als er seine Provision in Gedanken
+ueberschlug. Nunja, um es kurz zu machen, er hielt mir nach 1-2
+Minuten zwei Zettel zur Unterschrift unter die Nase. Eine Anmeldung
+der GEZ und einen Schrieb, dass ich schon seit 5 Jahren die Geraete
+besitze. Beides auf den Namen und die Adresse meiner Freundin
+ausgestellt.
+
+Freundlich wie ich nun einmal bin teilte ich ihm mit, dass ich weder
+Frau Anja K. bin, noch hier wohne.
+
+GEZ-Scherge: "Wo wohnen sie denn?"
+
+Ich: "Wissen sie das nicht?"
+
+GEZ-Scherge: "Nee"
+
+Ich: "Super, schoenen guten Abend"
+
+Ich schloss die Tuer, schaltete die Klingel ab und den Fernseher ein,
+das Bier war auch schon etwas kuehler.
+
+Wenn ich Glueck habe, kommen vielleicht auch bald mal wieder die
+Zeugen Jehovas vorbei.
+
+-----------------------------------------------------------------------------
+
+
+
+Kurz und knackig. (Ronda, 20. Jul 2004, 23:24:57):
+From: Wolfgang Schwanke <see@sig.nature>
+Newsgroups: de.etc.sprache.deutsch
+Subject: Re: Sonnenkerne ode Kuerbiskerne knacken
+Date: Fri, 16 Jul 2004 11:57:59 +0200
+Message-ID: <7r88dc.mk.ln@wschwanke.de>
+
+fplatonva@web.de (F.Platonva) wrote in 
+news:9ac3addc.0407160005.528a18ab@posting.google.com:
+
+> Sonnenkerne oder Kuerbiskerne
+
+Uebrigens heisst es Sonnenblumenkerne. Sonnenkerne sind schwer verdaulich.
+
+[...]
+
+-----------------------------------------------------------------------------
+
+
+
+Direkt... (Ronda, 21. Jul 2004, 00:07:58):
+... und (noch) nicht von de.alt.netdigest - aber vielleicht klappt das ja
+noch.
+
+Ronda *gab schon Omis Computerkurse - das ist die Realitaet, jawollja!*
+
+Newsgroups: de.alt.fan.aldi
+Subject: 50 Schleifscheiben abzugeben
+From: Ralf Wolf <Wolf@web.de>
+Ich hatte meiner Oma aus dem Urlaub geschrieben mir 50 CDs von ALDI
+einzukaufen um gleich die Fotos zu brennen. 
+Als sie hinkam war es gerade Mittwoch und es gab die Schleifscheiben
+fuer die Bohrmaschinen und es kam wie es kommen musste,
+sie kaufte 50 einzelne Schleifscheiben.
+Die Umtauschzeit ist abgelaufen.
+Wer die gebrauchen koennte schreibe mir mal, auch Tausch
+gegen CD.
+
+Mfg Ralf
+
+-----------------------------------------------------------------------------
+
+
+
+Endlich mal ne sinnvolle Sache! (Ronda, 23. Jul 2004, 22:53:52):
+From: Frank Weinberg <muelleimer@usenet-rundfahrt.de>
+Newsgroups: de.alt.recovery.scientist
+Subject: Re: Klausuren
+Message-ID: <5649@msgid.usenet-rundfahrt.de>
+Date: Thu, 22 Jul 2004 16:32:04 +0200
+
+Mathias Mildenberger schrieb:
+
+>Pruefung '97:
+>F: Was ist ein Iso-Korb?
+
+Der ISO-Korb ist ein standardisiertes Antwortschreiben auf Liebesbriefe,
+mit dem man mitteilen kann, dass man die Liebe nicht erwidert ohne dabei
+verletzend zu werden. Er wurde erstellt, weil die Wortwahl in seinem
+Vorgaenger, dem sogenannten DIN-Korb, nicht mehr zeitgemaess war.
+
+Frank
+
+-----------------------------------------------------------------------------
+
+
+
+Tja... (Ronda, 23. Jul 2004, 23:05:38):
+... und was sind dann Leute, die Nightwish oder Within Temptation und so
+machen...?
+
+Message-ID: <slrncft79n.jjj.ihr.name@exil.strg-alt-entf.org>
+From: Ralph Angenendt <ihr.name@strg-alt-entf.org>
+Newsgroups: de.rec.musik.rock+pop
+Subject: Re: Musikdefinitionen
+Date: Wed, 21 Jul 2004 16:43:35 +0000 (UTC)
+
+
+ Well, Matthias Mees <netuse@madisonheights.de> wrote:
+> Andrew Morgan writes:
+>
+>> Blues - Music by guys who lost their women
+>
+> Aeh ... und Country (beide Sorten)?
+
+Music by guys who lost their horses
+
+Ralph
+
+-----------------------------------------------------------------------------
+
+
+
+Klausuren... (Ronda, 25. Jul 2004, 19:00:55):
+From: Adrian Suter <adrian.usenet@wortrei.ch>
+Newsgroups: de.alt.recovery.scientist
+Subject: Re: Klausuren
+Date: Thu, 22 Jul 2004 16:14:28 +0200
+
+Mathias Mildenberger <usenet@m-mildenberger.de> scripsit:
+
+>> Och... erinnere mich an eine Scheinklausur technisches Englisch, bei
+>> der zu einer Aufgabe zwar ein dreiseitiger Text angegeben war, aber
+>> keine Aufgabenstellung...
+>
+>Ich biete Baukonstruktion bei den Architekten, Bauhaus-Uni Weimar.
+>Der - inzwischen emeritierte - Prof liess Extrapunkte vergeben, wenn
+>jemand eine daemlich gestellte Frage auch nicht ganz ernst beantwortet hat.
+
+Eine Mitstudentin erzaehlte mir, sie sei in der muendlichen Pruefung
+Kirchengeschichte, Spezialgebiet englische Reformation, gefragt worden, was
+eine Bloody Mary sei.
+
+Adrian
+
+-----------------------------------------------------------------------------
+
+
+
+Telefonitis (Arathorn, 27. Jul 2004, 22:42:33):
+Von:      Nico Lubitz <bayern-fan@gmx.net>
+Gruppen:  de.alt.netdigest
+Datum:    Tue, 27 Jul 2004 16:00:04 +0000 (UTC)
+
+From: Martina Lenzen <not.for.spam@web.de> Subject: Re: Tooor! Gelb.
+Newsgroups: de.alt.talk.unmut
+Date: Tue, 20 Jul 2004 21:55:15 +0200 Message-ID:
+<1ehl7y1chpf4u$.1jhdh3uv5t8ot$.dlg@40tude.net>
+
+
+Juergen Pfingst schrieb:
+
+> Martina Lenzen <not.for.spam@web.de> hatte geschrieben:
+> 
+>> Um beim Thema Telefon zu bleiben: In den goldenen Tagen, als
+>> hierzulande noch BBC Prime ins Kabelnetz eingespeist wurde, ist mir aus
+>> einer der dort ausgestrahlten Comedies noch sehr gut Mrs Bucket in
+>> Erinnerung, die sich am Telefon folgendermassen meldete: "The Bucket
+>> residence, the lady of the house speaking". Gaebe es hierzu eine
+>> adaequate deutsche Uebersetzung, ich wuerde mich nur noch so melden, ob
+>> die Gegenstelle dazu kompatibel waere
+> 
+> Danke, Martina!
+> 
+> Ab sofort werde ich mich am haeuslichen Telefonapparat melden wie folgt:
+> "Palais Romanow - es spricht der Zar persoenlich!"
+
+Naja, ich vermute mal "Palais Pfingst - es spricht der Ochse persoenlich"
+kaeme auch nicht so gut.
+
+Gruss
+Martina
+
+
+-----------------------------------------------------------------------------
+
+
+
+ISO 9001 (Ronda, 31. Jul 2004, 19:45:59):
+From: Guido Hennecke
+<0d-01-2004-nospam-remove-this@usenet.kicks-ass.org>
+Subject: Re: Schwere Sicherheitsmaengel bei Internet-Services der T-Com
+Newsgroups: de.comm.provider.misc
+Date:Thu, 29 Jul 2004 16:31:30 +0000 (UTC)
+Message-ID:
+<slrncgi9j2.ojr.0d-01-2004-nospam-remove-this@usenet.kicks-ass.org>
+
+[SN: auf den witzigen Teil eingedampft]
+
+... zur Qualitaetssicherung ein Schmankerl aus ISO 9001:
+
+Du kannst ein Unternehmen nach ISO 9001 zertifizieren lassen
+(erfolgreich), welches Schwimmwesten aus Beton herstellt.
+
+Es muss nur genau so gemacht werden, wie es dokumentiert ist.
+
+-----------------------------------------------------------------------------
+
+
+
+Re: ISO 9001 (Pilgrim,  2. Aug 2004, 11:11:22):
+~#! rn=Ronda rt=1091295959 rg=schmarrn.netdigest
+~#! tid=1091295959
+> ... zur Qualitaetssicherung ein Schmankerl aus ISO 9001:
+> 
+> Du kannst ein Unternehmen nach ISO 9001 zertifizieren lassen
+> (erfolgreich), welches Schwimmwesten aus Beton herstellt.
+> 
+> Es muss nur genau so gemacht werden, wie es dokumentiert ist.
+
+Wobei ich das wenig _witzig_ finde: Die Norm beschreibt halt die Sicherung
+eines
+Bestimmten Quallitaetsstandarts (Produnktion) ... und nicht die den
+Sinn/Unsinn
+(Wirksamkeit/Unwirksamkeit) von produzierten Guetern, oder?
+
+Das ist so, wie:
+'Magnetische Einlegesohlen zur Verminderung des Benzinverbrauchs bein
+Autofahren", ISO 9001 zertifiziert, TUeV
+ getest, medizinisch erprobt. * VW bestaetigt: Diese Einlegesohlen wurden
+entwickelt, um den Benzinverbruach eines jeden Kraftfahrzuegs drastisch zu
+vermindern.
+
+Und .. was heist das: Genau -> garnix
+
+Pilgrim
+
+PS: Ups TUeV sollte wohl TUeV heissen ;-)
+PPS: Ahrrr ... ersetzte der Editor U-Umlaut durch ue? Ich dachte schon: Ich
+hab doch Ueeess geschrieben, jetzt stehen dua u-e's ;-)
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: ISO 9001 (Zook,  2. Aug 2004, 11:42:37):
+~#! rn=Pilgrim rt=1091437882 rg=schmarrn.netdigest
+~#! tid=1091295959
+Ein Hinweis auf ISO 9001 darf eben nicht auf Produkten erscheinen, weil
+es sich um eine Norm fuer das Unternehmen und seine Prozesse handelt.
+
+Zook.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: ISO 9001 (Grimmborn,  2. Aug 2004, 12:01:29):
+~#! rn=Zook rt=1091439757 rg=schmarrn.netdigest
+~#! tid=1091295959
+Irgendwie denke ich, Pilgrim sollte seinen Editor mal TUeV-zertifizieren
+lassen.
+
+GdA
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: ISO 9001 (Pilgrim,  2. Aug 2004, 17:51:21):
+~#! rn=Grimmborn rt=1091440889 rg=schmarrn.netdigest
+~#! tid=1091295959
+LOL
+
+PilgrUEm
+
+-----------------------------------------------------------------------------
+
+
+
+Re^5: ISO 9001 (Nibel,  2. Aug 2004, 17:53:27):
+~#! rn=Pilgrim rt=1091461881 rg=schmarrn.netdigest
+~#! tid=1091295959
+Und dafuer tipp ich nn...
+  - Nibel
+-----------------------------------------------------------------------------
+
+
+
+Re^6: ISO 9001 (Zook,  2. Aug 2004, 17:56:55):
+~#! rn=Nibel rt=1091462007 rg=schmarrn.netdigest
+~#! tid=1091295959
+Auch hierfuer wirst Du nn tippen,
+
+Zook.
+
+-----------------------------------------------------------------------------
+
+
+
+Ein schmarrn.netdigest ganz speziell fuer Kiff@MG. (Ronda,  5. Aug 2004, 00:44:08):
+Subject: Re: Gutmenschen
+From: Hannes-Petersen@Hamburg.de (Hannes Petersen)
+Newsgroups: de.rec.sf.misc
+Message-ID: <dde528fd.0407310358.6548f21d@posting.google.com>
+Date: 31 Jul 2004 04:58:51 -0700
+
+Matthias Warkus schrie:
+> Ruediger Silberer:
+>>> Dieser staendige Zeigefinger, der uns weismachen will, was man alles aus
+>>> dem Verhalten des edlen Gutmenschen so alles lernen kann. Ich will aber
+>>> ohne staendige unterschwellige Indoktrination unterhalten werden.
+>> Bei Buechern ist dies noch aergerlicher. Siehe "Der Schwarm" von
+>> Schwaetzing, auf jeder Seite der erhobene Zeigefinger nach dem Motto:
+>> "Der Mensch ist schlecht" und "Die Natur schlaegt zurueck".
+> Was hast du denn beim Lesen geraucht?
+
+Das Buch, Mann! Das Buch!
+
+Die neueste Erfindung, auf die die Welt gewartet hat: Papier aus Hanf
+und Tinte auf Lysergsaeurebasis.
+
+Die Vorteile liegen auf der Hand:
+- Im Gegensatz zu ebooks sind h<anf>books biologisch sowas von
+abbaubar, dass es nur so raucht.
+- Gefaellt dir ein Buch, stellst du's ins Regal. Fehlkaeufe hingegen
+werden einfach weggeschmoekt.
+- <Mutti>Habt ihr hier etwa geraucht??</Mutti> <Stepke>Nein, Mama,
+gelesen. Wir lesen nur.</Stepke>
+- Probleme an Drogen zu kommen? Wozu gibt es die Gelben Seiten?
+- Klar gibts da auch was von Ratiopharm. Und wenn selbst der Arzt oder
+Apotheker nicht weiter weiss, rauchen Sie einfach den Beipackzettel.
+- Der Bibliomane aus der Wohnung unter mir hat einen Wohnungsbrand;
+das Treppenhaus voller Qualm, die Feuerwehr noch nichtmal informiert,
+ich weiss, ich werde sterben. Bin ich panisch? No Way! Ich springe
+einfach singend aus dem Fenster: "I believe, I can fly ..."
+- Der Fragebogen fuer Hartz-IV ist dir zu kompliziert? Dann nimm ihn
+gleich zweimal mit, einen kannst du dann sogar ausfuellen.
+- Aerger mit dem Mathebuch? Dann lass einfach mal Fuenfe gerade sein!
+- <Wal-Mart-Angestellte>Wollen Sie eine Tuete?</Wal-Mart-Angestellte>
+<Ich>"Ja sicher will ich eine Tuete!"</Ich>
+- <Oma>Na, Klein-Hannes, was willst du spaeter einmal werden?
+Rennfahrer? Astronaut?</Oma> <Klein-Hannes>Chefbibliothekar in
+Alexandria.</Klein-Hannes>
+Hm. Da kommt mir jetzt spontan der Verdacht, dass diese Erfindung
+eventuell gar nicht sooo neu ist ...
+
+/Hannes
+
+-----------------------------------------------------------------------------
+
+
+
+Autsch? (Ronda,  6. Aug 2004, 22:58:13):
+From: David Kastrup <dak@gnu.org>
+Newsgroups: de.sci.mathematik
+Subject: Re: Vorbereitung Mathe-Studium
+Date: 05 Aug 2004 13:39:44 +0200
+Organization: Organization?!?
+Message-ID: <x5n0196cfz.fsf@lola.goethe.zz>
+
+Oliver Vogel <nirvana@vogel-haus.de> writes:
+
+>On Tue, 03 Aug 2004 08:51:14 +0200, Michael Karlinsky
+><michael.karlinsky@alcatel.de> wrote:
+>
+>> Nun ja, frueher oder spaeter wirst du irgendetwas mathematisches
+>> formulieren muessen, und Aussagen wie "Mein Vektorraum ist ziemlich
+>> geil." o.ae. kommen bestimmt nicht so gut an...
+>
+>Dagegen kommen Formulierungen wie "Ich betrachte meinen
+>Unterkoerper..."  in der Regel sehr gut an ;)
+
+Mathevorlesung:  "... fuehre ich hier noch einen Winkel theta ein."
+Zwischenruf aus dem Hoersaal: "Bitte keinen Winkel, die sind doch immer
+so spitz!"
+
+Spaeter: "... und wenn wir hier noch etwas Mathematik hineinstecken,"
+Zwischenruf: "Aber da steckt doch noch der Winkel!"
+
+Spaetestens ab da war die Konzentrationsfaehigkeit des Publikums
+nachhaltig gestoert.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^21: Klassische Rechtschreibung (Ronda,  9. Aug 2004, 00:17:01):
+~#! rn=Miril rt=1092003153 rg=diskussion
+~#! tid=1091790396
+Auch schmarrn.netdigest nimmt sich des aktivsten Themas der MPA an:
+
+From: Vinzent 'Gadget' Hoefler <nntp-2004-08@t-domaingrabbing.de>
+Subject: Re: Spiegel und Springer kippen Reformschreibung
+Newsgroups: de.etc.sprache.deutsch
+Date:Fri, 06 Aug 2004 15:58:42 +0200
+Message-ID: <5h37h05upr1hl2tdpt14n9v9s5n1gkqubq@jellix.jlfencey.com>
+
+>Ach, ist das Niveau des Focus mittlerweile soweit gesunken, dass ihn
+>die ABC-Schuetzen lesen?
+
+Nein, es ist endlich so weit gestiegen.
+
+-----------------------------------------------------------------------------
+
+
+
+Veganer und B12 (Nonne, 10. Aug 2004, 08:12:01):
+Mail ist ja auch Netz und digest finde ich das allemal:
+
+>We can be nice to plants by eating more vegan but we can also do vegans a 
+>great favor when we shit over their vegetables. Here is the reason why:
+>
+>>> Human faeces can contain significant B12. A study has shown that a group 
+>of 
+>Iranian vegans obtained adequate B12 from unwashed vegetables which had been 
+>fertilised with human manure. Faecal contamination of vegetables and other 
+>plant foods can make a significant contribution to dietary needs, 
+>particularly in areas where hygiene standards may be low. This may be 
+>responsible for the lack of aneamia due to B12 deficiency in vegan 
+>communities in developing countries.
+
+Nonne, freut sich schon auf die naechste Unterhaltung mit einem Veganer.
+
+-----------------------------------------------------------------------------
+
+
+
+Artikel und Sig... (Ronda, 13. Aug 2004, 18:30:14):
+... sind IMHO lesenswert.
+
+Ronda
+
+Message-ID: <2nrlusF41r8pU1@uni-berlin.de>
+From: spam.for.the@buerotiger.de (Peter Lemken)
+Newsgroups: de.alt.talk.unmut
+Subject: Re: Rechtschreibreform
+Date: 10 Aug 2004 10:22:20 GMT
+
+Andreas Henicke <henicke@t-online.de> wrote:
+
+[Rechtschreibreform]
+
+> Gruss, An<was spraeche eigentlich gegen eine Volksabstimmung>dreas.
+
+Standartargumente
+
+Peter Lemken
+Berlin
+
+-- 
+Life is not a journey to the grave with the intention of arriving safely in
+a pretty and well-preserved body, but rather to skid in broadside, thoroughly 
+used up, totally worn out and loudly proclaiming, 'Wow, what a ride!'
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Veganer und B12 (Maharet, 16. Aug 2004, 12:28:58):
+~#! rn=Nonne rt=1092118321 rg=schmarrn.netdigest
+~#! tid=1092118321
+Veganer wissen sowas.
+
+-----------------------------------------------------------------------------
+
+
+
+Boese - oder die Wahrheit? (Ronda, 28. Aug 2004, 21:46:04):
+From: Mark Obrembalski <markobr@web.de>
+Subject: Re: Mausefallen und Tierschutzgesetz
+Newsgroups: de.soc.recht.misc
+Date: 19 Aug 2004 18:53:39 GMT
+Message-ID: <2okb9jFbm8ioU2@uni-berlin.de>
+
+
+Dominik Schneider <schnakls@t-online.de> schrieb:
+> Es soll doch tatsaechlich auch Mausefallen geben die nicht toeten... das
+Tier
+> setzt man dann einfach auf der naechsten Wiese aus (idealerweise mehrere km
+> entfernt) und gut ist.
+
+Dorthin begibt man sich dann zweckmaessigerweise per Auto und
+ueberfaehrt unterwegs einen Igel und mehrere Erdkroeten.
+
+Mark
+
+-----------------------------------------------------------------------------
+
+
+
+Das koennte auch... (Ronda, 31. Aug 2004, 23:58:34):
+... zu gewissen aktuellen Diskussionen in der MPA passen, oder?
+
+From: Michael Hemmer <mhemmer@nospam_samson.de>
+Subject: Re: Hessische Kultusministerin stammt aus Paralleluniversum!
+Newsgroups: de.etc.sprache.deutsch
+Date: Mon, 23 Aug 2004 12:57:51 +0200
+Message-ID: <4129cda9_1@news.arcor-ip.de>
+
+...
+
+Wenn man sich anschaut, was der Durchschnittsmensch so schreibt (und
+schrieb), kann man eigentlich nur zu dem Schluss kommen, dass jede Art
+der Rechtschreibung von der Mehrheit der Bevoelkerung abgelehnt wird.
+
+-----------------------------------------------------------------------------
+
+
+
+rm -r / (Ronda,  1. Sep 2004, 00:08:10):
+Hat was ;-)
+
+From: Jan Hladik <jan.hladik@gmx.net>
+Newsgroups: ger.ct
+Subject: Re: Einmal nur im Leben Soll die Erde beben: "rm -r /"
+Date: Tue, 24 Aug 2004 18:14:34 +0200
+Message-ID: <412B696A.92B67BC4@gmx.net>
+
+Herwig Huener wrote:
+> 
+> 2004-08-24 13:10:07 MESZ
+> 
+> OK - wenn man ein ganz neues Unix-Linux
+> aufbuegeln moechte - mit /home-Partitionen
+> und vielleicht noch eingemounteten
+> NFS-Partitionen - dann koennte man mit
+> der alten Installation noch mal als root
+> ganz absichtlich ein "rm -r /" probieren.
+
+Ich hab's mal gemacht, als ich ein Linux komplett neu installieren
+wollte. Hatte die passende Boot-Diskette (Mitte der 90er) und die
+Packages auf der Win (DOS?)-Partition. Also noch ein letztes mal
+gecheckt, dass im /home-Baum keine wichtigen Daten mehr sind, und dann 
+
+rm -r /
+
+> Hat das schon mal jemand gemacht? Wie
+> weit kommt er mit dem Loeschen, bevor
+> das System arbeitsunfaehig wird?
+
+Gar nicht. Erst nach dem Reboot. Komischerweise konnte ich danach aber
+die Installationspakete auf der Win-Partition nicht mehr lesen. Nach dem
+Durchprobieren aller Kombinationen von /dev/hd** wollte ich dann Windows
+booten, um nachzusehen, wo denn die ganzen Paketchen hin sind, und siehe
+da, auch kein Windows mehr.
+
+Vielleicht haette ich vor dem rm die Windows-Partition unmounten
+sollen...
+
+> Und wie fuehlt man sich als Shiva der
+> WeltZerstoerer?
+
+Ganz schoen scheisse.
+
+Jan
+
+-----------------------------------------------------------------------------
+
+
+
+Jugend forscht meets de.talk.liebesakt (Ronda,  5. Sep 2004, 01:11:27):
+From: David Kastrup <dak@gnu.org>
+Newsgroups: de.talk.liebesakt
+Subject: Re: Keine Lust!?
+Date: 16 Aug 2004 14:55:17 +0200
+Message-ID: <x5wtzz1buy.fsf@lola.goethe.zz>
+
+Sabine <savage-rose@t-online.de> writes:
+
+[vom Einreicher gekuerzt]
+
+> *lach* gab auch bei mir eine Zeit, in der ich es spannend fand,
+> Frauen an die Brueste zu fassen... man muss ja schliesslich wissen,
+> wie sich das anfuehlt.
+
+Wie unwissenschaftlich.  Als Knirps habe ich seinerzeit bei meiner im
+Mittagsschlaf befindlichen Oma mit einer Stecknadel probiert, ob
+selbige platzen koennen.  Da das aber vor der Zeit von Silikonkissen
+war, ist eher die Oma selbst geplatzt.
+
+--
+David
+
+-----------------------------------------------------------------------------
+
+
+
+LFS (Foobar,  5. Sep 2004, 20:45:51):
+From tim@tim-landscheidt.de Sun Sep  5 20:23:58 2004
+Newsgroups: de.alt.netdigest
+Path:
+uni-berlin.de!fu-berlin.de!news.uni-stuttgart.de!rz.uni-karlsruhe.de!inka.de!n
+ews.sub.net!book7.ms.sub.org!sparrow.datentrampelpfad.de!not-for-mail
+From: Tim Landscheidt <tim@tim-landscheidt.de>
+Subject: [de.comm.software.gnus] Re: Message/reply: automatische Auswahl des
+from
+Date: 30 Aug 2004 10:57:32 GMT
+Sender: toje@nightingale.ms.sub.org
+Followup-To: de.talk.jokes.d
+Lines: 35
+Content-Transfer-Encoding: 8bit
+Content-Type: text/plain; charset=ISO-8859-15
+Approved: toje@nightingale.ms.sub.org
+MIME-Version: 1.0
+Message-ID: <5e1022b75148a473fe73996db339e83c@sparrow.datentrampelpfad.de>
+Organization: Datentrampelpfad Duesseldorf-Holthausen, Germany
+Xref: uni-berlin.de de.alt.netdigest:12233
+
+Newsgroups: de.comm.software.gnus
+Subject: Re: Message/reply: automatische Auswahl des from
+From: Oliver Scholz <alkibiades@gmx.de>
+
+Holger Schauer <Holger.Schauer@gmx.de> writes:
+
+> On 3999 September 1993, Reiner Steib wrote:
+[...]
+>> [1] IIRC hat Oliver deshalb mal als unter dem Pseudonym "Richard
+>>     Stallman" auf emacs-devel gepostet.
+>
+> Autsch.
+
+Ja, das habe ich auch gesagt. Um die Anekdote zu vervollstaendigen: Ich
+hatte damals dann, diesmal unter meinem richtigen Namen, auf
+emacs-devel klar gestellt, was geschehen ist. Dennoch erhielt ich kurz
+darauf eine Mail von RMS. Offensichtlich hatte er sich ueber die Mail
+gewundert, die unter seinem Namen in der Mailingliste aufgetaucht war,
+die aber nicht von ihm stammt. Jedenfalls muss er sich wohl den header
+angeschaut haben. Dort stand bei mir damals noch unter Anderem:
+"X-Operating-System: Linux from Scratch". Und er bemaengelte dann auch
+gleich, dass es "GNU/Linux" heissen muesse.
+
+Doppelt peinlich.
+
+    Oliver
+-- 
+1 Fructidor an 212 de la Rvolution
+Libert, Egalit, Fraternit!
+
+-- 
+Submissionen fuer de.alt.netdigest bitte an
+<de-alt-netdigest@moderators.dana.de> schicken.
+Der Submitter ist fuer den Inhalt der Einreichung verantwortlich, 
+nicht der Moderator der Newsgruppe.
+
+
+-----------------------------------------------------------------------------
+
+
+
+Realitaet. Irgendwie. (Ronda,  9. Sep 2004, 01:07:09):
+From: Oliver Jennrich <oliver.jennrich@gmx.net>
+Newsgroups: de.soc.recht.misc
+Subject: Re: Beleidigung im Zug
+Date: Mon, 06 Sep 2004 10:39:33 +0200
+Message-ID: <81n0034wqi.fsf@ID-371.user.uni-berlin.de>
+
+* Eric Schneider writes:
+
+> Hallo,
+> ich habe gerade bei einer Zugreise eine unschoene Situation erlebt: Ich
+> verliess das Grossraumabteil in Richtung Bordbistro und vergass die Tuer
+> hinter mir zu schliessen. Daraufhin bruellte ein Mitreisender laut "Tuer
+> zu!". Ich war ueber den Tonfall erschrocken und antwortete "Das kann
+> man auch freundlicher sagen", darauf er "Du Scheisskerl denkst du waerst
+> was besonderes, ich red mit dir wie's mir passt." Ich war schockiert
+> und habe lieber nichts mehr gesagt, dazu betretenes Schweigen bei den
+> Passagieren. Ich habe meine Sachen genommen und bin in einen anderen
+> Wagen. Jetzt fuehlt dieser Asoziale sich auch noch als Sieger...
+
+> Frage: Wie gehe ich zukuenftig in diesen Situationen vor? 
+
+Das haengt davon ab:
+
+a) Die ueberlegene Methode:
+   Laecheln, weitergehen
+
+b) Die besorgte Methode:
+   Visitenkarte mit Dr. med. Irgendwas herausholen, dem Brueller in die
+   Hand druecken und ihm erklaeren, dass solche Zornesausbrueche auf einen
+   Nierentumor hindeuten und er sich doch mal bei Gelegenheit untersuchen
+   lassen soll
+
+c) Die provokante Methode:
+   Brueller angrinsen, betont laessig zur Tuer schreiten, diese ganz
+   oeffnen und zum Schluss den Mittelfinger-Gruss entbieten
+
+d) Tuerstehermethode
+   Zum Brueller gehen und ihm vorschlagen das Problem beim naechsten
+   Zughalt 'vor der Tuer' weiterzudiskutieren.
+
+e) Tuerstehermethode, Dringlichkeitsmodus
+   Wie d), das klaerende Gespraech findet zwischen den Wagen statt
+
+f) Tuerstehermethode, Code Red
+   Im Vorbeigehen den Unterkiefer brechen.
+
+
+-----------------------------------------------------------------------------
+
+
+
+Man beachte bitte... (Ronda, 10. Sep 2004, 21:00:27):
+... besonders das T-Shirt. Find ich zum Fliegen echt passend.
+
+
+[SN: "Bjoern" fragt vor der Einstellungsuntersuchung einer Airline, ob er
+seine Frisur und sein Piercing zwecks Steigerung der Erfolgschance den
+Job zu bekommen, aendern soll. Quoting auf den relevanten Teil gekuerzt]
+
+Von: Thomas Stoll <mail_will_be_deleted@gmx.net>
+Betreff: Re: Piloten und ihr Erscheinungsbild
+Gruppen: de.rec.luftfahrt
+Message-ID: <chirlk$6mg$01$1@news.t-online.com>
+Datum: Tue, 07 Sep 2004 01:25:36 +0200
+
+
+> Bjoern wrote:
+> 
+>> Ich kann mir vorstellen, dass Passagiere eine gewisse Optik erwarten
+> 
+> Das Problem ist nicht, dass die Passagiere das erwarten, das tun die 
+> meisten naemlich ueberhaupt nicht, und erstaunlicherweise am 
+> allerwenigsten die aelteren. Das Problem ist vielmehr, dass die Manager
+> meinen, die Passagiere wuerden etwas erwarten. [...]
+
+Uhhh, so pauschal wuerde ich das nicht sagen. Die Leute, deren Firma viel
+Geld fuer irgendwelche Business-Class Tickets zahlt, erwarten durchaus, 
+dass die Stewardessen alle jung sind, hypsch aussehen und eine Vorlage 
+zur Illusion einer mile-high-Mitgliedschaft darstellen.
+
+Ebenso sollen die Piloten allesamt stramme Burschen sein und nicht 
+irgendwelche langhaarigen Bombenleger, die zwar die Fliegerei 
+bedingungslos beherrschen, aber mit AC/DC-T-Shirt und Lederweste in die 
+Kiste einlaufen, um dann "Rock'n'Roll" ins Mikro zu ruelpsen.
+
+> Ich weiss, wovon ich rede (wenn auch in einer anderen Branche).
+
+Ich auch. Rundflug: Ich setzt mich, wie ueblich, Teva-Latschen, Jeans mit
+Loch am Knie, Headset und Kram in einer verbeulten Stofftasche,
+verbogene Muetze auf'm Kopp und ein T-Shirt mit Goethe-Zitat 
+"Unsterblichkeit ist nicht jedermanns Sache" ans Steuerhorn.Die Leute
+vom Verein wissen, dass ich fast immer so rumlaufe. Unwissende Fluggaeste
+aendern meist spontan ihre Gesichtsfarbe.
+
+
+-----------------------------------------------------------------------------
+
+
+
+Hoher Besuch (Foobar, 10. Sep 2004, 21:04:49):
+Newsgroups: arcor.misc
+From: runforcover@menthe.info (Ren Fuchs)
+Message-ID: <1gjueua.1878kqcjk7sdaN%runforcover@menthe.info>
+NNTP-Posting-Date: 09 Sep 2004 11:10:29 MEST
+
+Arcor Newsticker <dpa@arcor-online.net> wrote:
+
+> 09.09.2004, 10:55 Uhr
+>
+> Berlin (dpa) - Der irakische Praesident Ghasi el Jawar hat von
+> Deutschland einen Schuldenerlass fuer sein Land gefordert. Bei
+> einem Treffen mit Bundespraesident Horst Koehler in Berlin sagte
+> er, das sei die wichtigste Frage seines Besuchs in Berlin. Er
+> wird im Laufe des Tages mit Bundeskanzler Gerhard Schroeder und
+> Aussenminister Joschka Fischer zusammentreffen. Am Morgen war
+> Ghasi el Jawar von Koehler zu seinem ersten Besuch in
+> Deutschland mit militaerischen Ehren empfangen worden.
+
+Augsburg (refu) - Der deutsche Buerger Ren Fuchs hat von seiner
+Hausbank einen Schuldenerlass fuer seinen Haushalt gefordert. Bei
+einem Treffen mit der Schalterangestellten Angelika Mankelmann in
+Neusaess sagte er, das sei die wichtigste Frage seines Besuchs
+bei der Bank. Er wird im Laufe des Tages mit einem Auszugsdrucker
+und einem Geldautomaten zusammentreffen. Am Morgen war Ren Fuchs
+zu seinem 257. Besuch bei seiner Hausbank mit einem "Gruess Gott"
+empfangen worden.
+
+-----------------------------------------------------------------------------
+
+
+
+Ein wahrer Rant... (Ronda, 12. Sep 2004, 22:46:52):
+... geeignet auch fuer entsprechende Rubriken der MPA...
+
+Betreff: Re: Fruehstuecksunmut
+Datum: Tue, 7 Sep 2004 23:09:23 +0200
+Von: spam-or-nospam@gmx.de (Manfred Russ)
+Foren: de.alt.talk.unmut
+
+Wed, 1 Sep 2004 07:40:48 +0200 Sabine Loss schrieb: 
+
+> > Aber ich meine mich zu erinnern, dass das Thema schonmal durch war.
+> 
+> Dieses Thema liegt aber regelmaessig, wenn nicht sogar taeglich, vor
+> einem auf dem Teller - und das zu einer Tageszeit, zu der Regungen
+> wie Nachsicht oder Verstaendnis fuer das harte Baeckerei-Handwerk (wieso
+> selbst backen, wenn aufbacken schneller und billiger ist) noch nicht
+> wach sind (bzw. bei Unmuetigen, da eher OT, sowieso nicht vorhanden sind).
+
+Da klingt in Deiner Antwort das Thema "selbst backen" an.
+
+Denn es gibt Leute, die sich dieser Tendenz beherzt, um nicht zu sagen 
+fanatisch,[1] entgegenstellen. Leider hat man nicht immer das Glueck, 
+eindeutige Indizien rechtzeitig zu erkennen, und man ist kompromittiert.
+
+Voellig zu recht raet auch Ildiko von Kuerthy ihren Freundinnen im Geiste, 
+umgehend die Flucht zu ergreifen, sollten sie im Haushalt ihres 
+angehenden Stechers einer Getreidemuehle ansichtig werden.
+
+Selbst gebackenes Brot hat neben dem besonderen Scharm, wie ihn nur der 
+Nicaragua-Kaffee der achtziger Jahre verbreiten konnte, den Vorteil, 
+Echte Freunde von Gesinnungsmitlaeufern unterscheiden zu koennen. Echte 
+Freunde sagen einem die Wahrheit - waehrend Andere Freunde die 
+unverfaelschte Natur, das backhandwerkliche Geschick, bestenfalls den Mut 
+zur Unvollkommenheit loben. Nicht immer handelt man nach seinen Maximen; 
+allzu oft sieht man sich in Situationen, die, auch aufgrund des 
+allgemeinen Publikums am Fruehstueckstisch (topic!), es als ratsam 
+erscheinen lassen zu luegen, und somit der Tugend der Hoeflichkeit[2] 
+Prioritaet einraeumen. 
+
+Die Grundlagen dessen, was man als heiteres, entspanntes morgendliches 
+Zusammensein erhofft hatte, kommt oft genug in Kastenform daher. Was man 
+(da es auch so aussieht) eigentlich dem naechstbesten Einbrecher an den 
+Kopf werfen moechte, wird von der stolzen Baeckerin auf ein Brett 
+gewuchtet und in knoecheldicke Scheiben geschnitten. Diese haben immerhin 
+den schaetzenswerten Vorteil, dass man davon eine gehoerige Maulsperre 
+bekommt, was aufgrund der betonaehnlichen Konsistenz mich einige Minuten 
+lang von jedweder aktiven Kommunikation entbindet.
+Der Nachteil ist eben der: man hat zwar was im Mund, aber dennoch nichts 
+zu essen; man mag damit zwar das Bad kacheln koennen, aber kein Fruehstueck 
+bestreiten.
+
+Gerechterweise muss man dazu sagen, dass es zwei Grundmodelle eigenen 
+Brotbackwerkens gibt:
+- das Brikett, das mechanische Einfluesse weitgehend unbeschadet 
+uebersteht (dem korreliert absolute Ungeniessbarkeit[3], hervorgerufen 
+durch krudeste Kraeuterbeimischungen, gerne nach dem Mondkalender), sowie
+- das amorphe Konglomerat[4], das sich zwar der Bearbeitung durch Messer 
+und Butter nicht sperrt, diese Annaeherungsversuche (sofern es ueberhaupt 
+gelungen ist, eine Scheibe davon heile abzuschneiden) jedoch mit 
+allerlei Aufloesungserscheinungen quittiert. (Schmecken tut das ganze 
+dann wie zusammengepapptes Saegemehl.)
+
+Und bevor ich jetzt wieder von boesen Erinnerungen an Alternativ-WGs der 
+fruehen Jahre heimgesucht werde, beende ich das Posting an dieser Stelle.
+
+
+[1] Wo muss in diesem Nebensatz das Komma hin?
+[2] Hat man aber Pech, wird man wieder eingeladen.
+[3] Nein, das widerspricht sich nicht.
+[4] Wer jemals Loecher in Waende von Nachkriegswohnungen gebohrt hat, 
+weiss, was ich meine.
+
+
+Manfred
+
+-----------------------------------------------------------------------------
+
+
+
+Boese, nicht fuer Pflanzenquaeler geeignet (Ronda, 14. Sep 2004, 22:24:49):
+From: "Ulf Gutschmidt" <ulfgutschmidt@web.de>
+Newsgroups: de.alt.folklore.urban-legends
+Subject: Re: Sind pillenschluckende Veganer Heuchler?
+Date: Fri, 10 Sep 2004 01:00:46 +0200
+Message-ID: <2qc6kjFtqr8aU3@uni-berlin.de>
+
+[SN: gekuerzt]
+
+Aber es gibt eine hypsche Episode aus dem Flugzeug.
+Ort der Handlung: Ein Mitteleuropaflug der Deutschen BA.
+Zeit: Gestern Mittag.
+Personen: Eine Vegetarierin, eine Stewardess, ein UG.
+
+*Bordcrew beginnt mit dem Rumpeln der Essenkisten*
+(Schoene Flightcases uebrigens, nur mal so von Musiker zu Musiker erwaehnt)
+*Fluggaeste erwachen aus der allgemeinen Lethargie*
+*Stewardess naehert sich der Reihe, in der UG und eine ihm voellig fremde,
+halbverhungerte, faltige weibliche Person sitzen.*
+"Guten Appetit, ich hoffe, dass Ihnen die Mahlzeit gut schmeckt!"
+"ICH MOeCHTE EINE VEGETARISCHE MAHLZEIT!!!"`
+"Tut mir leid, das muss bis 24 Stunden durch den Fluggast extra bestellt
+worden sein, wir haben keine Bestellung vorliegen."
+(Knallhart, "wie aus der Pistole geschossen" und souveraen durch die
+Stewardess vorgetragen, Kompliment)
+"ICH PROTESTIERE!! BEI JEDER ANDEREN FLUGGESELLSCHAFT BEKOMME ICH OHNE
+VORBESTELLUNG VEGETARISCHES ESSEN!!!"
+"Tut mir wirklich leid, aber das muss ich bezweifeln. Ich koennte Ihnen
+Kekse anbieten, oder ein Broetchen mit Margarine."
+"NEIN, VON IHNEN WILL ICH NICHTS MEHR!"
+*UG mapft zwischenzeitlich mit Genuss das durchaus schmackhafte kalte
+Schweinrueckensteak, welches recht gross ausfiel. Dafuer war das beigefuegte
+Salatblatt so winzig klein, das es fuer den weiteren Verlauf eine Rolle
+spielen musste*
+"FINDEN SIE ES NICHT AUCH UNMOeGLICH, DASS DIE DBA SO MENSCHENUNWUeRDIG
+IST?!?!?"
+"Ich kann ihre Wut gut verstehen. Zum Trost habe ich hier eine ganz
+tolle, vollwertige vegetarische Mahlzeit als Zugabe bekommen. Ich wuerde
+Ihnen diese gerne schenken, um Ihre Laune zu verbessern."
+*Winziges Salatblatt wird ruebergereicht*
+"ICH LASSE MICH HIER NICHT AUCH NOCH VERARSCHEN!!!!! MIR REICHT ES
+JETZT!!"
+"Mir auch. Und ab jetzt ist hier mal Ruhe, ok?!"
+*Vegetarierin, sehr faltiges Gesicht zur Faust
+geballt, wendet sich unter innerem Protest ab*
+
+UG
+
+-----------------------------------------------------------------------------
+
+
+
+40 (Ronda, 16. Sep 2004, 00:10:32):
+From: Michael Hemmer <me2@privacy.net>
+Subject: Re: Gebaecke (war: Lernen lehren)
+Newsgroups: de.etc.sprache.deutsch
+Date:Sun, 12 Sep 2004 17:33:58 +0200
+Message-ID: <41446c1b$0$26100$9b4e6d93@newsread4.arcor-online.net>
+
+> Ich weiss nicht, wie Helga "40" spricht;
+
+Frauen sprechen das normalerweise ungefaehr [noynuntsvantsi].
+
+-----------------------------------------------------------------------------
+
+
+
+Manchmal ist menschliches Versagen echt lustig :-) (Ronda, 18. Sep 2004, 19:46:43):
+
+Date: Fri, 17 Sep 2004 22:56:52 +0200
+From: Helmut Barth <Helmut.Barth@arcor.de>
+Newsgroups: de.etc.bahn.misc
+Subject: Re: [NRW] Redesign ET 425
+Message-ID: <414b50a5$0$18565$9b4e6d93@newsread2.arcor-online.net>
+
+Salut!
+
+Jens Kaubisch schrieb:
+> Martin Purrucker <martin.purrucker@gmx.de> wrote:
+
+>>Gibt es dort Toiletten auf dem Bahnsteig?
+
+> Noe, aber massenhaft Baeume, Buesche und hohes Gras.
+
+Und das, wo noch vor Jahr und Tag an allen Zug WC angeschrieben war, dass 
+deren Benutzung im Bahnhof zu unterbleiben hat!
+
+[Anekdote]
+Zu seligen Bundesbahnzeiten stand ich diesbezueglich vor einem schweren 
+Dilemma. Ich hatte ein Fischbroetchen gefuttert, dass mir nicht besonders 
+wohlgesonne war, und nebenbei die Aufgabe einen Eilzug von Stuttgart 
+nach Tuebingen und zurueck zu bewegen. Nach dem Bereitstellen des Zuges 
+und kurz nach der Abfahrt kam es bereits zu ersten Andeutungen dass 
+Verdauungstechnisch was schieflaeuft.
+
+Nach dem Halt in Esslingen/N wurde ich mir doch recht unsicher ob ich 
+das bis Tuebingen durchhalte, und bei Altbach war mir klar: Ich brauche 
+ein WC, also ueber Funk die ZUe verstaendigt, dass sich die Weiterfahrt in 
+Plochingen wegen einer Unpaesslichkeit des Tf verzoegert. Wie froh war ich 
+bei der Einfahrt in Plochingen einen Tuebinger Kollegen am Bstg. zu 
+sehen, der Gastfahrt nach Tuebingen wollte. Dieser Verstand auch sofort 
+mein Winken und lief Richtung Lok. Als wir uns auf Hoehe des hinteren 
+Fuehrerstands begegneten fragte ich ihn, ob er eventuell weiterfahren 
+koenne, da ich mal das WC aufsuchen muesse. Er sagte ja, und ich 
+verschwand im Zug.
+
+Ab da wechselte ich an jedem Halt den Sitzplatz zwischen Lok und 
+Wagenzug, um nebenher einen Abloeser anzufordern. Doch mir wurde nur 
+erklaert, dass ich die Wahl zwischen Ausfall oder selbst fahren haette.
+So kam es dazu, dass die Fahrgaeste im Steuerwagen ihren Lokfuehrer oefter 
+sahen als ihnen aus Puenktlichkeitsgruenden lieb war. Und ich sah bei 
+jedem Halt das Vorwurfsvolle Schild "Die Benutzung im Bahnhofsbereich 
+ist untersagt!". Und bei jedem kleinen Druck ueberlegte ich mir, soll ich 
+wirklich auf freier Strecke anhalten, um diesem Gebot folge zu leisten?
+Ich entschied mich dafuer, ein schlechtes Vorbild zu sein.
+
+Bis Nuertingen hatten die meisten Fahrgaeste im Steuerwagen dann auch 
+schon gespannt was laeuft und hielten den Weg zwischen Fue-Tuer und WC 
+hindernisfrei und grinsten breit, wenn ich die Fue-Tuer oeffnete. In 
+Nuertigen hatte ich dann das Problem, dass es etwas laenger dauerte. 
+Waehrend ich noch versuchte gewisse Schwierigkeiten zu beenden hoerte ich 
+wie der Zugfuehrer abfertigte. Nachdem ich nicht an gewohnter Stelle aus 
+dem Zug schaute, griff dieser zur Pfeife um auf sich aufmerksam zu 
+machen, was ich wohl hoerte, aber aus bekanntem Grund sah ich davon ab 
+das Fenster an meinem aktuellen Aufenthaltsort zu oeffnen.
+
+Nach einiger Zeit hoerte ich wie der Zugfuehrer auf dem Bahnsteig nach 
+vorne geschlurft kam und fast direkt neben dem WC seine Pfeife mit aller 
+Kraft missbrauchte. Da oeffnete im Steuerwagen ein Reisender das Fenster 
+und rief: "Jetzt hoera se doch scho mit d'r Pfeiferei uff, deswegen 
+scheisst unser Lokfuehr'r au net schneller, hend sia etwa no net 
+mitkriagt, dass der die Scheisserei hot?" Ich waere vor Lachen fast von der 
+Schuessel gefallen und auch im Wagen war ein Riesengelaechter.
+
+Nach kurzer Zeit war ich dann in der Lage weiterzufahren und ich konnte 
+in Wernau sogar das Laufen auslassen, was mir in Plochingen die 
+Bemerkung: "Hoi, mir hend scho denkt, es haett sich bessret" einbrachte, 
+die mit allgemeiner Froehlichkeit aufgenommen wurde.
+
+Ich beendete die Fahrt in Stuttgart nach 10 Halten und 9 WC Besuchen mit 
+ungefaehr 12 Minuten Verspaetung. Und ja, ich war gerne ein schlechtes 
+Vorbild ;-).
+[/Anekdote]
+
+Gruessle, Hel*bitte-keinen-Fisch*mut
+
+-----------------------------------------------------------------------------
+
+
+
+No comment (c; (Nonne, 20. Sep 2004, 13:25:00):
+[Es geht um Dottikons; auf das Wesentliche gekuerzt]
+
+Message-ID: <cicp0t.1ps.1@stefan.msgid.phost.de>
+Subject: Re: Vakuumverpackt
+From: Stefan Reuther <stefan.news@arcor.de>
+Date: Thu, 16 Sep 2004 19:19:57 +0200
+Newsgroups: de.alt.sysadmin.recovery
+
+Andreas Wiese wrote:
+
+[..]
+> Hier auf der B27 von Blankenburg nach Huettenrode steht ein lustiges
+> Schild mit Pfeil, dass in Richtung Ziegenkopf (Pension, Aussichtspunkt,
+> Gaststaette) zeigt mit der Aufschrift:Pension's-Zimmerfrei.
+
+Mein Liebling bisher: "Ob grosse oder kleine Feste, vom Fleischer $NAME
+steht's das Beste". Auf der Getraenkekarte eines Abi-Balls.
+
+Ich bin ja der Meinung, da fehlt ein Komma.
+
+
+Stefan
+
+-----------------------------------------------------------------------------
+
+
+
+Der ist flach... (Ronda, 21. Sep 2004, 20:34:45):
+... aber die Rubrik soll ja nicht ganz einschlafen...
+
+From: Nico Lubitz <use_replyto@nurfuerspam.de>
+Newsgroups: de.alt.fan.aldi
+Subject: Re: Aldi =?ISO-8859-1?Q?S=FCd?= Einschlafdragees nicht
+Date: Sat, 18 Sep 2004 20:43:36 +0200
+Message-ID: <cii6lp.3as.1@nil.my-fqdn.de>
+
+"J. Mender" <JMREMOVE2003@web.de>  wrote:
+
+> Hi ich hab mir vor 1-2 Monaten eine Packung St. Benedikt
+> Baldrian+Hopfen Dragees gekauft. Die haben super geholfen bei
+> Einschlafproblemen. Gestern war ich im Aldi und die sind nicht
+> mehr im Regal, weis jemand warum?
+
+Die Geschaeftsbeziehungen zwischen Aldi und dem Lieferanten sind
+eingeschlafen.
+
+-nil
+
+-----------------------------------------------------------------------------
+
+
+
+Passt grad so schoen... (Ronda, 23. Sep 2004, 23:31:09):
+... hab nur vergessen, warum es passt...
+
+Ronda
+
+From: Heiner Blett <Heiner.Blett@gmx.de>
+Subject: Re: Alzheimer-Preis
+Newsgroups: de.etc.sprache.deutsch
+Date: Wed, 22 Sep 2004 13:54:44 +0200
+Message-ID: <17c8gm9919i1m$.927dnouvghqj$.dlg@40tude.net>
+
+>>> Es mag ungerecht gegenueber Alzheimer und seiner Leistung sein.
+>>> Aber irgendwie kommt es mir unpassend vor, einen Preis nach
+>>> ihm zu benennen. Und Euch?
+
+>>Ich find ja umgekehrt immer schon auch die Benennung von Krankheiten nach 
+>>ihren Erfindern gewoehnungsbeduerftig. Ich habe nie ganz nachvollziehen 
+>>koennen, wie man es als eine grosse Ehre empfinden kann, den eigenen Namen 
+>>einem moeglichst scheusslichen Leiden anzuhaften. Aber ich habe mal Aerzte 
+>>gefragt, die empfinden das wirklich so. Eine eigene Krankheit nach einem 
+>>benannt zu bekommen, ist das Groesste, was so einem Mediziner passieren
+kann. 
+>>Merkwuerdig.
+ 
+> Du hast schon recht, in der Hinsicht sind Mediziner sehr
+> eigenartig.
+
+Wobei Alzheimer sich wohl die falsche Krankheit ausgesucht hat, um auf
+ewig im Gedaechtnis der Leute zu bleiben. Die Pharmaindustrie ist auch
+nicht untaetig und entwickelt entsprechende Medikamente. Jede Wette, in
+zehn Jahren ist Alzheimer vergessen.
+
+-----------------------------------------------------------------------------
+
+
+
+Re: No comment (c; (Daria, 25. Sep 2004, 18:06:56):
+~#! rn=Nonne rt=1095679500 rg=schmarrn.netdigest
+~#! tid=1095679500
+Meine Favoriten sind in diesem Zusammenhang
+An einer Imbissbude:
+Essen wie bei Mutter'n
+
+Und an einem Friseurfenster:
+Oefter mal was Neue's
+
+Daria
+
+-----------------------------------------------------------------------------
+
+
+
+Nicht aus netdigest... (Ronda, 26. Sep 2004, 16:42:33):
+... aber auch ganz nett:
+
+From: Lukas Barth <tinloaf_usenet@gmx.de>
+Newsgroups: de.alt.sysadmin.recovery
+Subject: Re: Katzenthread
+Rolf Eike Beer wrote:
+
+> [Lustige Lesefehler]
+
+Gibts hier zufaellig Funkamateure? Pruefungsfrage Fach "Vorschriften":
+
+Darf ein Funkamateur als Blitzschutzerder verwendet werden?
+...
+Bitte?
+...
+*Brilleputz*
+...
+Darf ein Fundamenterder als Blitzschutzerder verwendet werden?
+Ahso...
+
+Das war bei der Pruefung zur Klasse 3. Die gleiche Frage bekam ich zur 
+Klasse 2. Ratet mal, was ich gelesen habe. Irgendwie haben mich meine 
+Mitprueflinge seltsam angesehen als ich laut losgelacht habe...
+
+Lukas
+
+-- 
+Seriennummer des Datentraegers 0815-FADE
+Ein weiteres Internet formatieren (J/N)? J
+
+-----------------------------------------------------------------------------
+
+
+
+Irgendwie... (Ronda, 28. Sep 2004, 00:05:37):
+... gehts da um erotische Klingonencountdowns oder so...
+
+From: Herwig Huener & Josella Simone Playton 
+<webmaster@Josella-Simone-Playton.de>
+Newsgroups: ger.ct
+Subject: Re: Alter Code - von einem selbst.
+Date: Thu, 16 Sep 2004 21:26:25 +0200
+Message-ID: <cicpbl$1eo$04$1@news.t-online.com>
+
+2004-09-16 21:21:21 MESZ
+
+Olaf Klischat wrote:
+
+>...
+
+>Natuerliche Sprachen muessen alle i.W. denselben Anforderungen
+>genuegen. Programmiersprachen nicht.
+
+Eigentlich ist das nicht richtig.
+
+Wenn Du in franzoesisch PrimZahlen aufsagst, hoert es
+sich an wie ein erotisches Gedicht. Wenn Du im Deutschen
+ein Erotisches Gedicht erzaehlst, koenntest Du mit
+gleicher Wirkung PrimZahlen aufsagen. Wenn Du in
+Englisch PrimZahlen aufsagst, hoert es sich an wie
+ein CountDown. Wenn Du in COBOL PrimZahlen aufsagst,
+hoert es sich an wie - PrimZahlenAufsagen. Wenn jemand
+in Klingonisch PrimZahlen aufsagt, wuerdest Du das lieber
+in COBOL hoeren.
+
+Herwig
+
+-----------------------------------------------------------------------------
+
+
+
+Braucht wer... (Ronda, 28. Sep 2004, 22:19:07):
+... grad ne Bommelmaschine?!
+
+Subject: Bommelmaschine zu verkaufen
+Date: Mon, 27 Sep 2004 13:19:42 +0200
+From: hwicht <vergraben_sie_ihren_muell_hier@gmx.de>
+Newsgroups: de.rec.motorrad
+
+Wochendende, Regenwetter, nix' zu schrauben (die eine Guzzi steht in Bern
+und ist kaputt, die andere Guzzi steht auf der Hebebuehne ist fixfoxi
+fertig). Keine Lust zum Schraubensortieren. Der Ehefrau auf'n Wecker gehen
+und jammern, dass man nix' zu schrauben hat.
+
+Das ist, wie jeder Frauenkenner weiss, ein ganz gefaehrlicher Ansatz, denn
+sie hat subito ungefaehr 27 gute Ideen, mir den Sonntag zu versuessen. Die
+gehen von A wie "Abwasch" ueber B wie "Bommeln annaehen" bis Z wie
+"Zusammenraeumen", und auch die selteneren Buchstaben des Alphabets (Q wie
+"Quetschen entkernen", X wie "Xsellschaftspiele spielen", und Y wie
+"bYgeln" ) finden ihre Entsprechung in ihrem Ideenuniversum.
+
+Als ich mich grade hilflos, wie ein unschuldiges Insekt im klebrigen Gewebe
+der heimtueckischen Spinne, im Geflecht ihrer Vorschlaege zu verheddern
+beginne, und schon einem verbygelten, quetschenentkernten,
+verxellschaftsspielten Sonntag ins Auge zu sehen glaube, geht die
+Bommelmaschine kaputt.
+
+Nun muss man wissen, dass eine Bommelmaschine, wie der Name sagt, eine
+Maschine zur Herstellung von Bommeln ist. Bommeln, jede Menge Bommeln
+braucht man, wenn man fuer die Basler Fasnacht drei sogennante Bommelkostueme
+(fuer meine Holde selbst, die Schwaegerin und mich) bastelt. Und das macht sie
+grade, genauer gesagt: sie bindet Bommeln. Nur dass man in Basel und
+anderswo nicht Bommel, sondern PomPom zur Bommel sagt.
+
+Eine Bommelmaschine besteht aus zwei Tori, also aus gelochten Scheiben,
+einer Unterlegscheibe nicht unaehnlich, die jeweils halbiert sind, also aus
+vier Halb- oder Hemitori. Jeweils zwei dieser Hemitori werden deckungsgleich
+uebereinandergelegt, so dass sich ein Doppelhalbtorus ergibt, dessen beide
+Hemitori jedoch durch noppenfoermige Abstandshalter etwa 1 mm weit
+auseinanderhalten werden. Jenen Doppelhalbtorus umwickelt man dann mit
+Wolle. Den anderen auch. Dann bastelt man mit Hilfe einer trickreichen
+Schiebeklemm-Ineinanderfrickelvorrichtung, die sich an den Enden der
+Hemitori befindet, die beiden wollumwickelten Doppelhalbtori zu einem
+Vierfachhalbtorus, also zwei vollstaendigen wollumwickelten
+ubereinanderliegenden Tori zusammen. Die ergeben eine Bommel, wenn man nun
+zwischen den auf Abstand gehaltenen Tori hindurch das Wollgewickel
+aufschneidet und mit einem Faden verschnuert.
+
+Kapiert? Ich auch nicht.
+
+Meine Frau aber, denn sie macht mit dieser Maschien Bommeln en gros, bis
+eben das Ding zerbricht, denn der ganze Apparat ist aus schnoedestem Plastik,
+und die Schiebeklemm-Ineinanderfrickelvorrichtung bricht irgendwann fast
+zwangslaeufig ab.
+
+"Das", sag ich, "bau' ich Dir aus Metall nach, das geht NIE mehr kaputt!"
+Zack und MIT ihrem Segen ab in die Garage, dem Abwasch entronnen.
+
+In der Garage. Vier Hemitori, auf  Abstand zueinander ... gruebel ... zwei
+grosse Unterlegscheiben, aber noble Scheiben aus Federstahl, nicht die
+billigen, gespaltenen, sondern gewoelbte (auf der letzten Veterama aus
+irgendeiner Grabbelkiste gefischt) ergeben, uebereinandergelegt, den
+Doppeltorus mit dem gewuenschten Spalt am Aussenrand, den's braucht, um den
+Schnitt und den Schnuerfaden durch Wollgewickel zu fuehren. Perfekt. Bischen
+groesser als das Original, aber kleinere Scheiben hab' ich nicht. Nur
+halbieren muss man die Dinger. Dauert nur etwa eine Stunde und kostet 4
+Saegeblaetter, jede Menge Verschnaufpausen und schmerzende Handgelenke, denn
+die Dinger sind fast durchgaengig hart. Guter Stahl, das. Auch der Anbau
+(Hartloeten) der Schiebeklemm-Ineinanderfrickelvorrichtung nimmt Zeit in
+Anspruch. Sehr viel Zeit. Bis zum Abendessen. Haeha, Tag gerettet.
+
+Dann, perfektes Timimng, d.h. kurz _vor_ dem Abendessen, aber _nach_ dessen
+Zubereitung, rette ich mich mit einer perfekt verloeteten, verschliffenen und
+funktionserprobten (habe noch in der Garage aus alter Paketkordel eine
+wunderschoene Schnuerkordelbommel gemacht) Schwermetallbommelmaschine zurueck
+an den heimischen Herd.
+
+"Die Bommelmaschine", sagt sie, "macht zu grosse Bommeln. Ich brauch'
+kleinere."
+
+Bommelmaschine zu verkaufen. Federstahl, unzerstoerbar. Perfekt fuer die
+Herstellung von Bommeln von etwa 7 cm Duchmesser.
+Suche Bommelmaschine fuer 5 cm-Bommeln.
+
+-- 
+Submissionen fuer de.alt.netdigest bitte an
+<de-alt-netdigest@moderators.dana.de> schicken.
+Der Submitter ist fuer den Inhalt der Einreichung verantwortlich, 
+nicht der Moderator der Newsgruppe.
+
+-----------------------------------------------------------------------------
+
+
+
+Trocken. (Ronda, 29. Sep 2004, 21:58:32):
+Und Geschmacksache. Mein Geschmack, ok.
+
+Ronda
+
+Subject: Re: Megaknall im All
+From: runforcover@menthe.info Ren Fuchs)
+Date: Sat, 25 Sep 2004 22:49:26 +0200
+Message-ID: <1gkoxuv.jlssep1na5cwaN%runforcover@menthe.info>
+Newsgroups: arcor.misc
+
+Arcor Newsticker <dpa@arcor-online.net> wrote:
+
+> 24.09.2004, 15:12 Uhr
+> 
+>     Washington (dpa) - Ein europaeischer Satellit hat eine der
+>   groessten Kollisionen von Galaxien im All aufgezeichnet. Der
+>   Zusammenprall von tausenden Galaxien und mehreren Billionen
+>   Sternen sei im Massstab des Universums gesehen relativ nahe an
+>   der Erde geschehen. Das berichtet die US-amerikanische
+>   Raumfahrtbehoerde NASA. Eine solche Massenkarambolage im All
+>   konnten die Forscher erstmals im Detail beobachten. Derartige
+>   Kollisionen setzen eine Energiemenge frei, die ansonsten nur
+>   von der des Urknalls uebertroffen wird.
+
+Als Grund fuer die Karambolage nannte die Polizei zu geringen
+Sicherheitsabstand und ueberhoehte Geschwindigkeit.
+
+Ren
+
+-----------------------------------------------------------------------------
+
+
+
+Fahrsturhl (Foobar,  5. Okt 2004, 19:27:02):
+From: Hendrik Straeter <news.hendrik@adlerstein.de>
+Subject: Re: Verhalten im Aufzug
+Newsgroups: de.alt.soc.knigge
+Date: 02.Oktober 2004, 16:48
+Message-ID: <news:cjmf0j$pht$05$2@news.t-online.com>
+
+Uli Stiehl schrieb:
+
+> Hallo zusammen!
+> 
+> Mich wuerde einmal interessieren, ob es verbindliche Regeln gibt, wie
+> man sich im Aufzug Eurer Meinung nach verhaelt.
+
+1.    Wenn ausser Dir nur noch eine andere Person im Aufzug ist, tippe
+       ihm/ihr auf die Schulter und tu dann so, als waerst du es nicht
+       gewesen.
+
+2.    Drueck auf einen Knopf und lasse es aussehen, als ob er dir einen
+       elektrischen Schlag verpasst. Dann laechle und mach es noch ein
+       paar mal.
+
+3.    Biete anderen Leuten an, fuer sie die Knoepfe zu druecken aber
+       druecke die falschen.
+
+4.    Ruf mit deinem Handy eine Wahrsagerhotline an und frag sie, ob
+       sie wissen, in welchem Stockwerk du dich gerade befindest.
+
+5.    Halte die Tueren offen und erklaere, dass du auf einen Freund
+       wartest.
+       Nach einer Weile laesst du die Tueren sich schliessen und sagst:
+       "Hallo Joerg, wie war dein Tag?"
+
+6.    Lass einen Stift fallen und warte, bis ihn jemand fuer dich
+       aufheben will, dann bruell ihn an: "Das ist meiner!"
+
+7.    Nimm eine Kamera mit und mach Fotos von allen Leuten im Aufzug.
+
+8.    Stell deinen Schreibtisch in den Aufzug und frage alle Leute die
+       hereinkommen, ob sie einen Termin haben.
+
+9.    Lege einen Twister-Spielplan auf den Boden und frage die
+       anderen, ob sie mitspielen wollen.
+
+10.    Lege eine Schachtel in eine Ecke und wenn jemand den Aufzug
+        betritt, frag ihn, ob er auch so ein seltsames Ticken hoert.
+
+11.    Tu so, als waerst du eine Stewardess und uebe das Verhalten im
+        Notfall und den sicheren Ausstieg mit den Fahrgaesten.
+
+12.    Frage die Leute: "Haben sie das gerade gespuert"
+
+13.    Stelle dich ganz nah an jemandem heran und schnueffle
+        gelegentlich an ihm herum.
+
+14.    Wenn die Tueren schliessen, erklaere den anderen: "Es ist alles OK.
+        Keine Panik, die Tueren werden sich wieder oeffnen."
+
+15.    Schlage nach nicht-existenten Fliegen.
+
+16.    Erklaere den Leuten, dass du ihre Aura sehen kannst.
+
+17.    Rufe: "Gruppenumarmung!" Und fang damit an.
+
+18.    Mach ein schmerzverzerrtes Gesicht waehrend du auf deine Stirn
+        schlaegst und murmelst "Seid doch still, seid doch endlich alle
+        still!"
+
+19.    oeffne deinen Geldbeutel, schau hinein und frage: "Kriegt ihr
+        auch genug Luft da drin?"
+
+20.    Starre einen anderen Fahrgast eine Weile an, dann schrei auf:
+        "Du bist einer von IHNEN!" Weiche langsam zurueck, ohne ihn aus
+        den Augen zu lassen.
+
+21.    Trage eine Handpuppe bei dir und benutze sie, um mit den andern
+        zu reden.
+
+22.    Hoere die Waende des Aufzuges mit einem Stethoskop ab.
+
+23.    Ahme Explosionsgeraeusche nach, wenn irgendjemand auf einen Knopf
+        drueckt.
+
+24.    Starre eine Weile lang einen anderen Passagier an, grinse und
+        erklaere nach einer Weile: "Also ICH trage frische Socken".
+
+25.    Male mit Kreide ein kleines Quadrat auf den Boden und erklaere
+        den anderen Fahrgaesten, dass dies deine Zone ist.
+
+
+SCNR,
+
+
+        Hendrik ;-)
+
+-- 
+Submissionen fuer de.alt.netdigest bitte an
+<de-alt-netdigest@moderators.dana.de> schicken.
+Der Submitter ist fuer den Inhalt der Einreichung verantwortlich, 
+nicht der Moderator der Newsgruppe.
+
+
+-----------------------------------------------------------------------------
+
+
+
+Internetfuehrerschein und Co...? (Ronda, 16. Nov 2004, 23:35:50):
+From: Christoph von Nathusius <usenet-abuse@despammed.com>
+Newsgroups: de.comp.security.misc,de.alt.rec.ascii-art
+Subject: Re: Bagle-Wuermer deaktivieren Windows Firewall
+
+[X'Post & F'up2]
+
+Andreas Kohlbach <ankman@email.com> wrote:
+> Ansgar -59cobalt- Wiechers wrote on 14. November 2004:
+>
+> Auch http://www.internetfuehrerschein.de/ ist schon vergeben. Was mich
+> etwas wundert, ist der whois:
+>
+> ,----
+> | [admin-c]
+> | Type:         PERSON
+> | Name:         Bernhard Syndikus
+> | Address:      Rechtsanwaelte Frhr. v. Gravenreuth & Syndikus
+> | Address:      Schwanthalerstrasse 3
+> | City:         Muenchen
+> | Pcode:        80336
+> | Country:      DE
+> `----
+>
+> Was der wohl vor hat?
+
+     .---------.---------------------------------------------.
+     |   ...   |                                             |
+     |  : D :  |  Fuehrerschein   --    INTERNET              |
+     |  '...'  | ------------------------------------------  |
+     |---------'  1.  Das Brot                               |
+     |    ____                            IN/103264/K546     |
+     |   | o|o|   2.  Bernd                                  |
+     |  X|__|_|X  3.  32.03.2000 Kikanien                    |
+     |   |__|_|   4a. 15.11.2004      4c. Chili-TV           |
+     |    O  O                            Redaktion          |
+     |            4b. -                                      |
+     |            5.  B0331XEF2I54                           |
+     |                 _                                     |
+     |            7.  /_) o , __  __|                        |
+     |               |(_/|_/ || |/\/|                        |
+     '-------------------------------------------------------'
+
+
+.. ausserdem:
+
+- Bundesinternetfuehrerscheindruckerei
+- Kostenpflichtige Internet-Sehtests
+
+
+     ,-------------------------------------.
+     |   _    ___    _     __    __    _   |
+     |  |_|    |    |_)   (_    |_    / \  |
+     |  | |    |    | \   __)   |     \_/  |
+     |                                     |
+     |   _     _     __    _    ___    _   |
+     |  [_]   |=]   |-<   [_]    |    |-'  |
+     |                                     |
+     |                                     |
+     |   |   |--|   |\/|   |_   |__|  |\|  |
+     |                                     |
+     |                                     |
+     |   X     F      S     J     L    P   |
+     |                                     |
+     |                                     |
+     |   .     ,      ;     '     .    ,   |
+     |                                     |
+     '-------------------------------------'
+
+
+- Internetalkoholkontrollen
+- Internetradarfallen
+                          +---------------+
+                          |        ,--.   |
+                          |       (    )  |
+                          |        `--'   |
+                          |               |
+                          |         (@)   |
+                          |               |
+                          +----.-----.----+
+                                |   |
+                                |   |
+                                |   |
+                                |   |
+- Internetparkverbotszonen      |   |
+- Internetkoellchen              |   |
+- ...                           |   |
+                                |   |
+CvN                             |   |
+
+
+-----------------------------------------------------------------------------
+
+
+
+Sechs Zeilen... (Ronda, 16. Nov 2004, 23:51:44):
+... besonders das mit den Enkelkindern find ich praktisch, da erspart man sich
+viel Aerger mit vollen Windeln, Pubertaet und so...
+
+Ronda *de.alt.netdigest abarbeitend*
+
+From: Sybille Kahl <Sybille.Kahl@gmx.ch>
+Subject: Re: Bin ich doof?
+Newsgroups: de.talk.romance
+Message-ID: <hji2p0harkd4bn0k0074c7cm3b9t8t79tf@news.individual.de>
+
+Hallo,
+
+Respect Privacy schrieb:
+
+[Will sie mehr? oder: wie flirte ich konkret]
+>Gibts Wege, dass genauer herauszufinden? Drueber sprechen funzt ja
+>nicht und irgendwelche Handlungen oder Gesten interpretieren und
+>Schluesse daraus ziehen moechte ich nicht.
+
+Hol Dir eine lila Schokokuh, kleb ein Post-it "Geh mit mir Kuehe
+umschubsen" drauf, pack den Picknickkorb, dazu heisser Kakao, Kerzen
+und eine warme Decke, ausfluegel mit ihr zum Kuehe gucken und
+anschliessendem Mitternachtspicknick am leise schwappenden See, waerm
+ihr die Haende, zeig ihr die fliegende Kuh am Sternenhimmel, waerm ihr
+die Nase, Kuss, Heirat, Enkelkinder, Friedefreudeschokokuchen.
+
+Vergiss die wirklich warme Decke nicht.
+
+Viele "ein Leben in sechs Zeilen" Gruesse,
+Sybille
+
+
+-----------------------------------------------------------------------------
+
+
+
+Fahren die Strassenbahnen... (Ronda, 18. Nov 2004, 00:00:05):
+... in Koeln mit Windows-Steuerung?!
+
+Ronda
+
+From: Hans Bonfigt <bonfigt.ses-koeln@t-online.de>
+Newsgroups: de.alt.sysadmin.recovery
+Subject: Re: Es ist bewiesen: Apple-User sind daemlich!
+Date: Thu, 04 Nov 2004 09:49:10 +0100
+
+[SN:  Gekuerzt.]
+
+Andreas Krey:
+
+> Die Strassenbahn, die in Koeln nicht anhalten wollte, war laut
+> Hersteller auch vollkommen in Ordnung.
+
+Neulich, in der Koelner Linie 1:
+
+"Liebe Fahrgaeste, irgendwas ist mir diesem Fahrzeug nicht in Ordnung.
+Bitte bleiben Sie auf Ihren Plaetzen, ich schalte die ganze Bahn jetzt
+einmal ab und wieder an.  Das dauert drei Minuten.  Lachen Sie nicht,
+aber das hilft meistens".
+
+Gruss Hans
+
+-----------------------------------------------------------------------------
+
+
+
+Brot ist gefaehrlich! (Ronda, 18. Nov 2004, 00:10:28):
+Ok, ok, das ist der letzte Artikel fuer heute nacht ;-)
+
+Ronda *nacharbeitend*
+
+ Betreff: Re: Wir wussten es ja schon immer...
+ Absender: Arno Nuehm <psych0@wtnet.de>
+ Datum: Sat, 30 Oct 2004 13:28:36 +0200
+ Newsgruppe: de.rec.bodyart
+ Message-ID: <1gje3migzp4fw.1udrs8rsgfo78$.dlg@40tude.net>
+
+ Am Wed, 14 Jul 2004 12:54:19 +0200 schrieb Tom Engelhardt:
+ 
+ > bei solchen Artikeln nehme ich mir immer ein schoenes Buch zur: "Der Hund,
+ > der Eier legt - Luegen mit Statistik" von Hans-Peter Beck-Bornholt und
+ > Hans-Hermann Dubben. Kostet 10 Euronen bei Amazon.
+ 
+ Danke fuer den Tip!
+ 
+ > 'Ne schoene Aussage ist auch "60% aller bayrischen Kinderschaender sind
+ > katholisch und essen Nutella". Mag ja sein, aber die Aussage, die man
+ > daraus ziehen kann, ist Mumpitz (oder aber ich muss meinen Nutellakonsum
+ > einschraenken).
+ 
+ Man kann das ganze auch wunderbar auf die Spitze treiben, ich hoffe das
+ noch nicht allzu viele Leute den Text kennen:
+ 
+ Keine Werbung fuer Brot!
+ 
+ Brot ist eine Einstiegsdroge. Meistens fuehrt sie zum Konsum haerterer
+ Mittel wie Butter, Marmelade, Erdnussbutter und sogar Wurst.
+ 
+ Mehr als 98% aller Inhaftierten sind BrotkonsumentInnen.
+ 
+ Die Haelfte aller Kinder, die in Haushalten aufwachsen, in denen
+ Brotkonsum stattfindet, liegen bei standardisierten Tests unter dem
+ Durchschnitt.
+ 
+ Im 18. Jahrhundert, als Brot noch in den Haushalten gebacken wurde,
+ war die durchschnittliche Lebenserwartung geringer als 50 Jahre; die
+ Sterblichkeitsrate bei Kindern war inakzeptabel hoch; viele Frauen
+ starben im Kindbett; Seuchen wie TBC, Grippe und Cholera
+ terrorisierten ganze Nationen.
+ 
+ Mehr als 90% aller gewalttaetigen Verbrechen geschehen innerhalb von 24
+ Stunden nach dem Konsum von Brot.
+ 
+ Brot wird aus einer Substanz hergestellt, die "Teig" genannt wird. Es
+ ist bewiesen, dass eine Maus schon an einem Pfund Teig ersticken kann.
+ Die/der durchschnittliche Deutsche isst jeden Monat mehr Brot als
+ diese Menge.
+ 
+ Primitive Naturvoelker, die kein Brot kennen, weisen wesentlich weniger
+ Krebs-, Alzheimer- und Parkinsonfaelle auf.
+ 
+ Brot macht nachweislich abhaengig. Menschen, denen Brot entzogen wird
+ und die nur noch Wasser bekommen, betteln spaetestens schon nach zwei
+ Tagen um Brot.
+ 
+ Brot absorbiert Wasser. Da der menschliche Koerper zu 90% aus Wasser
+ besteht, kann Brot den Koerper in eine dicke wabbelige Masse
+ verwandeln.
+ 
+ Neugeborene Babies koennen einen Schock von Brot bekommen.
+ 
+ Brot wird bei einer Temperatur von ueber 200 Grad Celsius gebacken.
+ Diese Temperatur toetet einen erwachsenen Menschen innerhalb von einer
+ Minute.
+ 
+ Die meisten BrotkonsumentInnen sind nicht in der Lage, zwischen
+ wissenschaftlichen Fakten und statistischen Manipulationen
+ unterscheiden zu koennen.
+ 
+ SCNR
+
+-----------------------------------------------------------------------------
+
+
+
+Katzen in den Schredder! (Amaryllis, 29. Nov 2004, 18:03:20):
+Message-ID: <30eqmaF2vhcpsU1@uni-berlin.de>
+From: Andreas Mauerer <a.mauerer@expires-2004-11-30.arcornews.de>
+Newsgroups: de.rec.tv.misc
+Subject: Re: Stern TV - Katze
+Date: Mon, 22 Nov 2004 19:49:44 +0100
+
+"Jens Mander" <haraldkauspins@web.de> meinte:
+
+
+>
+>'90a BGB "Tiere. Tiere sind keine Sachen. Sie werden durch besondere 
+>Gesetzte gesch|tzt. Auf sie sind die f|r Sachen geltenden Vorschriften 
+>entsprechend anzuwenden, soweit nicht etwas anderes bestimmt ist."
+>
+>Das hei>t. Eine Katze zu |berfahren ist genau so schlimm wie eine Kiste Bier 
+>zu |berfahren. Naja, vielleicht etwas komplizierter. 
+
+N, nach der Kiste Bier ist das Auto ziemlich sicher kaputt, nach der
+Katze tut es meist eine Autowsche. ;-)
+
+Gru;-)
+
+Andreas
+
+-----------------------------------------------------------------------------
+
+
+
+PIN... (Ronda,  3. Dez 2004, 01:29:43):
+... und wuerde bei Uralt-Muddern die 4711 zurueckgewiesen?
+
+Ronda *home again...*
+
+From: "Stefan Krieg" <Stefan.Krieg@GMX.de>
+Subject: Re: variable PIN
+Newsgroups: de.etc.finanz.banken+broker
+Date:Sat, 27 Nov 2004 23:32:38 +0100
+Message-ID: <30se2qF34qj4nU1@uni-berlin.de>
+
+[...PIN selbst waehlen...]
+
+> Es waere mal interessant, eine Liste von "zu simplen" oder "unsicheren"
+> PIN aufzustellen.
+> Ich glaub da bleibt dann gar nicht mehr so viel uebrig.
+[...]
+
+> (1367? ist doch klar: Papst Urban V geht von Avignon nach Rom zurueck
+> 1368? Karl der VI geboren 1366? der mittelalterliche Mystiker Heinrich
+> Seuse stirbt.
+
+Fehlermeldung des Geldautomaten: "Ihre selbstgewaehlte PIN wurde nicht
+akzeptiert. Laut unseren Unterlagen sind Sie Historiker. Bitte waehlen
+Sie eine PIN groesser 2004." (doof waere natuerlich, wenn sein Hobby
+Science Fiction- Literatur auch gespeichert ist)
+
+-----------------------------------------------------------------------------
+
+
+
+Kutteln und Trollinger... (Ronda,  3. Dez 2004, 01:37:11):
+... oder: Kulinarisches fuer Nicht-Schwaben...
+
+From: frank paulsen <frank.paulsen@gmx.net>
+Newsgroups: de.alt.talk.unmut
+Subject: Re: Lasst euch nicht verarschen.....
+Date: Thu, 25 Nov 2004 09:32:34 +0100
+
+Boris Gerlach <drstrange2004@doctor-strange.de> writes:
+
+> Wenn die Kutteln weich sind (Konsistenz von nassen
+> Frotthandtuchstreifen)
+> Gewuerze rausfischen.
+
+Kutteln auch rausfischen und wegwerfen, eingeweichtes Frotthandtuch
+in streifen schneiden und als Sushi mit etwas Sojasauce anrichten.
+
+> Bratkartoffeln gruener Salat und die 3. Fl. Trollinger dazu
+servieren.
+
+den Trollinger kann man sich mit viel gewinn direkt direkt auf den
+kopf schlagen, man erspart sich den schlechten geschmack bei
+vergleichbaren kopfschmerzen.
+
+-----------------------------------------------------------------------------
+
+
+
+Alles anderes als Schmarrn! (Ronda,  3. Dez 2004, 01:41:17):
+Nichts als die Wahrheit! Die BITTERE Wahrheit!
+
+Ronda *betroffen! Zu tiefst!*
+
+From: Christian Koehn <christiankoehn@gmx.de>
+Newsgroups: de.rec.musik.klassik
+Subject: Re: In der Oper kann man nicht zappen
+Date: Sun, 21 Nov 2004 19:19:24 +0100
+
+Am 21.November schrieb Peter Brixius:
+
+> (BTW unterscheide ich zwischen Folk und Volksmusik. Dem letzteren gehe
+> ich gern aus dem Weg, dem ersteren begegne ich gerne. Wobei der
+> Begriff "Volksmusik" so pejorativ auch erst seit ca. 40 Jahren ist, im
+> Sinne etwa Bartoks oder Kodalys kann man wohl wenig dagegen haben (und
+> das ist auch kein Folk ...)
+
+Deshalb wuerde ich fuer die "Volksmusik" nach Carolin-Reiber-Art den Begriff
+"volkstuemlicher Schlager" vorschlagen, wenigstens ist das der einzige
+nicht-vulgaere Begriff, der mir zu solchem Dreck einfaellt. Es gehoert zu den
+unverzeihlichen Luegen der zugehoerigen Industrie, dass sie ihre
+duemmlich-volkstuemelnden Produkte mit dem Etikett "Volksmusik" verkauft. Wer
+je die von Johannes Brahms wundervoll gesetzten Volkslieder gehoert hat,
+kann angesichts eines solch unverschaemten Wortmissbrauchs die Wut kriegen. 
+
+Viele Gruesse,
+
+Christian
+
+-----------------------------------------------------------------------------
+
+
+
+Datenverlust? (Ronda,  3. Dez 2004, 01:53:45):
+Naja. Also nach dem Genuss von etwas zu viel Grey Goose ists - finde ich -
+echt witzig. Ausserdem arbeite ich grad die Newsgroup ab. Also schiebts bitte
+auf die Ueberarbeitung. Aber: http://tinyurl.com/5rp7e ist vielleicht doch
+einen Besuch wert...
+
+Ronda
+
+Date: 24 Nov 2004 21:48:00 +0200
+From: all2001@gmx.de (Wolfgang Allinger)
+Newsgroups: de.etc.beruf.selbstaendig
+Message-ID: <9LVHfHW67QB.all2001@gmx.de>
+Subject: Re: [Presse] Leute seid vorsichtig!
+
+ On 24 Nov 04 at group /de/etc/beruf/selbstaendig in article
+ <vwh1l5cine0k$.1cpe6mcqxfk6$.dlg@40tude.net>
+ <ewarnecke@gmx.net>  (Edgar Warnecke)  wrote:
+
+>Moin,
+>
+>Ihr haengt ja alle irgendwie an den Rechenknechten.
+>
+>Verrueckte Datenpannen: Vom Himalaya bis zum WC
+>veroeffentlicht: 23.11.04 - 09:33
+>
+>Frankfurt/Main (rpo). Die zehn ausgefallensten Datenpannen hat
+>das Boeblinger Unternehmen Kroll Ontrack aus 30.000
+>eingegangenen Auftraegen zur Datenrettung zusammengestellt.
+>http://www.rp-online.de/public/article/nachrichten/medien/computer/697
+>18
+>
+>V o r s i c h t!
+>Vorher aufkauen und Kaffeetasse an die Seite stellen, nicht
+>dass bei Euch auch noch...  ;->
+
+So wild ist das eigentlich nicht.
+Fehlt: Katze benutze PC als Urinal :-)
+Beim morgentlichen booten stanks zum Himmel und die Sicherung
+fetzte raus.
+
+Nein ich hab die Platte vom Kunden nicht neu gereinigt etc. War
+seiner Meinung eh nix wichtiges drauf.
+
+Tschuess Wolfgang
+
+PS meine Katze hat mal auf/in einen Ordner mit Belegen fuers FA
+gekotzt. Ich hab das FA von der Sache unterrichtet und
+angeboten, ihnen den Ordner zu schicken. Wollten sie nicht haben
+und das betreffende Jahr auch nicht mehr pruefen. Durfte den
+Ordner dann entsorgen.
+
+Vermute aber, wenn jedes Jahr die Katze den Ordner entsorgt,
+werden die irgendwann mal stinkig :-)
+
+
+-----------------------------------------------------------------------------
+
+
+
+Erstsemester sind in jedem Fach gleich... (Ronda,  3. Dez 2004, 02:05:47):
+... und sorry: ich arbeite echt grad x Wochen de.alt.netdigest nach,
+urlaubsbedingt. Und ja: ich geniesse es! Den Urlaub UND d.a.n ;-)
+
+Ronda *suechtig*
+
+From: mails.an.diese.adresse.werden.nicht.gelesen@krazykat.de (Claudia
+Voelker)
+Newsgroups: de.alt.recovery.scientist
+Subject: Re: Kenntnisse von Erstsemestern
+Date: Fri, 22 Oct 2004 16:19:31 +0200
+Message-ID:
+<1gm2a35.1udwben1irc5cuN%mails.an.diese.adresse.werden.nicht.gelesen@krazykat.
+de>
+
+Mathias Boewe <Mathias.Boewe@t-online.de> wrote:
+
+> Man sollte Rechenschieber wieder verbindlich einfuehren!
+
+Hilft nicht:
+
+Montag Morgen, Programmierpraktikum im ersten Semester. Manchmal
+verstehe ich Fragen ja nicht. Manchmal verstehe ich ein Problem nicht,
+weil ich nicht erkenne, dass es sich um ein Problem handelt. Folgende
+Aufgabe war zu loesen: Eine Zeit ist in Minuten vorgegeben. Aus dieser
+Zahl soll ein Text aufbereitet werden. Beispiel: Vorgabe sind 90
+Minuten, der Text soll dann lauten: "1 Stunde, 30 Minuten". Jetzt sass
+ein Student ratlos mit seinem Taschenrechner da, und auch der
+Windows-Rechner konnte ihm offensichtlich nicht helfen. Schliesslich hat
+er mich gefragt:
+
+Student: "Wenn ich 59 durch 60 rechne, kommt da 0,98 raus."
+ Ich: (Soll ich das jetzt nachrechnen? Wird wohl stimmen.) "Ja. Und?"
+ S: "Ja, und dann hab ich die Stunden, das sind null."
+ I: (Was soll da sonst rauskommen?) "Ja. Und?"
+ S: "Ja, und wie krieg ich jetzt raus, wieviele Minuten das sind?"
+ I: (Fuer einen von uns beiden ist es wohl noch zu frueh.) "59?"
+ S: "Ja, aber wie rechne ich das aus?"
+ I: "?????"
+ S: Erklaert mir alles nochmal.
+ I: "Na, das sind 59 Minuten!"
+ S: "Ja, aber das muss ich doch irgendwie ausrechen!"
+ Groschen: *klapper*
+ I: "Ach soooo! Wie kommt man denn auf die 0,98?"
+ S: "Ich rechne 59 durch 60."
+ I: "Gut. Und wie kommt man jetzt wieder auf 59?"
+ S: *gruebel* "Indem ich mit 60 multipliziere?"
+ I: "Herzlichen Glueckwunsch. Und viel Spass in Mathe."
+
+Es tut mir leid, aber mein Geduldsmodul startet morgens so furchtbar
+langsam ...
+
+
+Und nachdem ich eben an einer Informatik-Studentin verzweifelt bin, die
+nicht wusste, wie sie mir eine Datei per Mail-Attachment schicken sollte
+("Was ist ein Attachment?"), die enttaeuscht war, dass wir nicht "ihre"
+AOL-Software auf den Pool-Rechnern installiert haben, die nicht wusste
+wie sie die erwaehnte Datei auf eine Diskette kopiert und die auf meinen
+Einwand "Mach das doch mit dem Explorer" den Internet Explorer gestartet
+hat, habe ich mir das Wochenende echt verdient.  :o(
+
+Claudia
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Erstsemester sind in jedem Fach gleich... (Bambi,  3. Dez 2004, 16:02:49):
+~#! rn=Ronda rt=1102035947 rg=schmarrn.netdigest
+~#! tid=1102035947
+Vielleicht habe ich die Geschichte ja schon einmal gepostet, aber weil sie so
+gut passt...
+
+Ich habe einige Zeit lang ein Labor fuer das erste Semester (Informatik)
+geleitet. Unter anderem stand da das Thema "Sicherheit" auf dem Plan, zu dem
+auch gehoerte, dass man seinen Account vor dem Zugriff durch Dritte schuetzen
+soll.
+
+Die Kernaussage, die mindestens in drei aufeinander folgende
+Unterrichtseinheiten wiederholt wurde, war:
+  Wenn man seinen Rechner nicht sperrt und ihn verlaesst, kann ein Dritter
+  mit dem Account Dinge anstellen, die man selbst nicht tun wuerde. Der
+  Dritte kann zum Beispiel Dateien loeschen. Wichtige Dateien.
+  Diplomarbeiten, Facharbeiten, Kochrezepte...
+
+Damit der Dritte nicht allzuviel Schaden anrichten kann, muss man sich fuer
+verschiedene Dienste separat einloggen. Proxy, wenn man ins Internet will,
+Telnet/SSH, wenn man auf dem Gateway/Unixrechner arbeiten will, Mailaccount,
+wenn man elektronische Briefe versenden will usw.
+
+Ich habe es ihnen hundert mal gesagt, ich habe es ihnen regelrecht
+eingeblaeut. Dass ich dafuer nicht mit Tomaten beworfen wurde, war alles. Und
+dennoch, einer hats geschafft:
+
+- Rechner nicht gesperrt:
+  Windows ist ungeschuetzt
+- einen Browser fuer das Internet offen lassen:
+  man kann mit seinem Account Sachen aus dem Internet ziehen, die garantiert
+  nicht unter "wissenschaftliches arbeiten" fallen.
+- Mail-Programm offen:
+  Man kann alle Mails lesen und Mails in seinem Namen verschicken.
+- Telnet-Session auf den Gateway offen:
+  Mails lesen und schreiben, Account manipulieren, die eigene (sehr
+  begrenzte Quota) auf das Doppelte erhoehen, alle Dateien in seinem Home
+  loeschen und so weiter.
+
+Ich habe mir lange ueberlegt, wie ich eine erzieherische Massnahme
+durchfuehren koennte.
+Mails lesen? Nein. Das Fernmeldegeheimnis hat durchaus seine Berechtigung.
+Dateien loeschen? Nein. Die eine Datei haette es auch nicht gebracht.
+Dem RZ-Leiter eine boese Mail schreiben? Nein, so unsympatisch war mir bisher
+keiner aus dem ersten Semester, dass er das verdient haette.
+
+
+Und dann kam mir folgende Idee.
+Ich wechselte ins Homeverzeichnis seines Accounts und fuehrte die folgenden
+zwei Befehle aus:
+   chmod 000 *
+   chmod 000 .
+Damit wurde folgender Effekt bewirkt: Kein Zugriff mehr auf sichtbare
+Dateien und kein Zugriff mehr auf das Verzeichnis selbst. Loggt er sich ein,
+dann kann er weder ls machen noch die Dateien bearbeiten, ehe er sich mit
+dem Rechtesystem von Unix auseinandergesetzt hat.
+Ausserdem schrieb ich der Frau von der Benutzerverwaltung eine nette e-mail
+(mit seinem Account), was genau ich manipuliert hatte.
+
+Um dem armen Tropf zu helfen, habe ich in den darauf folgenden 3
+Laboruebungen gefragt, ob irgendwer Probleme mit seinem Account haette. Ich
+habe auch "Uebungen" durchgefuehrt, die zwingend dazu haetten fuehren
+muessen, dass der betreffende Student auch bemerkt, dass etwas nicht so
+funktioniert, wie es soll. Aber niemand meldete sich. Als ich in der Woche
+nach der dritten Uebung die freundliche Dame der Benutzerverwaltung fragte,
+was aus "unserem speziellen Account" wurde, betraten gerade zwei Mitarbeiter
+des Rechenzentrums den Raum. (Mindestens einer der beiden sieht aus, wie man
+sich einen BOFH vorstellt.) Und sie fluchten. Der manipulierte Account loeste
+seit Wochen Probleme im Mailer aus, weil dieser es nicht schaffte, E-Mails an
+den manipulierten Account zu schicken: die Zustellung der Mails erforderte,
+dass besagter Account Schreibrechte in seinem Homeverzeichnis hat und die
+hatte ich ja entzogen.
+
+Ich wies die beiden freundlichen Herren darauf hin, wie der Account
+manipuliert worden war, worauf sie mir androhten, auch meinen Account wegen
+Sabotage des FH-Netzwerks zu sperren. Gluecklicherweise taten sie das aber
+nicht, sei es aus Gnade vor Recht oder weil sie meinen Nutzernamen haetten
+kennen muessen. Stattdessen vereinbarten wir, das Passwort des betroffenen
+Accounts zu sperren.
+
+Und in der darauffolgenden Laboruebung bekam ich dann mein Opfer. Ich setzte
+wieder einmal eine "Uebung" an und meinte, wer ein Problem habe, solle sich
+bitte bei mir melden. Der betroffene Student kam dann auch und meinte, er
+koenne sich nicht einloggen. Ich fragte ihn nach seinem Usernamen, den er mir
+auch nannte. Da er mit dem Namen des modifizierten Accounts uebereinstimmte,
+meinte ich nur: "Ach sie sind das. Gehen sie doch bitte zu Frau ****** vorne
+in der Benutzerverwaltung. Sie wartet schon seit drei Wochen darauf, dass Sie
+sich bei ihr melden."
+
+Und dann erklaerte ich noch einmal alle, dass es sehr wichtig sei, den
+Rechner nicht ungesperrt zurueckzulassen.
+
+MfG, Bambi.
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Suche: Alles lter 1945 (Amaryllis,  4. Dez 2004, 21:41:00):
+"Ralf" <sarakreutzmann@foni.net> writes:
+
+>Hallo,
+
+>ich bin ein rein privater Hobbysammler und suche zum Aufbau meiner
+>historischen Sammlung alles Mgliche, Hauptsache lter 1945. Mein besonderes
+>Interesse gilt alten Waffen wie z.B. alte Dolche (Heer, Luftwaffe, Marine u.
+
+Ich koennte meine Schwiegermutter anbieten. Aelter als 1945,
+Schmuck einer jeden historischen Sammlung, und geht problemlos
+als alte Waffe durch...
+
+SCNR.
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Erstsemester sind in jedem Fach gleich... (Muadib,  5. Dez 2004, 20:45:09):
+~#! rn=Bambi rt=1102086169 rg=schmarrn.netdigest
+~#! tid=1102035947
+also ich haette ja nicht gnade vor recht ergehen lassen
+
+-----------------------------------------------------------------------------
+
+
+
+Ab 18... (Ronda,  7. Dez 2004, 22:18:53):
+... neee, nicht Level 18 ;-)
+
+From: Eric Wick <ericwhh@despammed.com>
+Subject: Re: [talk] hot-babe bei debian main aufnehmen?
+Newsgroups: de.comp.os.unix.discussion
+
+spam.for.the@buerotiger.de (Peter Lemken) wrote:
+
+> "PORNUX" - Das Linux fuer den anspruchsvollen Herrn:
+
+Auch als Poppix auf Boot-CD erhaeltlich;-)
+
+Bye Eric
+
+-----------------------------------------------------------------------------
+
+
+
+Doch ganz schoen makaber... (Ronda,  7. Dez 2004, 22:45:04):
+... also doch besser nen "Disclaimer" dran. Wer keine makaberen Witze mag,
+bitte nicht weiterlesen - oder nicht beschweren ;-)
+
+From: "Marcus *Sugus* Michel" <marcus_michel@kraftfahrer-unfallhilfe.de>
+Newsgroups: de.etc.notfallrettung
+Subject: Makaber
+Date: Thu, 25 Nov 2004 12:56:33 +0100
+Message-ID: <30makcF32ikfkU1@uni-berlin.de>
+
+In d.t.j gefunden:
+
+Petrus steht - wie ueblich - am Himmelstor und passt gut auf. Es klopft
+und er oeffnet. Draussen steht ein Kerlchen und sagt: "Hallo,
+ich bin der Hu!" und ist - pffft - wieder verschwunden.
+
+Petrus schliesst das Tor und murmelt "komischer Kerl", als es wieder
+klopft. Draussen steht der Kerl von vorhin und sagt: "Hallo, ich
+bin der Hu!" und ist - pffft - wieder verschwunden.
+
+Petrus macht das Tor wieder zu, schimpft etwas von "So ein Bloedmann",
+als es erneut klopft. Draussen steht, na? Genau! Das Kerlchen
+von eben. "Hallo, ich bin der Hu!" und - pffft - weg ist er.
+
+Petrus schlaegt wuetend das Tor zu, schimpft, dass er sich auch alleine
+veraeppeln koenne, als Gott ihm die Hand auf die Schulter legt:
+"Reg Dich nicht auf Petrus. Das war Hubert Scholze. Der liegt auf der
+Strasse und wird gerade reanimiert."
+
+Gruss Sugus
+
+-----------------------------------------------------------------------------
+
+
+
+Extra fuer Amaryllis ;-) (Ronda,  7. Dez 2004, 22:57:47):
+From: andrea+news200410@shuttle.de (Andrea 'Princess' Wardzichowski)
+Subject: Re: Energieerzeugung
+Newsgroups: de.alt.sysadmin.recovery
+Date: Wed, 27 Oct 2004 07:38:07 +0000 (UTC)
+Message-ID: <clnj8v$qm3$2@ulm.shuttle.de>
+
+Mirko Liss <mirko.liss@web.de> wrote:
+> Dietz Proepper:
+>> Uwe Ohse wrote:
+>> 
+>>> <7eggert@nurfuerspam.de> wrote:
+>>> 
+>>>>Ich bin gegen durchschneiden.
+>>> 
+>>> Manchen Diskussionsteilnehmer hier in der Mitte durchzuschneiden klingt
+>>> verfuehrerisch.
+>> 
+>> Aufpassen, manche wirbellosen verdoppeln sich so...
+
+
+> Admins vermehrt man ungeschlechtlich:  Rueckgrat entfernen, halbieren
+> und in geeigneter Naehrloesung[1] nachwachsen lassen.  Geschlechtliche
+> Vermehrung fuehrt bei Admins nur zur Bildung stoerender Triebe und
+> fruehzeitiger Verbitterung.
+
+Und ich dachte man stellt sich ins Schlafzimmer und schreit "fork"?
+
+Princess
+
+-----------------------------------------------------------------------------
+
+
+
+Ich liebe Statistiken ;-) (Ronda,  9. Dez 2004, 01:10:21):
+From: Dirk Weber <from.header.ist@abwesend.de>
+Subject: Re: Marktanteil Mozilla (Firefox) auf euren Websites?
+Newsgroups: de.comm.software.mozilla.browser
+Date: 09.Oktober 2004, 14:23
+Message-ID: <news:slrncmfm2s.38e.from.header.ist@alucardrak.fqdn.th-h.de>
+
+
+* Patrick Kempf <cmdrfletcher@gmail.com>:
+ 
+>  ich bin Admin bei einer grossen Flirtcommunity (1.1+ Mio Visits / Mon).
+> 
+>  Hier sieht das so aus:
+> 
+>  80% Internet Explorer 6
+>  10% Internet Explorer 5
+>   7% Mozilla / Netscape
+>   1% Opera 7
+
+Zu deutsch: IE-Nutzer haben mehr Probleme, einen Partner zu finden, als
+die Nutzer alternativer Browser. Ein weiterer Grund, den IE in die
+Tonne zu kicken. ;-)
+
+Gruss, 
+Dirk
+
+-----------------------------------------------------------------------------
+
+
+
+Der letzte! (Ronda, 10. Dez 2004, 01:05:26):
+Ich hab endlich de.alt.netdigest durchgearbeitet und darf nun wieder synchron
+lesen! Also gibts den letzten Artikel. Aber ich find den auch echt nett. Nach
+ausreichend Rotwein, I admit. *hick*
+
+Ronda
+
+From: Hendrik Straeter <news.hendrik@adlerstein.de>
+Subject: Re: Verhalten im Aufzug
+Newsgroups: de.alt.soc.knigge
+Date: 02.Oktober 2004, 16:48
+Message-ID: <news:cjmf0j$pht$05$2@news.t-online.com>
+
+
+Uli Stiehl schrieb:
+
+> Hallo zusammen!
+> 
+> Mich wuerde einmal interessieren, ob es verbindliche Regeln gibt, wie
+> man sich im Aufzug Eurer Meinung nach verhaelt.
+
+1.    Wenn ausser Dir nur noch eine andere Person im Aufzug ist, tippe
+       ihm/ihr auf die Schulter und tu dann so, als waerst du es nicht
+       gewesen.
+
+2.    Drueck auf einen Knopf und lasse es aussehen, als ob er dir einen
+       elektrischen Schlag verpasst. Dann laechle und mach es noch ein
+       paar mal.
+
+3.    Biete anderen Leuten an, fuer sie die Knoepfe zu druecken aber
+       druecke die falschen.
+
+4.    Ruf mit deinem Handy eine Wahrsagerhotline an und frag sie, ob
+       sie wissen, in welchem Stockwerk du dich gerade befindest.
+
+5.    Halte die Tueren offen und erklaere, dass du auf einen Freund
+       wartest.
+       Nach einer Weile laesst du die Tueren sich schliessen und sagst:
+       "Hallo Joerg, wie war dein Tag?"
+
+6.    Lass einen Stift fallen und warte, bis ihn jemand fuer dich
+       aufheben will, dann bruell ihn an: "Das ist meiner!"
+
+7.    Nimm eine Kamera mit und mach Fotos von allen Leuten im Aufzug.
+
+8.    Stell deinen Schreibtisch in den Aufzug und frage alle Leute die
+       hereinkommen, ob sie einen Termin haben.
+
+9.    Lege einen Twister-Spielplan auf den Boden und frage die
+       anderen, ob sie mitspielen wollen.
+
+10.    Lege eine Schachtel in eine Ecke und wenn jemand den Aufzug
+        betritt, frag ihn, ob er auch so ein seltsames Ticken hoert.
+
+11.    Tu so, als waerst du eine Stewardess und uebe das Verhalten im
+        Notfall und den sicheren Ausstieg mit den Fahrgaesten.
+
+12.    Frage die Leute: "Haben sie das gerade gespuert"
+
+13.    Stelle dich ganz nah an jemandem heran und schnueffle
+        gelegentlich an ihm herum.
+
+14.    Wenn die Tueren schliessen, erklaere den anderen: "Es ist alles OK.
+        Keine Panik, die Tueren werden sich wieder oeffnen."
+
+15.    Schlage nach nicht-existenten Fliegen.
+
+16.    Erklaere den Leuten, dass du ihre Aura sehen kannst.
+
+17.    Rufe: "Gruppenumarmung!" Und fang damit an.
+
+18.    Mach ein schmerzverzerrtes Gesicht waehrend du auf deine Stirn
+        schlaegst und murmelst "Seid doch still, seid doch endlich alle
+        still!"
+
+19.    Oeffne deinen Geldbeutel, schau hinein und frage: "Kriegt ihr
+        auch genug Luft da drin?"
+
+20.    Starre einen anderen Fahrgast eine Weile an, dann schrei auf:
+        "Du bist einer von IHNEN!" Weiche langsam zurueck, ohne ihn aus
+        den Augen zu lassen.
+
+21.    Trage eine Handpuppe bei dir und benutze sie, um mit den andern
+        zu reden.
+
+22.    Hoere die Waende des Aufzuges mit einem Stethoskop ab.
+
+23.    Ahme Explosionsgeraeusche nach, wenn irgendjemand auf einen Knopf
+        drueckt.
+
+24.    Starre eine Weile lang einen anderen Passagier an, grinse und
+        erklaere nach einer Weile: "Also ICH trage frische Socken".
+
+25.    Male mit Kreide ein kleines Quadrat auf den Boden und erklaere
+        den anderen Fahrgaesten, dass dies deine Zone ist.
+
+
+SCNR,
+
+
+Hendrik ;-)
+
+-----------------------------------------------------------------------------
+
+
+
+Und ich sage Euch... (Ronda, 18. Dez 2004, 02:11:27):
+... mein Waeschestaender hat auch schon solche "Intelligenz"... :-(
+
+Ronda
+
+From:        Henning Sponbiel <Henning@detebe.de>
+Subject:     Re: Postingstatistik <04-09-12>
+Newsgroups:  de.talk.bizarre
+Date:        Mon, 13 Dec 2004 21:01:14 +0100
+
+
+>>>> Ich vermute derjenige der die Gestalt bei der Wiedergeburt aussucht hat
+>>>> einen guten Sinn fuer Humor.
+>
+>>
+>>Und das wird dann ein luegender Schrank, in dem man immer nur einen
+>>Socken findet?
+
+
+Da in nicht allzu ferner Zukunft die Schraenke mit Sprachmodulen
+ausgestattet sein werden, koennte das recht spassig werden.
+
+B. = Benutzer
+S. = Schrank
+W. = Waschmaschine
+
+B. (in Eile): "Schnell, Schrank, gib mir ein Paar schwarze Socken!" 
+S. (TruBlu, reinkarniert): "Ich habe leider keine schwarzen Socken." 
+B.: "Das kann doch gar nicht sein!" 
+S.: "Es ist aber so." 
+B.: "Was mach ich denn jetzt?" 
+S.: "Sie koennten die karierte Hose anziehen." 
+B.: "Arrrgh. Nicht zu _dem_ Termin." 
+S.: "Dann eben nicht." 
+B.: "Hmpf." 
+S.: "Wie bitte?" 
+B.: "Ja, okokok. Dann gib mir schon die karierte Hose raus - mir 
+     bleibt ja keine andere Wahl. ABER BEEIL DICH!" 
+S.: "Hier ist sie." 
+B. (zieht hastig seine schwarze Hose aus und die karierte an): "So, 
+     und jetzt gib mir noch die passenden Socken dazu." 
+S.: "Welches sind denn Ihrer Meinung nach die zu dieser 
+     Geschmacksverirrung passenden Socken?" 
+B. (aechzt): "Verdammt, ich habe es eilig. Wenn du mir nicht sofort 
+     irgendwelche Socken gibst, zerlege ich dich in deine 
+     Einzelteile!" 
+S.: "Jetzt? _Vor_ dem Termin, den sie gleich haben? Das glaub ich 
+     nicht." 
+B.: "DU SOLLST MIR JETZT SOCKEN GEBEN!" 
+S.: "Ich haette da was mit Garfieldmuster." 
+B. (verzweifelt): "Ja, von mir aus in Gottes Namen auch die. 
+     Hauptsache, ich habe endlich Socken!" 
+S.: "Von den Socken mit dem Garfieldmuster gibt es aber nur _eine_ 
+     Socke." 
+B.: "Red nicht so einen Scheiss! Ich weiss ganz genau, dass ich gestern
+     ein Paar von den Socken reingetan habe. Also _zwei_ Stueck." 
+S.: "Leider ist diese Aussage ganz nicht korrekt. Gestern haben Sie 
+     zwar zwei zusammengepackte Socken in mich reingelegt. Aber von 
+     diesen Socken war eine eine Socke mit Schlumpfmotiven und die 
+     andere hatte ein Ringelmuster." 
+B.: "Du luegst, du idiotischer Schrank." 
+S.: "Es tut mir leid. In meiner Datenbank ist nun einmal nur eine der 
+     von Ihnen gesuchten Socken verzeichnet." 
+B. (leicht hysterisch): "Ach! Und wo ist dann die andere Socke 
+     abgeblieben?" 
+S.: "Ich schaue im Archiv nach." Kurze Zeit spaeter: "Vor genau 17 
+     Tagen nahm dieser Schrank ein Paar dieser besagten Socken auf - 
+     die uebrigens rochen, als waeren sie nicht gewaschen worden." 
+B.: "Aaaaaaah. Sag ich doch." 
+S.: "Entnommen wurde eine Socke von diesem Paar vor 3 Tagen um 
+     6:31 Uhr zusammen mit einer der Micky-Maus-Socken." 
+B.: "Du willst mich wohl verarschen? Das war ein Sonntag und da stehe 
+     ich nie so frueh auf."
+S.: "So steht es aber in meiner Datenbank geschrieben."
+B. (hysterisch): "Scheiss auf deine Datenbank. Dann will ich wenigstens 
+     ein Paar irgendwelcher Socken haben."
+S.: "Ich habe kein einziges _Paar_ Socken vorraetig. Nur viele 
+     einzelne. Davon aber eine ganze Menge."
+B.: "WAAAAAS!? Ich habe gleich diesen wichtigen Termin. Und was jetzt?"
+S.: "Moechten Sie sich aus diesen vielen einzelnen Socken selbst welche
+     aussuchen oder soll ich das Paar zusammenstellen?"
+B. (schluchzt und faellt auf die Knie): "Der wichtige Termin! Und ich
+     habe kein Paar Socken. Mein Chef schmeisst mich raus. Schrank, wo 
+     sind denn nur all die Socken geblieben?"     
+S. (fluestert): "Vielleicht weiss die Waschmaschine ja Naeheres!"
+B. (kriecht zur Waschmaschine): "Hast du noch Socken von mir in dir?"
+W.: "Iiiich? Oh, nein. Ich doch nicht." Waschmaschine oeffnet die Tuer. 
+    "Hier, ueberzeugen Sie sich selbst, Nur Hosen und Hemden sowie drei
+     fast aufgeloeste Papiertaschentuecher, den Schluessel zum Buero in
+     der grauen Hose, ein jetzt gereinigter Personalausweis, ein 
+     Fuehrerschein in Fetzen, eine Eintrittskarte (in vielen 
+     Einzelteilen) fuer einen Pornofilm und ein aufgeloester, gut
+     gewaschener Lottoschein - der Ihnen uebrigens, wenn er noch ganz 
+     waere, zu der erklecklichen Summe von immerhin 285.097,28 Euro 
+     verholfen haette."
+B. (fasst sich an die Brust und bricht zusammen): "Arrrrrrrgh!"
+W.: "Jetzt isser tot."
+S. (gluckst vergnuegt, oeffnet die Schranktuer und laesst fuenf Paar 
+     schwarze und 42 Paar andere Socken auf den Boden fallen): "Den 
+     haette ich auch geschafft. Und ja, Waschmaschine, ich habe 
+     tatsaechlich kurze Beine." 
+W.+ S.: (Schauriges Gelaechter)
+
+Hen "Die Zukunft wird interessant" ning
+
+-----------------------------------------------------------------------------
+
+
+
+de.alt.sysadmin.recovery... (Ronda, 29. Dez 2004, 19:38:01):
+... ist ganz schoen recovery.
+
+Ronda
+
+Message-ID: <d29hqc.7r3.ln@rotfl.franken.de>
+Subject: Re: Ebay-Sichetheitsmensch bei SternTV
+Date: Fri, 24 Dec 2004 15:28:29 +0100
+From: Dietz Proepper <dietz-news@rotfl.franken.de>
+Newsgroups: de.alt.sysadmin.recovery
+
+Oliver Schad wrote:
+
+>> Dietz Proepper schrieb:
+>
+>>> > Oliver Schad wrote:
+>>
+>>>> > > Wenn man sich nur als solcher verhaelt, muss
+>>>> > > man sich nicht wundern, wenn man genau so gesehen wird. Nach einem
+>>>> > > gelungen Abend solltest du deiner Angebeteten einfach mal an die
+>>>> > > Brueste fassen, dann weiss sie direkt, dass du nicht nur ihr guter
+>>>> > > Freund sein willst.
+>>
+>>> >
+>>> > Guter Mann, die Frauen welche ich schaetze wuerden sich derartige
+>>> > Vertraulichkeiten energisch verbitten. Zumindest nicht solange man
+>>> > vorher nicht einige andere Schritte des Annaeherungsprotokolls
+>>> > durchlaufen hat.
+>
+>>
+>> Du kennst aber nur wirklich verklemmte Frauen. :-)
+
+
+Moeglich ;).
+
+Hey, nichtmal Schlampen(sic!) stehen darauf, einfach so angefummelt zu
+werden. Wenn Deine Definition des gelungenen Abends in einem langen
+Knutschen endet dann ist der von Dir genannte Schritt sicher nicht
+unangemessen, zum Abschied mal schnell nach den Titten zu grabschen hab'
+ich ganz ehrlich gesagt noch nie ausprobiert.
+
+Ein schneller poll bei den momentan anwesenden passenden Geschlecht
+fuehrt zu 1x "dem knack' ich die Eier", 2x "Watsch'n" und 1x "wo findet
+man denn solche Knaller?!"
+
+-----------------------------------------------------------------------------
+
+
+
+Re: de.alt.sysadmin.recovery... (Darklor, 29. Dez 2004, 19:41:05):
+~#! rn=Ronda rt=1104345481 rg=schmarrn.netdigest
+~#! tid=1104345481
+Junge is der gut - koennte fast unter Witze passen...
+
+Darklor (lachend)
+
+-----------------------------------------------------------------------------
+
+
+
+Mist, ich hab doch Hunger :-( (Ronda, 29. Dez 2004, 21:02:46):
+From: Jockel Hofmann <post@jockelhofmann.de>
+Newsgroups: de.alt.recovery.webauthor
+Subject: Re: Erdstrahlen und Freileitungen
+Date: Sat, 18 Dec 2004 11:42:31 +0100
+Message-ID: <32ifsoF3o5i3uU1@individual.net>
+
+Volker Gringmuth am Samstag, 18. Dezember 2004 00:20:
+
+
+>> Timo Kissing wrote:
+>> 
+>
+>>>> Womit wir auch gleich beim Nachteil waeren: WLAN transportiert auch
+>>>> keine Erdbeeren.
+>
+>> 
+>> Ausser die Verkabelung wurde mit STP-(Strawberry Transfer Protocol-)
+>> Kabeln vorgenommen.
+
+
+Ist das eine Erweiterung von FTP (Food Transfer Protocol)?
+
+Ich arbeite allerdings lieber mit SCP (Strawberry Crunch and Paste), da
+das
+ja bekanntlich die fuer diesen Verwendungszweck spezialisierte SSH
+benutzt
+(besser bekannt als "Strawberry-SHell")
+
+NNTP (Natural Nutritions Transfer Protocol) soll aber auch nicht
+schlecht
+sein, weil es besonders schonend mit Naehrstoffen umgehen kann.
+
+Wichtig ist halt, dass die WLAN-Kabel dick genug sind, dass die
+Erdbeeren
+durchpassen!
+
+:-) Jockel
+
+-----------------------------------------------------------------------------
+
+
+
+Schwiegermama, schau doch mal... (Ronda, 31. Dez 2004, 19:00:35):
+... ob der Toast schon fertig ist?!
+
+From: esselbach@t-online.de (Frank Esselbach)
+Newsgroups: de.sci.electronics
+Subject: Was zum Schmunzeln: Toast belichten
+Date: Fri, 31 Dec 2004 00:13:51 +0100
+Message-ID: <1gpmsyf.b3ynqt1jt7602N%esselbach@t-online.de>
+
+Ich besitze seit ca. 3 Jahren einen Toaster, das Modell von Siemens im
+Alu-Porsche-Design. Nun ging vor einigen Wochen der erste der beiden
+Quarz-Heitstaebe kaputt. Trotz intensivster Bemuehungen, kein Weg, an
+sowas als Ersatzteil ranzukommen, weder bei Siemens noch anderswo...
+
+Die daraufhin von mir durchgefuehrte Reparatur mit selber spiralisiertem
+Konstantandraht war nur von kurzer Dauer, erstens liess sich das Problem
+der Anschlusskontaktierung nur unvollkommen loesen und zweitens
+verabschiedete sich bald darauf der zweite Heizsztab.
+
+Bei einem Bummel durch die Leuchtmittelabteilung bei Conrad hatte ich
+ploetzlich den genialen Einfall: Halogenstaebe mit 255 mm Laenge, 1500
+Watt!
+
+Dazu noch 2 R7S-Sockel zerlegt und ein wenig Feinblechner-Arbeit und
+seit heute funktioniert der Toaster wieder. Abgesehn davon, dass man
+fast blind wird, wenn man den Braeunungsgrad der Toastscheiben durch
+Hineinsehen in den Schlitz pruefen will, funktioniert es praechtig! 
+
+Ich habe uebrigens die beiden Halogenstaebe in Reihe geschaltet, 3000 Watt
+schienen mir dann doch ein weinig uebertrieben. Wer will schon, dass das
+Toast nach 10 Sekunden in Flammen aufgeht. So stimmen die Toastzeiten
+fast mit den von frueher gewohnten ueberein ...
+
+Sollte ein Halogenstab kaputt gehen, kann man ihn nun innerhalb von 30
+Sekunden auswechseln (nachdem er abgekuehlt ist) und kostet weniger als 4
+Euro.
+
+Frank
+
+-----------------------------------------------------------------------------
+
+
+
+Handel oder nicht Handel? (Ronda, 31. Dez 2004, 19:02:33):
+Ok, mein Humor heute braucht vielleicht eine Rejustierung, aber ich find das
+echt nett (besonders die Beschreibung von Haendels Charakter...).
+
+Ronda
+
+From: "DaveVH" <dvh@ddaavvee.com>
+Newsgroups: de.etc.handel.auktionshaeuser
+Subject: Handel
+Date: Wed, 29 Dec 2004 22:24:37 -0000
+Message-ID: <cqvas6$jba$1@news7.svr.pol.co.uk>
+
+Hello!
+
+I'm so pleased there's a newsgroup now devoted to Handel!  That's quite an
+honour, considering not even Beethoven has a newsgroup.
+
+I'm a big fan of Handel, and I've been wondering about something.  Maybe you
+can help.
+
+When he was young he was made to go into the attic to practice the
+harpsichord.  I imagine this was probably very hard, and it may have
+affected him psychologically.  But do you think it affected his music in
+later life?  He had such a joyous sound most of the time, but I also think
+he was melancholy - like a seventeenth-century German bluesman who happened
+to play baroque music and was white.
+
+Thanks for your help.
+
+DaveVH
+
+-----------------------------------------------------------------------------
+
+
+
+Kids, don't do this at home! (Ronda,  1. Jan 2005, 18:53:08):
+From: Joachim Wiesemann <newsantwort.345@jwiesemann.de>
+Subject: Re: Neues MLM? Dummenfang? Weihnachts-April-Scherz? (
+Kostenloses Handy   von Exxxx)
+Newsgroups: de.etc.beruf.selbstaendig
+Date: Tue, 28 Dec 2004 11:15:36 +0100
+Message-ID: <33cq24F3vqqefU1@individual.net>
+
+Am 27.12.2004 23:26 geruhte Susanne Dieter zu schreiben:
+
+>> Es geht aber noch einfacher. Wenn Du jemandem einen Streich spielen 
+>> willst, loesche einfach die Desktop- und /oder Startmenue-Eintraege, dann 
+>> denkt derjenige, die Programme sind verschwunden.
+
+
+Das erinnert mich an einen Arbeitskollegen meiner Freundin, dem liebe 
+Kollegen seinen Desktop mit geoeffentem Word "abfotografiert" und als 
+Hintergrundbild montiert hatten. Dann noch Word schliessen und die Icons 
+in einen Ordner schieben ...
+
+Er hat 2 Stunden (!) probiert, bis er jemanden um Hilfe fragte. (Auch 
+neu booten half irgendwie nicht ;-)
+
+Viele Gruesse
+Joachim
+
+-----------------------------------------------------------------------------
+
+
+
+Wo Siebeck leidet: die Kantine des Bundestags (Vanion,  3. Jan 2005, 20:15:14):
+POTSDAM - Der Gastronomiekritiker Wolfram Siebeck macht sich ernsthafte
+Sorgen um die Ernaehrung deutscher Spitzenpolitiker. Nach einem Test der
+Berliner Bundestagskantine urteilte Deutschlands bekanntester
+Kochkritiker im Politikmagazin "Cicero": "Hier herrscht die Lust am
+Untergang." \ber einem "gebratenen Lachssteak, einem Haufen weisslicher
+Staebchen, die zur Familie der Kohlrabi gehoeren" und einem Haufen Reis
+machte Siebeck jene weisse, dicke Sauce aus, "welche die Mahlzeiten der
+Kindheit in Albtraeume verwandelt hat". Doch es sollte fuer den Gourmet in
+Gestalt einer Kyritzer Hasenkeule noch schlimmer kommen: "Das Ding sieht
+aus wie der Vtzi. Genauso dunkelbraun, genauso ledern wie der
+praehistorische Gletscherwanderer." Grausamer Schlusspunkt war der
+Nachtisch: "Zweimal suesser Brei und ein Schuesselchen mit giftig-gruener
+Goetterspeise." Siebecks erschuetterndes Fazit: "Erwachsene essen das und
+diskutieren anschliessend ueber die Gesundheitsreform." Falsche Ernaehrung
+wirke sich erst nach etwa zwanzig Jahren aus, weiss Siebeck und
+prophezeit: "In zwanzig Jahren sind die meisten Puddingesser in Rente
+wegen Fruehinvaliditaet."
+
+ddp
+
+Quelle: Tagesspiegel, Mittwoch, 29. Dezember 2004
+--
+Hab ich grad in d.r.m. gelesen.
+
+V*
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Wo Siebeck leidet: die Kantine des Bundestags (Kellybundy,  7. Jan 2005, 19:05:23):
+~#! rn=Vanion rt=1104779714 rg=schmarrn.netdigest
+~#! tid=1104779714
+1.) zeugt die Statur Siebecks auch nicht gerade von gesunder Ernaehrung
+2.) waere es nett wenn das Mud endlich mal ISO-8859 koennte ;-)
+3.) ist der Vergleich einer Kantine mit einem Spitzenrestaurant ungefaehr so
+als wollte man Trabbi und Ferrari vergleichen
+4.) gehoert es anscheinend eh zum guten Ton an Kantinenessen herumzunoergeln,
+komischerweise gehn ausgerechnet die Noergler immer wieder hin
+5.) sind derartike Kritiken immer recht subjektiv
+6.) ist mir jeder, der die nouvelle cuisine hochlobt, wie der Siebeck,
+suspekt. Wenn der ausschliesslich von nouvelle cuisine leben wuerde, wie der
+es propagiert, dann waere er mittlerweile entweder pleite oder verhungert.
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Wo Siebeck leidet: die Kantine des Bundestags (Croft,  7. Jan 2005, 19:08:21):
+~#! rn=Kellybundy rt=1105121123 rg=schmarrn.netdigest
+~#! tid=1104779714
+Nuja, er sagt er hat selbst schon den Wert eines Ein-Familien-Hauses
+verfuttert ...
+
+Croft
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Wo Siebeck leidet: die Kantine des Bundestags (Muadib,  7. Jan 2005, 19:14:29):
+~#! rn=Croft rt=1105121301 rg=schmarrn.netdigest
+~#! tid=1104779714
+wuerd ich auch gerne koennen, am besten im eigenen ein-familien-haus mit nem
+ferrari vor der tuer
+
+-----------------------------------------------------------------------------
+
+
+
+Drei Weizenbier. (Ronda,  8. Jan 2005, 00:23:27):
+Schiebt es einfach auf drei Weizenbier. Ich find den Artikel gut.
+
+Ronda *hicks!*
+
+From: Adrian Knoth <adi@thur.de>
+Newsgroups: de.comp.security.misc
+Subject: Re: Gattinen im Netz
+Date: 3 Jan 2005 18:19:48 GMT
+
+Thorsten Dahm <usenet_muelleimer@gmx.net> wrote:
+
+
+>> Entweder man vertraut seiner Partnerin, dann wird man(n) niemals Ihre 
+
+                                                           ^^^^^^^ 
+
+
+>> Wer seine Partnerin auf die Frage "hast Du Bilder von nackten Maedels auf 
+>> der Platte" hin anluegt luegt sie auch bei anderen Dingen an. 
+
+
+Ich weiss zwar nicht, worum es geht (Thread nicht gelesen), aber
+alle, die pauschalisieren, sind bloed ;)
+
+
+>> das heimliche Masturbieren ist nur 
+
+
+Masturbation ist die Antwort auf das Erpressungsmittel "Erloesungsmonopol".
+Sowohl Kirche als auch alte gesellschaftliche Strukturen ("Wixen gibt
+einen kaputten Ruecken/kaputtes Hirn/Schwimmhaeute an den Fingern") aber
+genauso Frauen wettern gegen Masturbation, weil sich damit der Mann
+aus seiner erpressbaren Situation befreit und der Geschlechtsverkehr
+nicht mehr instrumentalisierbar, materiell nutzbar ist.
+
+Oder kurz: Masturbation ist das Linux unter den Sexualpraktiken ;)
+
+-----------------------------------------------------------------------------
+
+
+
+Dieser Artikel ist ziemlich... (Ronda,  8. Jan 2005, 00:30:08):
+... Vakuum. Nicht ganz, aber wir geben uns Muehe.
+
+Ihre de.alt.netdigest-Digestorin Ronda
+
+From: Wolfgang Schmidhuber <wsnews_04@gmx.de>
+Subject: Re: "bis zu"
+Newsgroups: de.etc.sprache.deutsch
+Date:Mon, 27 Dec 2004 15:12:05 +0100
+Message-ID: <cqp57l$d3p$02$1@news.t-online.com>
+
+Gerd Thieme schrieb 
+
+
+>>Peter Muthesius wrote:
+>>
+>
+>>>> Ist eigentlich die Roehre meines Monitors mit evakuierter Luft gefuellt?
+>
+>>
+>>In die besseren kommt Vakuum rein.
+
+
+Schild an einem Metzgerladen am muenchener Viktualienmarkt:
+
+"Wir verpacken auch Vakuum!"
+
+-----------------------------------------------------------------------------
+
+
+
+[de.rec.musik.machen] Re: Blues Styles gesucht (Nonne, 31. Jan 2005, 10:56:11):
+Heinz Lindemann wrote:
+
+> [blues]
+> ein schoener zeitvertreib. Blues passt doch zu meiner jetzigen Situation.
+> ;-)
+
+Hallo Heinz,
+ob Blues wirklich zu Deiner Situation passt, kannst Du anhand 
+nachfolgender Liste pruefen :-)
+Gruss,
+jk
+
+1. Blues beginnt fast immer mit "Woke up this morning".
+
+2. "I got a good woman" ist ein schlechter Blues-Anfang, es sei denn, Du 
+denkst Dir fuer die zweite Zeile etwas ganz gemeines aus wie "I got a 
+good woman with the meanest face in town" oder aehnlich mieses.
+
+3. Der Blues ist simpel. Wenn Du die erste Zeile gesungen hast, 
+wiederhole sie einfach. Dann mach Dir darauf einen Reim, etwa so:
+"Got a good woman with the meanest face in town,
+Yes, I got a good woman with the meanest face in town.
+Got Teeth like Margaret Thatcher, and she weighs 500 pounds".
+
+4. Der Blues bedeutet nicht unbegrenzte Moeglichkeiten.
+
+5. Blues Autos sind Chevies, Cadillacs and alte Pick-ups. Der Blues 
+reist nicht im Volvo, BMW oder Daimler, auch nicht im Flugzeug.
+Andere Blues-Transportmittel sind der Greyhound Bus oder der Zug 
+Richtung Sueden.
+Zu Fuss unterwegs sein spielt eine bedeutende Rolle im Blues Lifestyle, 
+Warten auf den Tod auch.
+
+6. Teenager koennen keinen Blues spielen, sie warten noch nicht auf den 
+nahen Tod. Erwachsene singen den Blues. Im Blues bedeutet erwachsen 
+sein, dass Du alt genug fuer den elektrischen Stuhl bist, wenn Du einen 
+Typen in Memphis erschiesst.
+
+7. Du kannst den Blues in New York City haben, aber nicht auf Hawaii 
+oder irgendwo in Kanada. Schlechte Zeiten in Minneapolis oder Seattle 
+bedeuten lediglich Depressionen, aber keinen Blues. Chicago, St. Louis 
+und Kansas City sind immer noch die besten Plaetze um den Blues zu haben.
+
+8. Folgende Farben kommen im Blues nicht vor:
+a.violett
+b.beige
+c.mauve
+
+9. Ein Mann mit Glatze symbolisiert keinen Blues. Eine Frau mit Glatze 
+tut es. Sich das Bein beim Skifahren zu brechen symbolisiert nicht den 
+Blues.
+Sich das Bein zu brechen, weil ein Krokodil darauf rumgekaut hat tut es.
+
+10. Du kannst keinen Blues im Buero oder im Einkaufszentrum haben. Das 
+Licht passt einfach nicht. Geh raus auf den Parkplatz oder setz dich 
+neben die Muelltonnen.
+
+11. Gute Orte fuer den Blues sind:
+a.derHighway
+b.derKnast
+c.einleeresBett
+
+Schlechte Plaetze sind:
+a.KaDeWe
+b.Vernissagen
+c.Golf-Plaetze
+
+12. Niemand wird an Blues denken, wenn Du einen Anzug traegst, Ausnahme: 
+Du bist ein alter, farbiger Mann.
+
+13. Hast Du das Recht den Blues zu spielen?
+Ja,wenn:
+a.DuDeinVornamedereinesSouthernStateist,z.B.Georgia
+b.Dublindbist
+c.DujemandinMemphiserschossenhast
+d.Duniemalszufriedenbist
+
+Nein,wenn:
+a.Dufrueherblindwarstaberjetztwiedersehenkannst
+b.Dutaubbist
+c.DueineLebensversicherunghast
+
+14. Julio Iglesias und Barbara Streisand koennen keinen Blues singen.
+
+15. Blues ist keine Frage der Hautfarbe. Er ist eine Frage des Ungluecks 
+im Leben. Tiger Woods kann keinen Blues spielen. Sonny Liston koennte.
+Nur richtig haessliche Weisse haben auch ?nen Anspruch auf den Blues
+
+16. Wenn Du um Wasser bittest aber Benzin bekommst, das ist der Blues. 
+Blues Getraenke sind:
+a.Wein
+b.Whiskey
+c.truebesWasser
+d.ekligerschwarzerKaffee
+
+Keine Blues Getraenke sind:
+a.alleMixgetraenke
+b.Brause(Pulver,Tabs,Wuerfel)
+c.Eistee
+
+17. Wenn es in einer billigen Absteige oder bei einem Waffendealer 
+passiert, dann ist es ein Blues-Tod. Von einem eifersuechtigen Liebhaber 
+erstochen zu werden ist auch eine Art den Blues-Tod zu sterben. Ebenso 
+der elektrische Stuhl, Ueberdosierung irgendwelcher Art oder die 
+Weigerung von Notaerzten, Dich zu behandeln.
+Es ist kein Blues-Tod, waehrend einer Schoenheitsoperation zu sterben.
+
+18. Ein paar Blues-Namen fuer Frauen:
+a.Sadie
+b.BigMama
+c.Bessie
+
+19. Ein paar Blues-Namen fuer Maenner:
+a.Joe
+b.Willie
+c.LittleWillie
+d.Lightning
+
+20. Frauen mit dem Namen wie Sierra oder Sequoia koennen den Blues nicht 
+spielen, voellig egal wie viele Leute sie in Memphis erschossen haben.
+
+21. Blues-Namen-Bausatz:
+a.koerperlicheBehinderungwaehlen:
+z.B.Blind,Cripple,Asthmatic...
+b.Vorname=Wahlausa.+NameeinerFrucht
+z.B.BlindLemon,CripplePeach
+c.NachnahmeeinesPraesidenten
+z.B.Jefferson,Johnson,Fillmore...
+d.Mixen!
+
+22. Voellig egal wie tragisch das Leben verlaeuft, wenn Du einen Computer 
+hast kannst Du nie den Blues spielen.
+
+-----------------------------------------------------------------------------
+
+
+
+Und nein... (Ronda, 17. Feb 2005, 21:42:43):
+... ich war das auch nicht!
+
+Ronda *diesmal mit halbwegs gutem Gewissen*
+
+[Aus einem weniger bekannten IRC-Channel]
+
+09:31:50 <@Zeroth_> "Sie sitzen nachts allein in der Bank, es
+    rauchen der Reihe nach mehrere E10K Domains ab,
+    in jedem Rechner (ueber 1000) verabschieden sich
+    je 60% der Platten mit markanten Kreischen), der
+    Strom faellt aus und Notstrom kommt nicht hoch.
+    Wie verhalten Sie sich? - a) Ich will nach
+    Hause... b) "Ich hab nix gemacht" c) Ich will
+    wieder Archaeologe werden
+09:32:25 <@Isotopp> Zeroth_: das ist keine typische fehlersituation.
+09:32:41 <@Zeroth_> Nein, das ist Hardcore Alptraum
+09:32:43 <@Isotopp> Zeroth_: wenn du auf diese weise strom, storage
+    und domains verlierst, handelt es sich
+    vermutlich um ein erdbeben.
+09:33:12 <@Isotopp> Zeroth_: in diesem fall muss sofort bis zum CSO
+    und Vorstand eskaliert werden und es muss der
+    notfall-rechenzentrum-plan aktiviert werden.
+
+09:33:23 <@Zugschlus> Zeroth_: b)
+09:33:49 <@Zeroth_> Zugschlus: Volle Punktzahl
+
+-----------------------------------------------------------------------------
+
+
+
+Man beachte bitte... (Ronda, 17. Feb 2005, 21:58:57):
+... auch die Signatur. Sie ist das einzig anstaendige an diesem Artikel aus
+de.alt.recovery.scientist. Noch von news.individual.net, aber leider nicht
+mehr lange.
+
+Ronda
+
+Lothar Kimmeringer <news200501@kimmeringer.de> writes:
+
+
+>> Wird das jetzt der Teilthread "Schluepfrige Lehrerzitate"?
+>> OK, hier ist ein weiterer:
+>>
+>> "Wer noch keinen Merkzettel hat, der gehe bitte zum Sekretariat
+>> und hole sich einen runter".
+
+
+Musiklehrerin (aus den 70ern uebrig geblieben, haesslich wie die Nacht)
+kommt rein und fragt "Habt ihr hier einen Fernseher stehen?", darauf
+mein Mathelehrer: "Nein, ich hab keinen stehen.".
+
+Als sie dann wieder draussen war und wir uns beruhigt hatten meinte er
+"Ich hab Jahre warten muessen, bis ich den Spruch loslassen konnte."
+
+Jaja, der Kiefer war noch einer aus der aussterbenden Rasse echter
+Originale.
+
+-- Did you ever realize how much text fits in eighty columns? If you now
+consider that a signature usually consists of up to four lines, this gives you
+enough space to spread a tremendous amount of information with your messages.
+So seize this opportunity and don't waste your signature with bullshit nobody
+will read. 
+
+-----------------------------------------------------------------------------
+
+
+
+Doener ohne CSS (Mupfel, 17. Feb 2005, 23:26:12):
+Lars Kasper schrieb:
+> Michael Fesser schrieb:
+>> .oO(Lothar Kimmeringer)
+>>> On Wed, 26 Jan 2005 18:46:54 +0100, Lukas Graf wrote:
+>>>> Bei HTML gibt es dafuer "You see HTML, you get HTML". Also YSHYGH. Das
+ist
+>>>> gut so, und erst noch viel einfacher auszusprechen als WYSIWYG.
+>>>
+>>> Wobei Dein Wort eventuell auf Tuerkisch eine ganz fiese
+>>> Beleidigung sein koennte, also pass auf, wo du es sagst.
+>>
+>> Mal beim Doenermann um die Ecke probieren: "Einmal YSHYGH mit alles."
+>
+> "Mit alles" ist dann sicherlich auch mit CSS.
+
+Habbich heute ma probiert:
+
+Ich: "Iyi Guenler! Einmal Doener ohne CSS"
+
+Doenermann: "Wasn Ceses? Habe nich!"
+
+I: "Dann is ja gut. Dat nehm ich."
+
+D: "Ja wie? Was nehmen?"
+
+I: "Doener ohne CSS."
+
+D: "Ich nix weiss was Ceses. Willst Du Doener mit allem?"
+
+I: "Ja. Aber ohne CSS."
+
+D: "Ich habe nix Ceses. Ich kenne nix Ceses."
+
+I: "Prima! Dann nehme ich das."
+
+D: <mode volume="louder">"Hier nix Ceses, klar?"</mode>
+
+I: "Is ja jut! Jenau dat will ich."
+
+Der Dialog zog sich noch bei zunehmender Lautstaerke etwas hin und
+wurde
+erst durch die Intervention  der Menschen hinter mir in der Schlange
+beendet, die Hunger hatten. Ich glaube, in dieser Doenerbude sollte ich
+vorlaeufig nicht wieder auftauchen.
+
+Fazit: Die Trennung von Inhalt und Design ist bei Doener noch nicht
+bekannt.
+
+-mupfel-
+
+-----------------------------------------------------------------------------
+
+
+
+Netdigest ... (Vanion, 22. Mar 2005, 20:27:42):
+From: Ralf Angeli <dev.null@iwi.uni-sb.de>
+Newsgroups: de.comp.editoren
+Subject: Re: [Emacs] Vorschlag eines einfach zu handhabenden
+Template/Snippet-Mechanismuses
+Date: Mon, 21 Mar 2005 14:47:46 +0100
+Message-ID: <3a81jvF69d52kU1@individual.net>
+
+* David Kastrup (2005-03-21) writes:
+
+
+>> Die ganze Arbeit an Benutzerfreundlichkeit ist doch fuer den A....,
+>> weil die Benutzer das Handbuch nicht einmal anschauen, wenn man es
+>> ihnen per Menu unter die Nase reibt.
+
+
++-----------------------------------------------------------------+
+| Hallo [Benutzer],                                               |
+|                                                                 |
+| Du hast Emacs neu gestartet.  Wir moechten dies zum Anlass       |
+| nehmen, eine neue Runde unseres Emacs-Handbuch-Quiz zu spielen. |
+| Thema dieses Mal: Kaffee machen                                 |
+|                                                                 |
+|     ?  Mit dem Tastaturkuerzel `C-u 3 C-M-S-1 RET C-x e a' wird  |
+|   O'   a) die Koernung der Kaffeemaschine auf Stufe 3 gestellt,  |
+|  <|    b) eine Bestellung ueber drei Cappuccino beim             |
+|   |\      naechstgelegenen Caf aufgegeben oder                  |
+|        c) der Java-Modus aktiviert.                             |
+|                                                                 |
+| Bitte triff Deine Wahl jetzt.                                   |
+|                                                                 |
+| Als Belohnung bei richtiger Antwort winkt ein zwanzigteiliges   |
+| Fingerhantelset oder wahlweise eine chinesische Fingerfalle fuer |
+| die erzwungene Pause zwischendurch.                             |
++-----------------------------------------------------------------+
+
+
+
+-- Submissionen fuer de.alt.netdigest bitte an
+<de-alt-netdigest@moderators.dana.de> schicken. Der Einsender ist fuer den
+Inhalt der Einreichung verantwortlich, nicht der Moderator der Newsgruppe. 
+--
+V*
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Netdigest ... (Darklor, 22. Mar 2005, 20:36:38):
+~#! rn=Vanion rt=1111519662 rg=schmarrn.netdigest
+~#! tid=1111519662
+Gibts dieses Tastaturkuerzel echt?
+
+Darklor
+
+-----------------------------------------------------------------------------
+
+
+
+DAS will ich auch! (Ronda, 25. Mar 2005, 23:10:27):
+... den anderen Artikel - den mit den Cola-Kisten, den ich Rochus gewidmet
+haette - hab ich mir verkniffen. Der hier ist erstrebenswerter...
+
+Ronda
+
+From: Thorsten Michels <michels@aton.informatik.uni-kl.de>
+Subject: Re: Seid endlich RUHHHHHHHHHHIIIIIIIGGGGGGG!!!!11elf
+Newsgroups: de.alt.sysadmin.recovery
+Date: Thu, 24 Mar 2005 14:28:28 +0000 (UTC)
+Message-ID: <slrnd45jkc.gm1.michels@aton.informatik.uni-kl.de>
+
+Oliver Schad <o.schad@web.de> wrote:
+
+>> 
+>> Mein Fluessigkeitshaushalt war auf jedenfall kaputt. Ich musste gestern
+>> nach dem Bier pissen wie ein Pferd. Haette gar nicht gedacht, dass soviel
+>> Fluessigkeit in der Blase sein kann. Hab schon unglaeubig nach dem
+>> Special-Effect-Mann Ausschau gehalten.
+
+
+Bier spuelt die Nieren durch. Als ich einen Nierenstein hatte, gaben mir
+die Aerzte den Rat, viel Bier zu trinken. Also hab ich einen Kasten Bier
+mit ins Krankenhaus genommen. Die Blicke der anderen Patienten waren
+recovery.
+
+Schoenen Gruss,
+Thorsten
+
+-----------------------------------------------------------------------------
+
+
+
+Vulkanismus... (Amaryllis,  3. Apr 2005, 20:51:00):
+Subject: Re: Vulkan Mount St. Helens wieder aktiv
+From: Hans-Georg Bickel <hgbusenetmuell@gmx.de>
+Message-ID: <d0ngol.2b0.1@ID-108823.user.uni-berlin.de>
+Date: Wed, 09 Mar 2005 18:54:13 +0100
+Newsgroups: arcor.misc
+
+Arcor Newsticker <dpa@arcor-online.net> wrote:
+
+> Im vergangenen Herbst war der Mount St. Helens nach einer
+> laengeren Ruhephase wieder zum Leben erwacht.
+
+Aha. Ein Schlaefer also. Handeln Sie, Mr. Bush! Setzen Sie ein
+Zeichen im Kampf gegen den internationalen Vulkanismus!
+
+HG
+
+-----------------------------------------------------------------------------
+
+
+
+de.alt.netdigest goes IRC (Ronda, 23. Apr 2005, 23:26:08):
+Ich frag mich ja nur, was er gedacht hat das es ist?
+
+Ronda
+
+Newsgroups: de.alt.netdigest
+Subject: Irclog
+
+Hoi,
+
+hier was ausm IRC (anonymisiert):
+
+<XXXX> so geil, heute hat einer von den drei indern in ein an die wand
+gebeamtes pdf dokument gemalt mit einem edding
+<XXXX> und grade im dezember wurde der besprechungsdraum frisch geweisselt
+<YYY> an die wand?
+<YYY> wie bitte?
+<YYY> hehe.... das nenn ich mal genial ;-)
+<XXXX> ja an die wand... ich dachte ich fall um vor lachen
+<XXXX> als ich etwas aufgeschreckt bin, meinte er nur
+<XXXX> "Ohhhhhhhhhhhhhhhhhhh it's a wall?"
+
+-----------------------------------------------------------------------------
+
+
+
+Re: de.alt.netdigest goes IRC (Muadib, 24. Apr 2005, 00:49:17):
+~#! rn=Ronda rt=1114291568 rg=schmarrn.netdigest
+~#! tid=1114291568
+sowas ist mir auch schon passiert
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: de.alt.netdigest goes IRC (Croft, 24. Apr 2005, 00:52:25):
+~#! rn=Muadib rt=1114296557 rg=schmarrn.netdigest
+~#! tid=1114291568
+D.h. du hast mit dem Edding auf einer Wand gezeichnet?
+
+Croft
+
+-----------------------------------------------------------------------------
+
+
+
+Re: de.alt.netdigest goes IRC (Requiem, 24. Apr 2005, 09:05:35):
+~#! rn=Ronda rt=1114291568 rg=schmarrn.netdigest
+~#! tid=1114291568
+Ueberrascht mich nicht wirklich ;-)
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: de.alt.netdigest goes IRC (Muadib, 24. Apr 2005, 12:09:00):
+~#! rn=Croft rt=1114296745 rg=schmarrn.netdigest
+~#! tid=1114291568
+jo
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: de.alt.netdigest goes IRC (Ronda, 24. Apr 2005, 12:10:20):
+~#! rn=Muadib rt=1114337340 rg=schmarrn.netdigest
+~#! tid=1114291568
+Ich kenn immer nur die Variante, statt nem Boardmarker (abwischbar) nen
+wasserfesten Edding auf nem Whiteboard zu verwenden...
+
+Ronda *redet Denglish*
+
+-----------------------------------------------------------------------------
+
+
+
+Re^5: de.alt.netdigest goes IRC (Muadib, 24. Apr 2005, 12:11:04):
+~#! rn=Ronda rt=1114337420 rg=schmarrn.netdigest
+~#! tid=1114291568
+es hat aber niemanden gestoert und ich war nicht der einzige. erst beim
+wegwischen fiel uns das auf
+
+-----------------------------------------------------------------------------
+
+
+
+Re: de.alt.netdigest goes IRC (Jimdigriz, 24. Apr 2005, 16:09:45):
+~#! rn=Ronda rt=1114291568 rg=schmarrn.netdigest
+~#! tid=1114291568
+Oh lustig, hats sogar hierher geschafft.
+
+JdG (weiss wer XXXX und YYY sind, auch wenn das ja egal ist)
+
+-----------------------------------------------------------------------------
+
+
+
+de.alt.netdigest - extra fuer Humni (Arathorn, 26. Apr 2005, 21:09:36):
+(Vorsicht, laenglich.)
+
+Arathorn.
+
+From: Karl Valentin <tonne@karlvalentin.de>
+Subject: Zum Tag des Bieres
+Newsgroups: de.talk.bizarre
+Date: Sat, 23 Apr 2005 07:26:28 +0000 (UTC)
+Message-ID: <slrnd6ju54.48u.tonne@toxoplasmose.karlvalentin.de>
+
+Liebe Schwestern und Brueder des alkoholischen Geistes!
+
+Bier ist ein edler Trunk. Ihr sollt euch daran laben und ihn
+preisen und auch preisen sollt ihr, wer euch das Bier gebraut, und
+auch, wer euch das Bier eingeschenkt.
+
+Selig, die ein Bier trinken, denn ihnen gehoert das Himmelreich.
+Selig die Duerstenden, denn ihr Durst wird gestillt werden. Selig,
+die das Glas erheben, denn auf ihr Wohl wird getrunken werden.
+Selig die Brauenden, denn sie verwandeln Wasser in Bier. Selig die
+Schankmaiden und Wirte, denn sie versorgen uns mit dem edlen
+Trunke. Selig, der glaubt, noch ein Bier zu brauchen, denn er hat
+zum rechten Glauben gefunden.
+
+Der Hopfen ist die Seele des Bieres. Wenn das Bier seine Seele
+verliert, wie kann es uns Seelenheil bringen? Es taugt zu nichts
+mehr; es wird weggeschuettet und von den Leuten geaechtet. Das Malz
+ist der Koerper des Bieres, es gibt ihm Farbe und Geschmack. Man
+giesst kein Bier ein und stuelpt ein Gefaesst darueber, man stellt es
+auf den Tisch, damit ein jeder sich daran erfreue. So soll stets
+ein gefuellter Krug Bier auf dem Tische stehen, damit man des
+Brauers gutes Werk sieht und preise.
+
+Huetet euch, euren Rausch oeffentlich zur Schau zu stellen; sonst
+habt ihr kein weiteres Bier von eurem Wirte zu erwarten. Wenn du
+ein Bier spendierst, so lass es nicht vor dir herposaunen, wie es
+die Heuchler in den Schenken und Wirtshaeusern tun, um von den
+Leuten gelobt zu werden. Amen, das sage ich euch: Sie haben ihren
+Lohn bereits erhalten. Dein Bier sollst Du teilen, denn wer gibt,
+dem wird gegeben werden.
+
+Ihr habt gehoert, das gesagt worden ist: Das Bier soll wohl
+temperiert sein. Ich aber sage euch: Ist das Bier zu kalt, so
+truebt es ein und bildet keine rechte Krone. Ist das Bier zu warm,
+schmeckt es schal und der Schaum nimmt ueberhand.
+
+Ihr habt gehoert, dass gesagt worden ist: Es ist in Ordnung, aus der
+Flasche zu trinken. Ich aber sage euch: Nur dem, der aus dem Glase
+trinkt, wird das Bier ein Genuss sein. Dem, der sein Bier aus der
+Flasche trinkt, wird sich der Genuss nicht erschliessen. Wer sein
+Bier aus der Dose trinkt, soll dem Feuer der Hoelle verfallen sein.
+Giess ohne Zoegern das Bier in das Glas, dass Du schraeg unter Flasche
+oder Zapfhahn haeltst. Ist das Glas zur Haelfte gefuellt, halte es
+senkrecht und fuelle es bis zum Eichstrich und erfreue Dich an der
+Krone. Lass Dir nicht zu viel Zeit, sonst wird das Bier schal.
+Amen, und das sage ich dir: Am schalen Bier wirst Du keine Freude
+haben, an keinem Tropfen.
+
+Wenn ihr trinket, so macht es nicht wie die Heuchler. Sie ziehen
+sich zum Trinken in ihre Kammern zurueck, um nicht teilen zu muessen
+den gepriesenen Trunk. Amen, das sage ich euch: Sie haben ihren
+Lohn bereits erhalten. Du aber geh ins Wirtshaus, bevor du
+trinkest, lasse ein Prosit erschallen; dann trinke dein Bier, was
+im Glase ist. Dein Wirt, der das leere Glas sieht, wird dir ein
+volles bringen. Wenn ihr trinket, sollt ihr nicht plappern wie
+die, die meinen, sie werden nur erhoert, wenn sie viele Worte
+machen. Macht es nicht wie sie, denn euer Wirt weiss, was ihr
+braucht, noch ehe ihr ihn bittet. So sollt ihr trinken: Erhebe
+das Glas und proste deinen Naechsten zu, nimm einen kraeftigen
+Schluck und lobe des Braumeister und sein edles Bier und den Wirt,
+der es ausgeschenkt. Denn wenn ihr Wirt und Brauer preiset, ist
+euch das naechste Bier sicher. Wenn du aber deinen Wirt
+beschimpfst, so gibt es fuer dich kein naechstes Bier.
+
+Ihr habt gehoert, dass gesagt worden ist: Du sollst die Zeche nicht
+prellen. Ich aber sage euch: Wer auch nur einen solchen Gedanken
+hegt, hat in seinem Herzen seinen Wirt schon betrogen. Wenn dich
+dein rechtes Auge zum Boesen verfuehrt, dann rufe den Wirt und
+bestelle ein Bier. Denn es ist besser fuer den Wirt, wenn du ein
+Bier bestellst und nicht die Zeche prellst.
+
+Und es ist gesagt worden: Dein Bier sollst du geniessen, doch nicht
+damit deinen Durst loeschen. Ich aber sage euch: Loesche auch deinen
+Durst mit Bier und hoere nicht auf die Zweifler, die dich vom
+rechten Glaube abbringen wollen. Gib auch den Zweiflern von deinem
+Bier, damit sie ihren Durst loeschen koennen und zum rechten Glauben
+zurueck finden.
+
+Verschuettet nicht euer Bier, denn wie wollt ihr euch an
+verschuettetem Biere laben?
+
+Bittet, dann wird euch gegeben; bestellt, dann wird euch gezapft;
+erhebt das Glas, dann wird euch zugeprostet. Denn wer bittet, der
+empfaengt; wer bestellt, bekommt ein Bier; wer sein Glas erhebt,
+dem wird zugeprostet. Oder ist ein Wirt unter euch, der seinem
+Gaste Wasser bringt, wenn dieser um Bier bittet, oder ein leeres
+Glas reicht, wenn dieser um ein volles bittet?
+
+Alles, was ihr also von anderen erwartet, das tut auch ihnen!
+Bestell ihnen Bier und erhebe das Glas auf ihr Wohl!
+
+Geht durch das enge Tor! Denn das Tor ist weit, das ins Verderben
+fuehrt, und der Weg dahin ist breit und viele gehen auf ihm. Aber
+das Tor, das zum Biergarten fuehrt, ist eng und der Weg dahin ist
+schmal und nur wenige finden ihn.
+
+Huetet euch vor den falschen Bieren; sie kommen zu euch wie edle
+Truenke, in Wirklichkeit aber handelt es sich um Abwaesser. An ihren
+Gebinden werdet ihr sie erkennen. Trinkt man etwa aus hellen
+Flaschen oder gar Dosen? Jedes gute Bier muss in einem guten
+Gebinde lagern, in einem schlechten Gebinde kann nur schlechtes
+Bier lagern. In einem schlechten Gebinde kann kein gutes Bier
+lagern. Jedes Gebinde, dass kein gutes Bier beinhalten kann, sollt
+ihr meiden. An ihren Gebinden werdet ihr die rechten Biere
+erkennen. Nicht jeder, der Bier trinkt, wird daran Freude haben,
+sondern nur der, der das rechte Bier wohl trinkt.
+
+Wer diese meine Worte hoert und danach handelt, ist ein kluger
+Mann, der stets noch ein Bier in seinem Keller hat. Als nun eine
+Duerre kam und die Quellen versiegten, die Sonne brannte und die
+Temperaturen stiegen, so duerstete er nicht, denn er hatte stets
+noch ein Bier in seinem Keller. Wer aber meine Worte hoert und
+nicht danach handelt, ist wie ein unvernuenftiger Mann, der nur
+Plunder in seinem Keller hat. Als nun eine Duerre kam und die
+Quellen versiegten, die Sonne brannte und die Temperaturen
+stiegen, so verdurstete er.
+
+Gruss, Karl
+
+-----------------------------------------------------------------------------
+
+
+
+Der Jungschlips - niedrigste aller Lebensformen (Grimmborn, 26. Apr 2005, 21:27:21):
+
+From: Hans Bonfigt <bonfigt.ses-koeln@t-online.de>
+Subject: Der Jungschlips - niedrigste aller Lebensformen
+Newsgroups: de.alt.sysadmin.recovery
+Date: Sat, 16 Apr 2005 23:17:04 +0200
+Message-ID: <d3rvcd$nh2$00$1@news.t-online.com>
+
+Am Freitag besuchte ich ein "Event" im IBM - Umfeld.  "Naja", hatte
+ich gedacht, besuche die Veranstaltung und, wenn Du schon 'mal ins
+schoene Hornberg musst, dann fahre mit dem Fahrrad hin und mache an-
+schliessend eine kleine Tour durch den Hochschwarzwald".
+
+"Casual wear" ist Usus bei Treffen dieser Art.  Aber der Laden, wo
+ich hin muss, ist ueberraschenderweise keine Produktionsbude, sondern
+ein "Design Center".
+Ich laufe da aber in T-Shirt (immerhin mit zwei winzigen AErmelstum-
+meln), Fahrradhose und Sandalen auf - letztere sind kraeftigst einge-
+dreckelt, der Feinstaub ist halt ueberall.  Schon der abschaetzend -
+entsetzte Blick der versacegestylten Empfangsdaten haette mich stutzig
+machen sollen:  Ich entere das Foyer und sehe mich mindestens 40
+Jungschlipsen gegenueber, die keine Muehe gescheut haben, alles aufzu-
+bieten, was Garderobe und Kleiderschrank zu bieten hatten.  Nicht
+ein einziges Staeubchen truebt die hochglanzpolierten Lacklederschuh-
+spitzen.  Die Manschettenknoepfe blinken mit den Billigbreitlngs um
+die Wette.
+Mann, haben die mich angeglotzt.  Man merkte foermlich, wie sie mit
+dem vom Fahrtwind zerzausten Kopf anfingen, sich kurz bei den il-
+legitimen AErmeln aufhielten und dann, in einer Mischung aus Entsetzen
+und Empoerung, an den Sandalen regelrecht haengenblieben.  Auf mein
+vernehmliches "Guten Morgen" kam nichts zurueck ausser Stille, ledig-
+lich zwei oder drei, die mich kennen, nickten moeglichst unauffaellig,
+um sich nicht zu blamieren.
+Naja, denke ich mir, "Ihr mich auch", und befasse mich ausgiebig
+mit dem Fruehstuecksbuffet.  Die Butterbrezen sind naemlich ausgespro-
+chen lecker und ich habe nach der langen Fahrt ganz gut Hunger.
+Mit jedem Brezen, den ich nachhole (und das sind einige), gucken
+die Schlipsis brueskierter.  "Das kann man toppen", denke ich, nehme
+einen kraeftigen Schluck "Hornberger Mineralwasser" und lasse einen
+kraeftigen Ruelpser krachen:  "Das nennt sich der Legende nach das
+'Hornberger Schiessen', meine Herren", verkuende ich aufgeraeumt.
+Totenstille ist die Folge.  Im anschliessenden Seminar habe ich eine
+ganze Reihe fuer mich.
+
+Und jetzt kommt's:  Mittagspause.  Ich sitz' natuerlich allein an
+einem Tisch, als Vorstandsvorsitzender W. verspaetet einreitet.
+Der ignoriert die Meute, die ihn alsbald begruessen will und bahnt sich
+schnurstracks einen Weg zu mir:  "Oh, das ist aber schoen, dass Sie
+kommen konnten, Herr Bonfigt - darf ich mich zu Ihnen setzen ?"
+Nach dem Mittagessen, wie durch ein Wunder, kennen mich alle.  Und
+gruessen.  In der Kaffeepause am Nachmittag habe ich keine Minute fuer
+mich.  Und auch Mitlaeufer X. entbloedet sich nicht, mich anzuhauen
+mit "Wir haben uns heute morgen ja gar nicht richtig begruesst".
+
+"Kleider machen Leute", o.K., das stimmt zum Teil.  Aber welchen
+Effekt eine simple, fluechtige Bekanntschaft hat, das haette ich im
+Traum nicht fuer moeglich gehalten.
+
+Zurueck blieb bei mir ein gewisser Ekel und auch ein gehoeriges Mass
+an Beklemmung.  Den mentalen 'Schlipstraeger-Score' habe ich auf
+jeden Fall noch mal gehoerig nach unten angepasst.
+
+
+
+Gruss Hans
+
+p.s.:
+Innerhalb weniger Stunden hatten die "feinen Pinkel" es geschafft,
+das morgens blitzsaubere Klo bis zur Unbenutzbarkeit zuzuschiffen.
+
+-----------------------------------------------------------------------------
+
+
+
+Mal wieder was... (Ronda, 23. Mai 2005, 00:17:39):
+... fuer diese Rubrik...
+
+[SN: Gekuerzt auf das nette ENde.]
+
+From: Johann Hrebicek <JoHrebi@web.de>
+Newsgroups: t-online.talk.allgemein
+Subject: Re: Congster Spezialflat ... Haken?
+Date: Wed, 18 May 2005 19:57:06 +0200
+Message-ID: <2107822.76izYA46Kv@johrebi.dyndns.org>
+
+T-Online-Team schrieb:
+
+[...]
+
+
+>> Ist allerdings Pech fuer die Musikindustrie, dass Moses die dritte Tafel, 
+>> auf der das Verbot der digitalen Kopie ausgefuehrt wurde, beim Abstieg vom 
+>> Berg Sinai zerdepperte. <g>  
+
+
+Vermutlich ist er ueber DRM gestolpert. <eg>
+
+Johann
+
+-----------------------------------------------------------------------------
+
+
+
+Matrix - Die Zusammenfassung (Ronda, 23. Mai 2005, 00:24:53):
+Message-ID: <d6c2bq$uff$1@news2.rz.uni-karlsruhe.de>
+From: Thomas Kersten <kepheus2nd@gmx.net>
+Newsgroups: de.rec.film.misc
+Subject: Re: Star Wars - Welche Reihenfolge
+Date: Tue, 17 May 2005 08:18:34 +0200
+
+Michael Adler wrote:
+
+>> Ich hab am WE mit meiner Freundin Matrix gesehen, von dem sie vorher nur 
+>> wusste, das dort jemand mit einem schwarzen Mantel rumlaeuft ;)
+
+
+Schoene Ein-Satz-Zusammenfassung der gesamten Trilogie ;-)
+
+Thomas
+
+-----------------------------------------------------------------------------
+
+
+
+Frauen fahren Auto... (Nonne, 10. Jun 2005, 10:25:55):
+Ab 1.6.05  wieder 0,8 Promille:
+
+Die 0,5 Promille-Grenze  wird wieder aufgehoben. Ab dem 1. Juni 05
+betraegt fuer Autofahrer der zulaessige  Alkoholgrenzwert wieder 0.8
+Promille.
+
+Wie eine gesamtschweizerische Studie der ETH Zuerich  ergeben hat, hat
+die Unfallhaeufigkeit seit Einfuehrung der 0,5 %o-Grenze stark zugenommen.
+Auffaellig sei, dass speziell zur spaeten Stunde und an Wochenenden,  die
+mittel- bis schweren Unfaelle eine noch nie dagewesene Zahl erreichten.
+Abklaerungen der Polizei haben ergeben, dass die Ursache darin liege,
+dass seit  dem 1. Januar die Maenner nicht mehr alkoholisiert heimfahren,
+sondern sich von  ihren Frauen abholen lassen.
+
+Quelle: NZZ vom 23.04.2005
+
+Nonne, hats immer gewusst.
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Frauen fahren Auto... (Catweazle, 10. Jun 2005, 10:46:31):
+~#! rn=Nonne rt=1118391955 rg=schmarrn.netdigest
+~#! tid=1118391955
+Fake, oder?
+
+YTC
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Frauen fahren Auto... (Croft, 10. Jun 2005, 10:49:55):
+~#! rn=Catweazle rt=1118393191 rg=schmarrn.netdigest
+~#! tid=1118391955
+Ja. 
+
+Croft
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Frauen fahren Auto... (Wurzel, 10. Jun 2005, 11:03:31):
+~#! rn=Croft rt=1118393395 rg=schmarrn.netdigest
+~#! tid=1118391955
+obwohl, den schweizern traue ich fast alles zu... mal zook fragen :)
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: Frauen fahren Auto... (Nonne, 10. Jun 2005, 11:04:43):
+~#! rn=Wurzel rt=1118394211 rg=schmarrn.netdigest
+~#! tid=1118391955
+Habe mal bei der NZZ im Archiv gesucht, aber nichts gefunden, scheint ein Fake
+zu sein. Aber gelacht habe ich doch :-)
+
+-----------------------------------------------------------------------------
+
+
+
+Re^5: Frauen fahren Auto... (Maharet, 10. Jun 2005, 12:24:05):
+~#! rn=Nonne rt=1118394283 rg=schmarrn.netdigest
+~#! tid=1118391955
+Dass so alte Witze immer noch Leute zum Lachen bringen koennen ...
+
+-----------------------------------------------------------------------------
+
+
+
+Re^6: Frauen fahren Auto... (Anthea, 10. Jun 2005, 12:25:22):
+~#! rn=Maharet rt=1118399045 rg=schmarrn.netdigest
+~#! tid=1118391955
+Genau wie http://www.frau-am-steuer.de/
+
+-----------------------------------------------------------------------------
+
+
+
+Re^7: Frauen fahren Auto... (Maharet, 10. Jun 2005, 12:38:29):
+~#! rn=Anthea rt=1118399122 rg=schmarrn.netdigest
+~#! tid=1118391955
+Nene, wieviel Aufwand sich manche machen.  Gibt es dann da wirklich so viele
+streitige Diskussionen?  Ich hab bisher immer nur Maenner erlebt, die das
+Thema immer wieder aufbringen, und wenn, dann waren es auch nur Maenner, die
+dagegen argumentiert haben.
+Es muss also wirklich was ganz grundlegendes bei den Kerlen ansprechen ;) 
+Aber schon traurig, dass sie ihren Stolz nicht aus anderen Faehigkeiten
+ableiten (koennen).  Schaetzen wir die Maenner fuer die falschen Qualitaeten?
+
+-----------------------------------------------------------------------------
+
+
+
+Re^8: Frauen fahren Auto... (Grimmborn, 10. Jun 2005, 12:41:57):
+~#! rn=Maharet rt=1118399909 rg=schmarrn.netdigest
+~#! tid=1118391955
+Das Thema loest bei Maennern tiefsitzende Konflikte aus: Sie stehen mit dem
+Wagen vor der Luecke und wuenschen sich auf einmal, sie haetten einen
+*kuerzeren*. In dieser unaufloesbaren Konfliktsituation kommt es dann zu einer
+Uebersprunghandlung, um auf Kosten der Frauen wenigstens einen Teil des
+Selbstwertgefuehls wieder aufzurichten. 
+
+GdA
+
+-----------------------------------------------------------------------------
+
+
+
+Re^8: Frauen fahren Auto... (Gwenili, 10. Jun 2005, 12:42:13):
+~#! rn=Maharet rt=1118399909 rg=schmarrn.netdigest
+~#! tid=1118391955
+klick mal auf "Notausgang", maha ;)
+gwen.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^8: Frauen fahren Auto... (Nonne, 13. Jun 2005, 09:38:07):
+~#! rn=Maharet rt=1118399909 rg=schmarrn.netdigest
+~#! tid=1118391955
+Fuer welche Qualitaeten schaetzt ihr die Maenner denn?
+
+-----------------------------------------------------------------------------
+
+
+
+Re^9: Frauen fahren Auto... (Grimmborn, 13. Jun 2005, 09:39:49):
+~#! rn=Nonne rt=1118648287 rg=schmarrn.netdigest
+~#! tid=1118391955
+Bist Du sicher dass Du auf diese Frage eine Antwort haben willst? Ganz sicher?
+Wirklich?
+
+GdA
+
+-----------------------------------------------------------------------------
+
+
+
+Re^10: Frauen fahren Auto... (Nonne, 13. Jun 2005, 09:44:44):
+~#! rn=Grimmborn rt=1118648389 rg=schmarrn.netdigest
+~#! tid=1118391955
+Da ich mein Selbstbewusstsein nicht aus dem Autofahren ziehen (habe nicht mal
+eins), bin ich mir ganz sicher, ja. Ich werde die Antwort verkraften muessen.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^11: Frauen fahren Auto... (Zook, 13. Jun 2005, 10:11:46):
+~#! rn=Nonne rt=1118648684 rg=schmarrn.netdigest
+~#! tid=1118391955
+Ich behaupte ja immer, ich sei ein schlechter Autofahrer...
+
+Zook.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^12: Frauen fahren Auto... (Muadib, 13. Jun 2005, 10:13:02):
+~#! rn=Zook rt=1118650306 rg=schmarrn.netdigest
+~#! tid=1118391955
+in welche richtung fischst du gerade?
+soll man dir widersprechen oder recht geben?
+
+-----------------------------------------------------------------------------
+
+
+
+Re^12: Frauen fahren Auto... (Wurzel, 13. Jun 2005, 10:14:12):
+~#! rn=Zook rt=1118650306 rg=schmarrn.netdigest
+~#! tid=1118391955
+das ist immer eine frage der kriterien fuer gut oder schlecht.
+ich behaupte immer, michael schumacher sei ein schlechter autofahrer, weil
+er wenig umweltschonend faehrt. wenn es allerdings wichtig ist, schnell zu
+fahren, mag ein anderer massstab anliegen.
+warum man allerdings moeglichst schnell immer im kreis fahren muss, entzieht
+sich meinem verstaendnis.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^13: Frauen fahren Auto... (Zook, 13. Jun 2005, 10:14:26):
+~#! rn=Muadib rt=1118650382 rg=schmarrn.netdigest
+~#! tid=1118391955
+Ich stehe dazu, kein guter Autofahrer zu sein. Punkt.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^14: Frauen fahren Auto... (Grimmborn, 13. Jun 2005, 10:15:42):
+~#! rn=Zook rt=1118650466 rg=schmarrn.netdigest
+~#! tid=1118391955
+Immer noch besser als kein Selbstbewusstsein zu haben wie Nonne.
+
+GdA
+
+-----------------------------------------------------------------------------
+
+
+
+Re^15: Frauen fahren Auto... (Gloinson, 13. Jun 2005, 10:56:14):
+~#! rn=Grimmborn rt=1118650542 rg=schmarrn.netdigest
+~#! tid=1118391955
+Ich bin ein passabler Autofahrer, wenn ich erstmal wieder ein paar hundert
+Kilometer gefahren bin. Da ich so gut wie nie fahre, bin ich ein schlechter
+Autofahrer. Koennen wir den Thread jetzt zurueckmigrieren wo er hingehoert? ;)
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^16: Frauen fahren Auto... (Wurzel, 13. Jun 2005, 10:57:22):
+~#! rn=Gloinson rt=1118652974 rg=schmarrn.netdigest
+~#! tid=1118391955
+mach doch. tu dir keinen zwang an.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^17: Frauen fahren Auto... (Nonne, 13. Jun 2005, 11:03:42):
+~#! rn=Wurzel rt=1118653042 rg=schmarrn.netdigest
+~#! tid=1118391955
+Ich haette aber vorher gerne noch eine Antwort auf meine Frage.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^18: Frauen fahren Auto... (Wurzel, 13. Jun 2005, 11:05:06):
+~#! rn=Nonne rt=1118653422 rg=schmarrn.netdigest
+~#! tid=1118391955
+ich wuerde dir ja antworten, aber das ist wohl nicht das was du hoeren
+willst. musst du auf maha warten.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^19: Frauen fahren Auto... (Nonne, 13. Jun 2005, 11:10:44):
+~#! rn=Wurzel rt=1118653506 rg=schmarrn.netdigest
+~#! tid=1118391955
+Du koenntest mir antworten, wenn du zu der von Maharet als 'wir' bezeichneten
+Gruppe gehoertest. Ich mutmasse mal, dass sie damit Frauen meint, womit ich du
+nicht dazugehoertest. Aber Maharet ist ja anwesent, vielleicht hat sie den
+Thread noch nicht uebergangen.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^20: Frauen fahren Auto... (Maharet, 13. Jun 2005, 12:10:07):
+~#! rn=Nonne rt=1118653844 rg=schmarrn.netdigest
+~#! tid=1118391955
+ihre Haende, ihren Bartwuchs, ihren hinreissenden Sinn fuer Romantik, ihre
+Faehigkeit zu schwaengern, ihre Faehigkeit, dies ggf auch ohne den schreienden
+Erfolg zu tun, ihre Muskelkraft, ohne die ich manchmal verdurstet waere, die
+tiefe Stimme, die Form ihres Hinterns (naja, bei einigen zumindest, aber da
+Nonne gefragt hatte ;), ihre Fuersorglichkeit, ...
+
+-----------------------------------------------------------------------------
+
+
+
+Re^21: Frauen fahren Auto... (Grimmborn, 13. Jun 2005, 12:11:13):
+~#! rn=Maharet rt=1118657407 rg=schmarrn.netdigest
+~#! tid=1118391955
+Ah, I see. Und jetzt bitte nochmal ohne Ironie...
+
+GdA
+
+-----------------------------------------------------------------------------
+
+
+
+Re^22: Frauen fahren Auto... (Wurzel, 13. Jun 2005, 12:12:31):
+~#! rn=Grimmborn rt=1118657473 rg=schmarrn.netdigest
+~#! tid=1118391955
+interessant, dass schon wieder zuerst die haende genannt werden. irgendwo
+habe ich mal gelesen, dass zwei drittel der frauen zuerst auf die haende
+sehen bei maennern. versteh ich nicht.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^23: Frauen fahren Auto... (Maharet, 13. Jun 2005, 12:13:17):
+~#! rn=Wurzel rt=1118657551 rg=schmarrn.netdigest
+~#! tid=1118391955
+Ich bin seit einem halben Jahr erst verheiratet und immer noch gluecklich. Das
+war nicht ironisch, ehrlich :)
+
+-----------------------------------------------------------------------------
+
+
+
+Re^24: Frauen fahren Auto... (Grimmborn, 13. Jun 2005, 12:13:39):
+~#! rn=Maharet rt=1118657597 rg=schmarrn.netdigest
+~#! tid=1118391955
+Naja, ich sehe bei einer Frau ja auch zuerst auf die.... Haende. Und die
+Augen, klar...
+
+GdA
+
+-----------------------------------------------------------------------------
+
+
+
+Re^25: Frauen fahren Auto... (Maharet, 13. Jun 2005, 12:14:39):
+~#! rn=Grimmborn rt=1118657619 rg=schmarrn.netdigest
+~#! tid=1118391955
+Oh, ich seh nicht als erstes auf die Haende.  Ich meine jetzt auch nicht
+unbedingt das Aussehen - obwohl es ja sehr schoene Maennerhaende gibt.  Es ist
+mehr das, wie sie sich anfuehlen. 
+
+-----------------------------------------------------------------------------
+
+
+
+Re^24: Frauen fahren Auto... (Wurzel, 13. Jun 2005, 12:14:55):
+~#! rn=Maharet rt=1118657597 rg=schmarrn.netdigest
+~#! tid=1118391955
+altes chinesisches sprichwort:
+wenn du einen tag lang gluecklich sein willst, erfuelle dir einen lange
+gehegten wunsch.
+wenn due eine woche lang gluecklich sein willst, heirate.
+wenn du ein leben lang gluecklich sein willst, werde gaertner.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^25: Frauen fahren Auto... (Maharet, 13. Jun 2005, 12:15:27):
+~#! rn=Wurzel rt=1118657695 rg=schmarrn.netdigest
+~#! tid=1118391955
+Ich habe einen Gaertnersohn geheiratet. Das ist ein guter Kompromiss.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^25: Frauen fahren Auto... (Darklor, 13. Jun 2005, 12:15:37):
+~#! rn=Wurzel rt=1118657695 rg=schmarrn.netdigest
+~#! tid=1118391955
+Wieso Gaertner?
+
+Darklor
+
+-----------------------------------------------------------------------------
+
+
+
+Re^26: Frauen fahren Auto... (Gloinson, 13. Jun 2005, 12:15:49):
+~#! rn=Darklor rt=1118657737 rg=schmarrn.netdigest
+~#! tid=1118391955
+Ich achte bei Frauen eher auf das Gesamtbild. Die einzelen Features muessen in
+Proportion sein.
+Das kann man verbinden, Wurzel. Mein Vater gaertnert mittlerweile sehr viel.
+Wieder.
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^27: Frauen fahren Auto... (Muadib, 13. Jun 2005, 12:44:58):
+~#! rn=Gloinson rt=1118657749 rg=schmarrn.netdigest
+~#! tid=1118391955
+ich bin nach aussage anderer kein guter autofahrer, weil ich angeblich zu
+aggressiv fahre, zu schnell fahre und zu spaet bremse
+ich seh das anders
+
+-----------------------------------------------------------------------------
+
+
+
+Re^28: Frauen fahren Auto... (Wurzel, 13. Jun 2005, 12:45:40):
+~#! rn=Muadib rt=1118659498 rg=schmarrn.netdigest
+~#! tid=1118391955
+was macht einen "guten" autofahrer aus?
+
+-----------------------------------------------------------------------------
+
+
+
+Re^29: Frauen fahren Auto... (Muadib, 13. Jun 2005, 12:51:10):
+~#! rn=Wurzel rt=1118659540 rg=schmarrn.netdigest
+~#! tid=1118391955
+ich weiss es nicht
+darum ist es fuer mich auch einfacher geradeaus borniert anderer meinung zu
+sein
+ignoranz ist ein ziemlich schlagendes argument
+
+-----------------------------------------------------------------------------
+
+
+
+Re^28: Frauen fahren Auto... (Zook, 13. Jun 2005, 13:37:58):
+~#! rn=Muadib rt=1118659498 rg=schmarrn.netdigest
+~#! tid=1118391955
+ich habe dich schon anders fahren erlebt. zook.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^29: Frauen fahren Auto... (Muadib, 13. Jun 2005, 13:38:24):
+~#! rn=Zook rt=1118662678 rg=schmarrn.netdigest
+~#! tid=1118391955
+ja
+manchmal gibt es ausnahmen
+vor allem wenn ich todmuede bin
+
+-----------------------------------------------------------------------------
+
+
+
+Re^30: Frauen fahren Auto... (Zook, 13. Jun 2005, 13:39:00):
+~#! rn=Muadib rt=1118662704 rg=schmarrn.netdigest
+~#! tid=1118391955
+dann bremst du noch spaeter?
+
+-----------------------------------------------------------------------------
+
+
+
+Re^31: Frauen fahren Auto... (Boing, 13. Jun 2005, 15:30:26):
+~#! rn=Zook rt=1118662740 rg=schmarrn.netdigest
+~#! tid=1118391955
+Wahrscheinlich standet ihr im Stau ... da ist Muadib dann ein sehr
+ruhiger Autofahrer. :)
+  Boing
+
+-----------------------------------------------------------------------------
+
+
+
+Re^32: Frauen fahren Auto... (Zook, 13. Jun 2005, 15:32:58):
+~#! rn=Boing rt=1118669426 rg=schmarrn.netdigest
+~#! tid=1118391955
+Koennte eine Loesung sein. Aber ich sass gar nicht mit ihm in einem Wagen.
+Er fuhr vor oder hinter mir oder so.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^33: Frauen fahren Auto... (Boing, 13. Jun 2005, 15:34:30):
+~#! rn=Zook rt=1118669578 rg=schmarrn.netdigest
+~#! tid=1118391955
+Immerhin hat er in meiner Gegenwart noch keine Baustellenmarkierungen
+umgefahren. Da haben ihm andere Kollegen was voraus :)
+  Boing
+
+-----------------------------------------------------------------------------
+
+
+
+Re^34: Frauen fahren Auto... (Humni, 13. Jun 2005, 15:47:26):
+~#! rn=Boing rt=1118669670 rg=schmarrn.netdigest
+~#! tid=1118391955
+Ein guter Autofahrer...
+
+* faehrt vorausschauend (da vorne in die Luecke pass ich, mach dem
+Hintermenschen Platz, und komm noch vor dem LKW wieder raus....)
+* faehrt darum zuegig, und trotzdem sicher
+* faehrt darum mit relativ geringem Spritverbrauch
+
+Uebrigens behaupte ich nach wie vor, dass sich die Guete eines Autofahrers
+nicht am Auto zeigt. Ich behaupte sogar, dass man wenn man nur
+200PS++-Schlitten faehrt, nicht unbedingt ein besserer Autofahrer wird. Wenn
+man aus einem recht kleinen Auto viel rausholt und seine Grenzen kennt ist man
+in meinen Augen ein guter Autofahrer. Wenn man das nur mit "linker Spur
+blockieren" und grossen Schlitten und hohem Verbrauch kann, nicht.
+
+So seh ich das. Und ja, ich hatte noch keinen Wagen mir 100 PS oder mehr..
+darum diese eingeschraenkte Sichtweise.
+
+Humni
+
+-----------------------------------------------------------------------------
+
+
+
+Re^35: Frauen fahren Auto... (Grimmborn, 13. Jun 2005, 15:50:40):
+~#! rn=Humni rt=1118670446 rg=schmarrn.netdigest
+~#! tid=1118391955
+Nach meiner bescheidenen (Autobahn)Erfahrung sind die wirklich schlimmen
+Selbstmoerder meist mit Audi oder Passat unterwegs. Mercedes S-Klasse, BMW 7er
+und Phaeton sind mir ueberwiegend als ueberraschend zivil aufgefallen. Ist ja
+auch eigentlich verstaendlich: die muessen sich nichts mehr beweisen. Es sind
+immer die kleinen Hunde, die agressiv versuchen mit den grossen mitzupinkeln.
+Und dabei regelmaessig umkippen, wenn sie das Bein heben.
+
+GdA
+
+-----------------------------------------------------------------------------
+
+
+
+Re^36: Frauen fahren Auto... (Zook, 13. Jun 2005, 15:52:51):
+~#! rn=Grimmborn rt=1118670640 rg=schmarrn.netdigest
+~#! tid=1118391955
+Du begegnest VW Foeten? Ich dachte, mehr als die drei Regierungskutchen
+haben die nicht hergestellt....
+
+Ich meine uebrigens festgestellt zu haben, dass die Aggressivitaet auch
+irgendwie von der Autobahn abhaengt... Auf der A5 Richtung Sueden meine
+ich begegne ich mehr aggressiveren Autofahrern (ok, da in der Naehe wohnt
+ja auch Muadib ;))) als z.B. auf der A4 nach Dresden (auch da kann man
+teilweise ohne Geschwindigkeitsbeschraenkung fahren).
+
+Zook.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^36: Frauen fahren Auto... (Gloinson, 13. Jun 2005, 15:53:15):
+~#! rn=Grimmborn rt=1118670640 rg=schmarrn.netdigest
+~#! tid=1118391955
+Mein bestes Erlebnis mit mehr als 100 PS: Tchechische Autobahn, unser
+Reiskocher hat 112 PS, reicht um meine Maximalstandardgeschwindigkeit mit dem
+Auto, also konstant 160 zu fahren. Ein 3er BMW kann da nicht ganz mit. Berg
+runter: an uns vorbei, Berg hoch: wir an ihm vorbei ... das ging so sicher 30
+Kilometer.
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^35: Frauen fahren Auto... (Wurzel, 13. Jun 2005, 15:53:59):
+~#! rn=Humni rt=1118670446 rg=schmarrn.netdigest
+~#! tid=1118391955
+es ist meiner meinung nach fuer die sicherheit egal, was man fuer ein auto
+faehrt, solange man seine grenzen kennt. ich bin frueher auch nur kleine und
+ganz kleine gurken gefahren, das aendert aber nichts grundsaetzliches an der
+fahrweise. uebrigens, wer einen kleinwagen auf ordentliche geschwindigkeit
+bringt, faehrt auch nicht viel sparsamer. mein mercedes heute verbraucht
+deutlich weniger als mein alter kaefer frueher.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^37: Frauen fahren Auto... (Zook, 13. Jun 2005, 15:55:17):
+~#! rn=Gloinson rt=1118670795 rg=schmarrn.netdigest
+~#! tid=1118391955
+darf man in tschechien so schnell fahren?
+
+-----------------------------------------------------------------------------
+
+
+
+Re^38: Frauen fahren Auto... (Gloinson, 13. Jun 2005, 15:56:01):
+~#! rn=Zook rt=1118670917 rg=schmarrn.netdigest
+~#! tid=1118391955
+Zu dem Zeitpunkt durfte man auf der Autobahn das noch, ja. Ein halbes Jahr
+spaeter nicht mehr.
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^37: Frauen fahren Auto... (Cornholio, 13. Jun 2005, 17:50:22):
+~#! rn=Gloinson rt=1118670795 rg=schmarrn.netdigest
+~#! tid=1118391955
+Soso. Da gibt es bestimmt so ein paar 3er (auch aeltere E30!),
+die da sehr wohl mitkommen wuerden.
+Ein 3er ist ein 3er ist ein 3er? :) (da sind wir wieder bei der Dreiigkeit)
+
+-----------------------------------------------------------------------------
+
+
+
+Re^38: Frauen fahren Auto... (Zook, 13. Jun 2005, 17:50:42):
+~#! rn=Cornholio rt=1118677822 rg=schmarrn.netdigest
+~#! tid=1118391955
+watwillst?
+
+-----------------------------------------------------------------------------
+
+
+
+Re^39: Frauen fahren Auto... (Gloinson, 13. Jun 2005, 17:51:26):
+~#! rn=Zook rt=1118677842 rg=schmarrn.netdigest
+~#! tid=1118391955
+Schwanz vergleichen will er.
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^23: Frauen fahren Auto... (Kadabra, 13. Jun 2005, 23:34:12):
+~#! rn=Wurzel rt=1118657551 rg=schmarrn.netdigest
+~#! tid=1118391955
+Wurzel, mit Deiner Erfahrung solltest Du das aber verstehen .... ;-D 
+Geht halt um Haptik ... 
+
+-----------------------------------------------------------------------------
+
+
+
+Re^35: Frauen fahren Auto... (Fondor, 15. Jun 2005, 14:21:36):
+~#! rn=Humni rt=1118670446 rg=schmarrn.netdigest
+~#! tid=1118391955
+Also auf den Punkt gebracht: Es kommt nicht auf die PS-Zahl des Autos an,
+sondern wie man damit umgeht, Humni? Oh die Analogien!
+
+-----------------------------------------------------------------------------
+
+
+
+Du weisst, dass du im Jahr 2005 bist, wenn ... (Rangorn, 22. Jun 2005, 12:11:05):
+Du weisst, dass du im Jahr 2005 bist, wenn ...
+
+1) Du unabsichtlich Deine PIN-Nummer in die Mikrowelle eingibst.
+
+2) Du schon seit Jahren Solitaer nicht mehr mit richtigen Karten gespielt
+hast.
+
+3) Du eine Liste mit 15 Telefonnummern hast, um Deine Familie zu erreichen,
+die aus 3 Personen besteht.
+
+4) Du ein Mail an Deinen Kollegen schickst, der direkt neben Dir sitzt.
+
+5) Du den Kontakt zu Freunden verloren hast, weil sie keine E-mail Adresse
+haben.
+
+6) Du nach einem langen Arbeitstag nach Hause kommst und Dich mit Firmenname
+am Telefon meldest.
+
+7) Du auf Deinem Telefon zu Hause die Null whlst, um ein Amt zu bekommen.
+
+8) Du seit 4 Jahren auf Deinem Arbeitsplatz bist, allerdings f|r 3
+verschiedene Firmen.
+
+10) Alle Fernsehwerbungen eine Web-Adresse am Bildschirmrand zeigen.
+
+11) Du Panik bekommst, wenn Du ohne Handy aus dem Haus gehst und umdrehst, um
+es zu holen.
+
+12) Du morgens aufstehst und erstmal Outlook/LotusNotes aufmachst, bevor Du
+Kaffee trinkst.
+
+13) Du den Kopf neigst, um zu laecheln ;-)
+
+14) Du diesen Text liest und grinst.
+
+15) Schlimmer noch, Du bereits weisst, wem Du die Mail weiterleitest.
+
+16) Du zu beschaeftigt bist, um festzustellen, dass in dieser Liste die 9
+fehlt.
+17) Du die Liste jetzt nochmal durchgehst, um nachzuschauen, ob wirklich die 9
+fehlt
+...und jetzt lachst...
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Du weisst, dass du im Jahr 2005 bist, wenn ... (Bambulko, 22. Jun 2005, 16:16:52):
+~#! rn=Rangorn rt=1119435065 rg=schmarrn.netdigest
+~#! tid=1119435065
+4) ist doch noch harmlos. Schlimm wird es erst, wenn man emails an sich selber
+schreibt...
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Du weisst, dass du im Jahr 2005 bist, wenn ... (Zook, 22. Jun 2005, 16:17:20):
+~#! rn=Bambulko rt=1119449812 rg=schmarrn.netdigest
+~#! tid=1119435065
+Passiert mir regelmaessig.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Du weisst, dass du im Jahr 2005 bist, wenn ... (Wurzel, 22. Jun 2005, 16:18:14):
+~#! rn=Zook rt=1119449840 rg=schmarrn.netdigest
+~#! tid=1119435065
+"passiert" mir nicht, sondern mache ich absichtlich. als merker ist das
+absolut okay.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: Du weisst, dass du im Jahr 2005 bist, wenn ... (Ronda, 22. Jun 2005, 23:23:19):
+~#! rn=Wurzel rt=1119449894 rg=schmarrn.netdigest
+~#! tid=1119435065
+Hart wirds nur, wenn man sich selbst auf den Anrufbeantworter spricht oder SMS
+schickt als Merker...
+
+-----------------------------------------------------------------------------
+
+
+
+Re^5: Du weisst, dass du im Jahr 2005 bist, wenn ... (Humni, 22. Jun 2005, 23:26:53):
+~#! rn=Ronda rt=1119475399 rg=schmarrn.netdigest
+~#! tid=1119435065
+Tja. Ich hab damals (da hatte ich ein Uralt-Motorola-Handy ohne Uhr drin)
+meist keine Uhr, aber das Handy dabeigehabt. Also hab ich mir selbst immer von
+meinem Studi-SMS-Guthaben (5 DM im Monat damals) immer selbst eine SMS
+geschickt, da stand dann die Uhrzeit bei, wann die gesendet wurde. Alle haben
+mich fuer bescheuert erklaert. Ich mich auch, funktionierte aber.
+
+Humni
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Du weisst, dass du im Jahr 2005 bist, wenn ... (Bambi, 23. Jun 2005, 10:24:26):
+~#! rn=Bambulko rt=1119449812 rg=schmarrn.netdigest
+~#! tid=1119435065
+Aeh...
+Was ist so schlimm daran, sich selbst e-mails zu schreiben?
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Du weisst, dass du im Jahr 2005 bist, wenn ... (Kellybundy,  1. Jul 2005, 21:43:59):
+~#! rn=Bambulko rt=1119449812 rg=schmarrn.netdigest
+~#! tid=1119435065
+Mache ich oefters.
+Weil ich wichtige setupfiles verschiedener vielbenutzter programme (wie z.B.
+zmud) als Attachment dranhaenge. Mach ich so seit dem letzten Plattencrash.
+Ist vielleicht unelegant, aber effektiv, ausserdem ist man mobil, ohne dass
+man unbedingt seine selbstgebrannte CD-Sammlung dabei haben muss. Einfach aufs
+Mailaccount gehen, setupfiles runterladen auf den lokalen rechner fertig
+
+Bloe^Hndchen
+
+-----------------------------------------------------------------------------
+
+
+
+Star Wars in Braunschweig...? (Ronda,  1. Jul 2005, 23:04:47):
+
+[auf den lustigen Teil gekuerzt]
+
+
+Subject: Re: 75 Festnahmen bei NPD-Demonstration in Braunschweig
+From: Erik Meltzer <ermel-seine-muelltonne@ermel.org>
+Date: Sun, 19 Jun 2005 00:00:57 +0200
+Message-ID: <42B49999.D7985737@ermel.org>
+Newsgroups: arcor.misc
+
+[...]
+
+Selten so gelangweilte Polizisten gesehen.  Von den Nazis 
+sah man nicht viel -- die ganze Stadt war gruenweiss/gruensilber,
+den ollen Hanomag-Lautsprecherwagen der NPD hat man auch eher
+gerochen als gesehen oder gehoert.  Alles in allem sah es
+stark nach einer Polizeidemo aus.
+
+Besonders beeindruckt hat mich die Frage eines Polizisten:
+"Entschuldigung, duerfte ich mal bitte vorbei?"  *Das* hoert man
+sicher nicht allzu haeufig auf Demos ;-)  Spruch des Tages:
+Gegendemonstrant zu Polizist in schwarzer Schutzkleidung mit
+Helm: "Ach Herr Vader, Sie auch hier? Wie nett!"
+
+Liebe Gruesse,
+   Erik.
+
+-----------------------------------------------------------------------------
+
+
+
+Merke: Keine Mordwerkzeuge mit Payback-Karte bezahlen! (Ronda,  1. Jul 2005, 23:08:57):
+From: Andreas Karrer <ak-5e@gmx.ch>
+Subject: Re: Beil
+Newsgroups: de.alt.fan.aldi
+Date: 1 Jun 2005 23:14:36 GMT
+Message-ID: <slrnd9sgas.cln.ak-5e@etna.ee.ethz.ch>
+
+* Peter Ofenbaeck <peter.ofenbaeck@online.de>:
+
+
+>>Priesterin dir nichts getan hat. Du legst das Beil vorsichtig aufs
+>>Laufband. Heute vielleicht nicht, aber irgendwann. Es wird der Tag
+>>kommen, an dem es gut ist, ein Beil zu besitzen.
+
+
+In Winterthur (CH) hat einer ein solches Beil dann entsprechend
+benutzt, Opfer war seine Frau. Vor ein paar Monaten hat er vor Gericht
+auf Totschlag im Affekt plaediert, er habe sich einfach so ein
+herumliegendes Beil gegriffen. Man konnte ihm aber nachweisen (der
+Baumarkt hat ein Kundenbindungsprogramm mit Strichcodekarte), dass er
+das Beil eine halbe Stunde vor dem Mord gekauft hat.
+
+Merke: In solchen Faellen cash bezahlen, keine
+Kundenbindungsprogrammkarte zeigen und Kassenzettel vernichten.
+
+ - Andi
+
+-----------------------------------------------------------------------------
+
+
+
+Freifrau Gabriele Siegberta zu Klaffenstein (Ronda,  1. Jul 2005, 23:14:23):
+From: "Peter Merkel" <pmerkel@lycos.de>
+Newsgroups: de.soc.recht.misc
+Subject: Hundenamen
+Date: Sun, 5 Jun 2005 13:44:25 +0200
+Message-ID: d7uoim$6fd$05$1@news.t-online.com
+
+... oder die Frage, ob ich meinen Hund Graf Hasso nennen darf:
+
+Seit geraumer Zeit wohnt nun eine Familie neben uns, die die
+Abschaffung des Adelsstandes psychisch wohl nicht so ganz
+verkraftet haben.
+
+Das faengt mit dem ueberdimensionierten Familienwappen ueber der
+Haustuere an und setzt sich im Umgang mit der Nachbarschaft fort.
+Wenn ich naemlich mit einem Menschen
+a. nur reden darf, wenn er gerade seinen Gnaedigen hat und
+b. ich selbst dann nur eine Antwort bekomme, wenn ich ihn
+   "Baron" nenne, dann
+a+b. will ich mit diesen Menschen nicht unbedingt reden.
+
+Da mir das ganze aber trotzdem geringfuegig auf den Wecker geht,
+und ich vor kurzem eine Huendin bekam, habe ich mich zum
+Gegenschlag geruestet und die Huendin "Freifrau Gabriele Siegberta
+zu Klaffenstein" genannt und rede sie auch inzwischen darauf an.
+
+Unsere Durchlaucht von Nachbarn, vor allem die dazugehoerige
+Freifrau mit aehnlichem Vor- und Zunamen, fanden das nur
+grenzwertig witzig und beauftragen einen wohl der Familie
+befreundeten Grafen, der an der koeniglich- und kaiserlichen
+Hofakademie die Rechtswissenschaften studiert hat (zu deutsch
+einen Anwalt, dessen komplette Anrede ebenfalls 2/3 des
+Briefbogens fuellt), mich staatsanwaltschaftlich wegen
+Beleidigung in 47 Faellen (naemlich jedes Mal, wenn ich meine Gabi
+beim Namen gerufen habe, inklusive Datum, Uhrzeit und Ort)
+bekannt zu machen.
+
+Da ich selbst nach ausgepraegter Recherche keine Gesetze fand,
+die die missbraeuchliche Verwendung von Adelstiteln bei Tieren
+regeln, bin ich mir nicht so ganz sicher, was ich machen soll:
+- Warten, bis sich der Staatsanwalt tot- oder ausgelacht hat und
+  auf Einstellung des Verfahrens hoffen?
+- selbst einen Anwalt nehmen und schon mal sparen?
+- die Bildzeitung informieren?
+- Gabi einschlaefern lassen und an das Fenster der gnaedigen Frau
+  haengen?
+
+PS: bis auf die letzten beiden Punkte ist das uebrigens alles
+ernst gemeint, auch wenn's womoeglich nicht ganz so klingt.
+
+
+-----------------------------------------------------------------------------
+
+
+
+Kinder und so. (Ronda,  6. Jul 2005, 21:30:29):
+From: Oliver Cromm <lispamateur@internet.uqam.ca>
+Subject: Re: Sollbruchstelle
+Newsgroups: de.etc.sprache.deutsch
+Date: Mon, 4 Jul 2005 17:58:17 -0400
+Message-ID: <pfk5krrotuo6.dlg@ocromm.my-fqdn.de>
+
+...
+
+>> Froh, dass ein Notueberlauf funktioniert hat.
+
+
+Von mir als Fuenfjaehrigem ist die wissenschaftliche Feststellung "Oma,
+dein Waschbecken ist zu klein" ueberliefert, als ich den Hahn nicht
+zukriegte.
+
+-----------------------------------------------------------------------------
+
+
+
+Entwicklung vs. Evaluierung? (Ronda, 15. Jul 2005, 01:05:40):
+From: Oliver Cromm <lispamateur@internet.uqam.ca>
+Subject: Re: Deutsche Uebersetzung gesucht
+Newsgroups: de.etc.sprache.misc
+Date: Thu, 23 Jun 2005 17:22:43 -0400
+Message-Id: <bm3p77p1n4vw$.dlg@ocromm.my-fqdn.de>
+
+* Sayoko69@web.de wrote:
+
+
+>> Ulf Moeller schrieb:
+>>
+>
+>>>> Wenn es um Software geht, sind "Entwicklung" und "Evauluierung" voellig
+>>>> verschiedene Dinge.
+>
+>>
+>> Wo liegt denn der Unterschied?
+
+
+Microsoft hat die Anwendung "Word" entwickelt. Wir haben sie und andere
+Textverarbeitungen evaluiert, dann haben wir uns fuer OpenOffice.org
+entschieden.
+
+-----------------------------------------------------------------------------
+
+
+
+Selbstzerstoerungsknopf (Ronda, 15. Jul 2005, 01:06:55):
+Message-ID: <3fg69kF7i1rlU1@news.dfncis.de>
+Subject: Re: StarWars Episode 3
+From: Oliver Schad <o.schad@web.de>
+Date: Tue, 24 May 2005 10:17:55 +0200
+Newsgroups: de.alt.sysadmin.recovery
+
+Ignatios Souvatzis wrote:
+
+>>Nicholas Preyss <...> writes:
+>
+>>>>Bitte? Die ganze Episode 6 besteht aus Kampfszenen.
+>
+>>
+>>Ah ja. Besonders die, die damals in MAD parodiert wurde:
+>>"Lieber Feind: Genau hier hineinschiessen, bitte, um uns zu sprengen!"
+
+
+Es ist immer ganz wichtig einen grossen roten Selbstzerstoerungsknopf oder 
+aehnlich wirkende Mechanismen an einer unzerstoerbaren Waffe anzubringen, 
+sonst wuerde man sie nicht unzerstoerbar nennen.
+
+Nehmen wir den Reaktor im Todesstern. Der erzeugt soviel Waerme, dass er 
+eine Kuehlung braucht. Und damit genug Aussenluft aus dem Weltraum in den 
+Reaktor hineinstroemt, braucht man Lueftungsschlitze - ganz klar, das weiss 
+jeder Computer-Tuner von zuhause.
+
+Und wenn so eine unzerstoerbare Waffe im Weltraum getroffen wird, was 
+passiert damit? Klar, die stuerzt ab - nach unten, immer weiter nach 
+unten und weiter und weiter, bis diese unzerstoerbare Waffe auf dem Boden 
+des Weltraums aufschlaegt und explodiert.
+
+mfg
+Oli
+
+-----------------------------------------------------------------------------
+
+
+
+Herrje ... (Gloinson, 20. Jul 2005, 18:53:05):
+Die Geschichte dahinter waere interessant.
+
+From: "Andreas R." <rord2@gmx.de>
+Newsgroups: bln.markt
+Subject: V: Brautkleid, ungetragen
+Date: Wed, 20 Jul 2005 18:42:57 +0200
+
+Hi!
+
+Im Auftrag einer Bekannten zu verkaufen:
+
+Brautkleid
+
+ungetragen, in ungeoeffneter Originalverpackung, cremefarben
+Groesse 36, fuer ca. 160-165 cm Koerpergroesse
+
+2-teilig, schulterfrei, bodenlang
+Korsagenoberteil, geschnuert, in der Mitte spitz nach unten abschliessend
+Reifenrock mit eingearbeiteter kurzer Schleppe
+
+2-lagig
+obere Lage transparent mit dezenten Rosenapplikationen (siehe Bild) und 
+drei weissen Rosen (seihe Bild), leicht schimmernd
+untere Lage aus Satin
+
+Gratis dazu:
+passende Handschuhe, kurz, cremefarben
+
+Besichtigung empfohlen fuer Selbstabholer in Berlin
+
+Bilder auch im WWW unter http://anzeige.npx.de
+
+Preis VB: 790 EUR
+
+Rufnummer 08-11 Uhr / 22-23 Uhr:    0172 9310830
+
+Das Kleid wurde nie getragen und befindet sich in ungeoeffneter 
+Originalverpackung!
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Herrje ... (Grimmborn, 20. Jul 2005, 19:00:11):
+~#! rn=Gloinson rt=1121878385 rg=schmarrn.netdigest
+~#! tid=1121878385
+Tja, vielleicht aus einer Geschaeftsaufloesung?
+Und warum postest Du das, hast Du daran Interesse? Kannst ja mal fragen,
+vielleicht verleihen sie das Kleid ja auch...
+
+GdA
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Herrje ... (Gloinson, 20. Jul 2005, 19:01:56):
+~#! rn=Grimmborn rt=1121878811 rg=schmarrn.netdigest
+~#! tid=1121878385
+Ja. Waere eine Idee. Aber ich bin ja arm. Willst du es nicht vielleicht fuer
+deinen naechsten Versuch anschaffen?
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Herrje ... (Grimmborn, 20. Jul 2005, 19:04:26):
+~#! rn=Gloinson rt=1121878916 rg=schmarrn.netdigest
+~#! tid=1121878385
+Danke, kein Interesse. Dann wuerdest Du nur versuchen das von mir zu borgen,
+und so ein Schmarotzer-Ossihaltung will ich da echt nicht unterstuetzen. Aber
+greif Du ruhig zu, sicher ist irgendwann Dein Ringfinger wieder beschwerdefrei
+und dann kannst Dus brauchen. 
+
+GdA
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: Herrje ... (Gloinson, 20. Jul 2005, 19:06:59):
+~#! rn=Grimmborn rt=1121879066 rg=schmarrn.netdigest
+~#! tid=1121878385
+Aber es stuende dir wesentlich besser, es hat wohl auch einen eingebauten
+Heiligenschein. Damit kannst du ja deinen Chef dann auch hin und wieder
+beeindrucken, so zur Abwechslung.
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^5: Herrje ... (Maharet, 20. Jul 2005, 19:08:17):
+~#! rn=Gloinson rt=1121879219 rg=schmarrn.netdigest
+~#! tid=1121878385
+Oh nein! Scotty ist tot!
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Selbstzerstoerungsknopf (Kellybundy, 23. Jul 2005, 12:51:06):
+~#! rn=Ronda rt=1121382415 rg=schmarrn.netdigest
+~#! tid=1121382415
+Vor allem, wos im Weltraum auch so viel Luft gibt *GG*
+
+-----------------------------------------------------------------------------
+
+
+
+PKW vs Drucker... (Ronda, 26. Jul 2005, 00:33:25):
+... vielleicht sollte grad ich das nicht posten... ;-)
+
+Ronda
+
+From: W. H. Greiner <whgreiner@t-online.de>
+Subject: Re: Turbo vs Kompressor?
+Newsgroups: de.etc.fahrzeug.auto
+Date: Wed, 20 Jul 2005 12:59:32 +0200
+Message-ID: <dblaqh$3ga$04$1@news.t-online.com>
+
+Michael Landenberger schrieb in dem Posting 
+<dbk898$iod$1@online.de>:
+
+
+>>Apropos Franzose: Letztens habe ich von einem Kfz-Meister gehoert, dass eine
+>>simple Druckleitung fuer die Servolenkung eines 2 Jahre alten Nissan als 
+>>Ersatzteil ueber 400 Euro kosten soll. 
+
+
+Es kommt die Zeit, da laeuft das wie Druckern und Beamern: Neuwagen mit
+allen Schikanen fuer 500 Euro - aber tanken kann man nicht mehr an der
+Tankstelle, sondern nur noch in der Markenwerkstatt unter Austausch
+des kompletten, verplombten Originaltanks samt Inhalt fuer 500 Euro.
+Die Reifen kann man natuerlich dann auch nicht mehr einfach
+austauschen, man kriegt sie nur noch als komplettes Original-Ersatzrad
+fuer 500 Euro das Stueck. Und selbstverstaendlich enthaelt die
+Erstausstattung ab Werk nur 20 Liter Benzin und Reifen mit 1,5 mm
+Profil. Elektronik sorgt dafuer, dass bei Verwendung von Fremdtanks oder
+Fremdraedern der Motor streikt bzw. die Bremsen nicht mehr
+funktionieren...
+
+Gruss, Walter
+
+-----------------------------------------------------------------------------
+
+
+
+Nochwas zu PKW(s) (Ronda, 26. Jul 2005, 00:35:49):
+From: Michael Hemmer <me2@privacy.net>
+Subject: Re: Mehrzahl von "Mercedes"
+Newsgroups: de.etc.sprache.deutsch
+Date:Tue, 19 Jul 2005 23:30:45 +0200
+Message-ID: <42dd70bf$0$16487$9b4e6d93@newsread4.arcor-online.net>
+
+[SN: Zitat ergaenzt und umgestellt]
+
+
+>>>>>>>> wie bringt man korrekt zum Ausdruck, dass man 2 Fahrzeuge der Marke
+>>>>>>>> "Mercedes" hat?
+
+
+>>>>>>>> Ich habe 2 Merceden?
+>>>>>>>> Ich habe 2 Mercedes?
+>>>>>>>> Klingt alles irgendwie komisch.
+
+
+>>>>>>Klar, es heisst ja auch "zwei Benze" :-)
+
+
+>>>>>>In einem googlenotorischen Witz schreibt sich das mit zwei "s":
+>>>>>>Was gibt es, wenn zwei Mercedesse zusammenstossen? - Krieg der Sterne.
+
+
+
+>>>> Ich glaub, ich kauf lieber VW. Da bin ich mit "zwei Volkswaegen" 
+>>>> grammatikalisch auf der absolut sicheren Seite.
+
+ 
+
+>> Ja genau, auch ich fahre nicht ohne Grund immer Goelfe!
+
+
+Gut, da koennen wir doch schon mal eine kleine Tabelle machen:
+
+    Einzahl           Mehrzahl
+    -------------------------------------
+    Mercedes          Mercedes[[s]e]
+    Volkswagen        Volkswaegen
+    Golf              Goelfe
+    Fiat Uno          Fiat Multipla
+
+-----------------------------------------------------------------------------
+
+
+
+Re: PKW vs Drucker... (Marcus, 26. Jul 2005, 12:22:53):
+~#! rn=Ronda rt=1122330805 rg=schmarrn.netdigest
+~#! tid=1122330805
+Nein,
+
+Das Equivalent waere ...
+
+Anstatt nur das Benzin zu tanken wir der komplette Motor mit eigenem Tank
+und fuer den Motor optimiertes Hochleistungsbenzin ausgewechselt.
+
+Manchmal ist der Tank auch nur halbvoll.
+
+Ciao, Marcus
+
+-----------------------------------------------------------------------------
+
+
+
+Die Steuer und so... (Ronda, 30. Jul 2005, 23:23:56):
+From: Alexander Gottwald <ago@odoaker.hrz.tu-chemnitz.de>
+Newsgroups: de.alt.folklore.urban-legends
+Subject: Re: =?iso-8859-1?Q?R=E4uberpistole?=
+Date: Thu, 28 Jul 2005 15:27:33 +0000 (UTC)
+Message-ID: <dcath5$fsl$2@anderson.hrz.tu-chemnitz.de>
+
+[SN: Quoting ergaenzt]
+
+Lothar Frings wrote:
+
+
+>> Christian Gramsch tat kund:
+
+
+>>> > Gerade bin ich im NEON-Magazin auf einen Artikel gestossen:
+>>> > 
+>>> > ---
+>>> > 
+>>> > Raeuberpistole
+>>> > 
+>>> > In Holland hat ein Bankraeuber seine Tatwaffe von der Steuer abgesetzt.
+>>> > Ein Selbststaendiger darf Invesitionen zur Ausuebung der
+Erwerbstaetigkeit
+>>> > steruerlich absetzen: einen Bueroschrank, Miet- oder Fahrtkosten. Was
+>>> > eben so anfaellt. Im hollaendischen Roermond hat ein 46-Jaehrigernun
+>>> > erfolgreich sein 2000 Euro teures Arbeitsgeraet, eine Pistole, geltend
+>>> > gemacht. Eine zugegeben sinnvolle Investition fuer einen Bankueberfall.
+>>> > Der empoerten Oeffentlichkeit erklaerte das Justizministerium: Sobald
+ein
+>>> > Gericht befugt sei, illegale Gewinne zu beschlagnahmen - der Mann wurde
+>>> > zur Beuterueckgabe und vier Jahren Knast verurteilt - koenne der Taeter
+die
+>>> > entstandenen Aufwendungen deklarieren. Die Anschaffungskosten fuer die
+>>> > Pistole wurden mit dem Gewinn aus dem Ueberfall verrechnet.
+>>> > Justizminister Piet Hein Donner erlaeuterte auf Nachfrage, dass aber nur
+>>> > die Kosten beruecksichtigt wurden, "die nicht angefallen waeren, wenn
+die
+>>> > Straftat nicht begangen worden waere, und die in direkter Verbindung mit
+>>> > der Vollendung des Delikts stehen." Eine interessante Logik: Die Pistole
+>>> > kaufen, aber nur steuerlich ab- und nicht beruflich einzusetzen, waere
+>>> > kriminell gewesen.
+>>> > 
+>>> > Gordon Detels
+>>> >
+>
+>> 
+>> Wuerde in Deutschland nicht gehen wegen privater Nutzbarkeit.
+>> Er koennte damit ja auch seine Frau aus dem Weg raeumen.
+
+
+Aber nur anteilig. Seine Frau kannst er nur einmal erschiessen, aber
+mehrere Banken ausrauben. Loesung: Fahrtenb^WSchiesskladde
+
+SCNR
+ago 
+
+-----------------------------------------------------------------------------
+
+
+
+Political correct? Egal ;-) (Ronda, 10. Aug 2005, 23:30:37):
+From: Timo von Burg <timo.von.burg@mymail.ch>
+Subject: Re: Hirnlose Gedankenstriche
+Newsgroups: de.etc.sprache.deutsch
+Date:Sun, 07 Aug 2005 20:21:57 +0200
+Message-ID: <42f65137$0$18643$14726298@news.sunsite.dk>
+
+[SN: Auszeichnungen von mir]
+
+
+>> (Und wenn wir gerade bei der Politik sind: Es erheitert mich doch
+>> sehr, dass "klare Maengel" ein Anagramm von Angela Merkel ist :-)
+
+
+Da sind Reklamen egal: fuer den einen ist "Angela Merkel" ein 
+"Karamelengel", andere empfinden "Laermklaenge", gar mancher 
+"erlag am Ekeln", da half auch keine "Analegel-Krem".
+Trotz "realem Klagen", wo wir morgen unsere "Kamele lagern" oder ich 
+mir eine "Makrele angle" -- so sie keine "Aale gen Kreml" schickt, 
+ist die "Alge am Rekeln", um im Bild zu bleiben. Immerhin bekommen 
+im Fall eines Wahlsieges "alle Armen EKG"!
+
+-----------------------------------------------------------------------------
+
+
+
+iTunes und "Bedenkliche Inhalte" (Ronda, 10. Aug 2005, 23:34:31):
+Endlich begreifts mal jemand!
+
+Ronda *hustend*
+
+From: kscheller@ochs.franken.de (Konni Scheller)
+Newsgroups: de.comp.sys.mac.soc
+Subject: Re: Bedenklichen Inhalt melden
+Date: Thu, 4 Aug 2005 18:25:55 +0200
+Message-ID: <1h0s8iq.7cuxk2fdz10N%kscheller@ochs.franken.de>
+
+Daniel Krebs <tonne@gm.ufz.de> wrote:
+
+
+>> ist schonmal jemandem aufgefallen, dass es unter dem Podcasts- Fenster  
+
+in
+
+>> iTunes den Punkt "Bedenklichen Inhalt melden" gibt?
+>> Was hat das zu bedeuten?
+
+
+Der ist fuer die Volksmusik.
+
+Servus,
+Konni
+
+-----------------------------------------------------------------------------
+
+
+
+Das bizarre Volk der Schweizer (Ronda, 10. Aug 2005, 23:42:41):
+... ich hoffe, dass Anoris mir verzeiht, dass ich das poste ;-)
+
+Ronda
+
+From: Florian Spisla <individual@nurfuerspam.de>
+Newsgroups: de.alt.gruppenkasper,de.talk.jokes,de.talk.bizarre
+Subject: <dag-offziell> Das bizarre Volk der Schweizer
+Date: Thu, 04 Aug 2005 15:35:22 +0200
+Message-ID: <3lejsqF10n8t2U1@individual.net>
+
+
+Wie Sie die Schweizer besser verstehen...
+Das Kleine Einmaleins fuer den Schweiz-Besuch
+------------------------------------------------------------
+
+Wollen Sie demnaechst in die Schweiz? Wollen Sie auch verstehen,
+was die Schweizer so sagen und meinen? Dann habe ich heute
+etwas fuer Sie.
+
+Hier geht's los:
+
+Allgemeines
+-----------
+
+* Wenn die Welt untergeht, heisst das noch lange nicht, dass das
+die Schweiz auch betrifft.
+
+* Ironie wird im Zweifelsfalle eher nicht verstanden.
+
+
+Sprache
+-------
+
+* Der 'Deutschschweizer Dialekt' als Ganzes ist mit dem
+Hochdeutschen etwa so eng verwandt wie ostfriesisches Platt mit
+der niederbayerischen Mundart.
+
+* Die Pflicht, sich im Auto anzuschnallen, heisst
+Gurtenobligatorium.
+
+* Die Staenderlampe ist eine Stehlampe und keine
+Genitalbeleuchtung.
+
+* Wenn Sie die Schweiz besuchen: Bitte sagen Sie zum 'Gipfeli'
+(Hoernchen, Croissant) nicht 'Kipfelchen'.
+
+* Lassen Sie bleiben, was Sie zu beherrschen glauben. Das klingt in
+Schweizer Ohren uebel: Gruetzi, grueuezi oder gruezzi!
+Bleiben Sie bei 'Guten Tag', bis Ihnen jemand fuer Ihr Grueaezi die
+Pruefung abgenommen hat. Oder wenden Sie den Verschlucktrick an
+und sagen Sie -zi. Das machen auch viele Schweizer so.
+
+* Ein Harass ist kein Schaeferhund, sondern eine Getraenkekiste.
+
+* Wenn von einem Moedeli Anke die Rede ist, so ist kein Maedchen
+namens Anke gemeint, sondern ein Stueck Butter.
+
+* Und wer Sie fragt, ob Sie ein Zaeltli moechten, der will Ihnen
+keine kleine Campingausruestung aufschwaetzen, sondern ein Bonbon
+anbieten.
+
+* Chriesi sind keine Krisen, sondern Kirschen.
+
+
+Bluffen (= gross angeben)
+-------------------------
+
+* Bestellen Sie in einer Kneipe (Schpunte, Beiz, Chnelle) ein
+Tschumpeli Dohl. Das Risiko duerfte sich lohnen. Wenn alles glatt
+laeuft, bekommen Sie ein Glaeschen Rotwein (Dle).
+
+
+La Grande Nation
+----------------
+
+* Caf, Restaurant, Coiffeur (ja nicht Friseur!), Trottoir, Billet,
+Jupe statt Rock, pressant (statt in Eile), Apro, Dessert, Sauce,
+Glac, Radio statt Rundfunk.
+
+* Gewoehnen Sie sich an das leise Laecheln des Schweizers, wenn
+Sie sich mit Staedtenamen wie Vevey abmuehen (Es sei hier verraten:
+Woewee). Wenn Sie von Bulle ueber den Col des Mosses fahren, denken
+Sie bitte weder an einen Bullen noch an Moses. Es heisst "Buell"
+und "Koll dee Moss", das kann doch nicht so schwierig sein!
+
+* Wenn Sie in der Schweiz ein Muesli bestellen, grinsen Ihre
+Gastgeber in sich hinein, denn Sie scheinen eine kleine Maus
+verspeisen zu wollen. Die in der Schweiz von Dr. Bircher
+entwickelte Frucht-Joghurt-Flockenmischung ist hierzulande naemlich
+ein Mueesli.
+
+* Spargeln ist in der Schweiz kein Verb (ich habe gespargelt),
+sondern schlicht die Mehrzahl von Spargel, wie sie in Deutschland
+nicht existiert.
+
+
+Heiterkeit
+----------
+
+* Zu Heiterkeit geben dem Deutschen immer wieder hochdeutsche
+schweizerische Formulierungen wie 'Fehlbare Automobilisten
+werden gebuesst' Anlass, oder schriftliche Warnungen in Trams,
+dass Fahrgaeste ohne Billet 50 Franken fuer die Umtriebe zahlen
+muessen.
+
+* In der Schweiz loest man nicht nur Wasser, sondern auch Billette
+an Billet-Automaten. Und man parkt und grillt nicht, man
+parkiert und grilliert. Nur fuer den Fall, dass Sie mit Ihren
+Schweiz-Kenntnissen brillen moechten
+
+
+Telefonieren
+------------
+
+* Die putzigste Eigenart des Schweizers beim Telefonieren:
+Wie kurz auch immer Ihr Schweizer Telefonpartner das
+Gespraech unterbrechen muss, er wird es mit diesen Worten
+wiederaufnehmen: 'Sind Sie noch da?' Antworten Sie mit einem
+schlichten 'Ja', und wundern Sie sich nicht. Es ist nun einmal
+eine Redensart am Telefon, und die ironische Antwort 'Nein,
+Sie haetten sich gerade eben in Luft aufgeloest', wuerde Ihren
+Gespraechspartner nur unnoetig befremden. Wenn ein Englaender Sie
+mit 'How do you do?' begruesst, erklaeren Sie ihm ja auch nicht,
+wie Sie es am liebsten treiben.
+
+* Ebenfalls geht der Verabschiedung - vor allem in Berner
+Regionen - immer ein gedehntes Aaauusoo voraus und deutet somit
+an, dass der Gespraechspartner das Telefonat beenden moechte.
+
+* Wenn die Schweizer jemanden anrufen, dann "machen" sie ein
+"Telefon": "I ha geschter no ae huufe Telefon gmacht" (Ich habe
+gestern noch viele Anrufe getaetigt). Wenn man jemanden darauf
+hinweist, dass man sich wieder telefonisch meldet, wird ein
+"telefon gegeben": "I gib dr de spaeter no es telefon" (Ich ruf
+dich dann spaeter nochmals an).
+
+
+Einkaufen
+---------
+
+* Fuer die Papiertuete im Supermarkt muessen Sie 30 bis 50
+Rappen bezahlen. Das ist kein hinterhaeltiger Angriff auf Ihren
+Geldbeutel, sondern eine erzieherische Massnahme, um die
+Wegwerfgesellschaft zu bekaempfen. Wenn Sie also einen Schweizer
+mit einer leeren Papiertuete antreffen, ist er vermutlich auf dem
+Weg zum Einkauf.
+
+
+Volkssport, Puenktlichkeit
+-------------------------
+
+* Schweizer Volkssportarten: Schwingen, Hornussen, Skifahren,
+Holzhacken, Abstimmungen ignorieren, Jassen
+
+* Ueber die Puenktlichkeit der Schweizer wird zu Unrecht gelaestert.
+Sie gehen damit viel lockerer um, als Sie glauben. Wenn man Sie
+um 19.30 Uhr bestellt hat, koennen Sie durchaus eine Minute zu
+frueh bis zwei Minuten zu spaet kommen. Das wird immer noch als
+passabel puenktlich empfunden.
+
+Schweiz intim
+-------------
+
+* Die Waschkuechenbenutzung in Mietwohnungen von
+Mehrfamilienhaeusern:
+Verstoesse gegen die Waschkuechenordnung werden in der Regel nicht
+im persoenlichen Gespraech, sondern durch das Aufhaengen
+grossformatiger Botschaften mit vielen Ausrufungszeichen an Tueren,
+Waschmaschinen und Wasserhaehnen geahndet. Schon ein einziger nach
+Ablauf der eigenen Waschkuechenbenutzungsfrist liegengebliebener
+Socken hat in der Regel nicht nur eine Zurechtweisung zur Folge,
+sondern auch die Erklaerung, dass darum die Waschkueche unbenutzbar
+gewesen sei
+
+-----------------------------------------------------------------------------
+
+
+
+Best of Bewerbungen (Ronda, 29. Aug 2005, 22:21:23):
+... wobei ich mir nicht sicher bin, ob man drueber schmunzeln oder jammern
+sollte. Gibts echt Leute, die so wenig Zeit in Bewerbungen investieren, dass
+sie sie ohne x mal Gegenlesen rausschicken?
+
+Ronda
+
+From: Oliver Schad <o.schad@web.de>
+Newsgroups: de.alt.sysadmin.recovery
+Subject: Best of Bewerbungen
+
+Heyho,
+
+wenn ich eine Bewerbung schreibe, dann verwende ich fuer die Passagen,
+deren Inhalt mir noch nicht ganz klar ist, immer Platzhalter. Sehr
+beliebt uebrigens bei der unklaren Aufgabenbeschreibung in so mancher
+Stellenanzeige.
+
+Was einem spontan dazu einfaellt, wird gerade mal in die Tastatur
+gehaemmert, spaeter selbstverstaendlich korrigiert. Ich schicke fuer
+gewoehnlich eine elektronische Bewerbung als E-Mail-Anhang im
+PDF-Format-Format. Dummerweise laeuft der PDF-Export nicht
+transparent.
+
+Als ich den Anhang der gesendeten Email nochmal oeffnete und als
+Betreff "Bewerbung als eierlegende Wollmilchsau im technischen
+Bereich" und als Abschluss "Um mich auszugleichen mache ich seit
+einigen Jahren Karate. Das ist ausserdem bei Gehaltsverhandlungen
+recht nuetzlich" las, musste ich doch leicht lachen.
+
+Komischerweise meldete sich betreffendes Unternehmen irgendwann zurueck
+und meinte, dass ich leider ueberqualifiziert sei.
+
+mfg
+Oli
+
+-----------------------------------------------------------------------------
+
+
+
+Gibts das auch fuers Mud? ;-) (Ronda,  7. Sep 2005, 22:31:35):
+From: Andre Bryx <news0805@bryx.de>
+Newsgroups: de.soc.recht.misc
+Subject: Re: Verleumdung in Newsgroups
+Date: Thu, 01 Sep 2005 15:28:51 +0200
+Message-ID: <df6vlc$6j5$1@newsreader3.netcologne.de>
+
+Thomas Reisinger schrieb:
+
+[Reue]
+
+Als langjaehriger Forenadmin kenne ich das Problem mit "alkoholisierten
+Postings" nur zu gut. Wenn es eine einmalige Sache und der User - so
+wie Du - einsichtig ist, gibt?s ?nen Rueffel und gut ist?s.
+So sollte man es eigentlich handhaben.
+Ansonsten einfach mal 2-4 Wochen ganz still sein und die Sache wird sich
+in Luft aufloesen - es gibt wesentlich Schlimmeres.
+
+Anekdote:
+Ich erinnere mich noch aus meinen Tagen als Elektronikverkaeufer, als
+eine Dame hereinkam und fuer ein CB-Funkgeraet ein ganz bestimmtes
+Mikrophon haben wollte. Nach dem es bezahlt war, fragte sie mich, ob
+ich es ihr "unsichbar" kaputtmachen koenne - die Mikrokapsel soll
+abgeklemmt werden. Auf meine berechtigte Frage, warum, entwortete sie,
+dass ihr Mann, wenn er Abends zu viel trank sich immer an die CB-Funke
+setzte und alle in der Nachbarschaft stundenlang beleidigte, was ihr
+immer ziemlich peinlich war.
+So konnte sie nun rechtzeitig das Mikro austauschen und ihr Maenne
+stundenlang lauwarme Luft anschwatzen ohne das es jemanden stoert :-)
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Gibts das auch fuers Mud? ;-) (Muadib,  8. Sep 2005, 23:23:22):
+~#! rn=Ronda rt=1126125095 rg=schmarrn.netdigest
+~#! tid=1126125095
+ich tausche auch abundzu die mikropaskel aeh mikrokapsel aus
+
+-----------------------------------------------------------------------------
+
+
+
+Waehler gewinnen... (Ronda, 14. Sep 2005, 00:06:24):
+From: KVSpambox@web.de
+Subject: Waehler gewinnen
+Newsgroups: de.talk.jokes
+Date: 8 Sep 2005 08:00:39 -0700
+Message-ID: <1126191639.707148.3230@g49g2000cwa.googlegroups.com>
+
+
+Gerhard Schroeder und Angela Merkel sitzen vor dem Bundestag in der
+Sonne und unterhalten sich. Ploetzlich hoert Angela nicht mehr hin und
+kuckt an Gerhard vorbei. Gerhard dreht sich um.
+
+Angela: Siehst du auch, was ich da sehe?
+Gerhard: Na klar sehe ich das. Das ist ein ... ein Dings ... wart mal
+...
+Angela: Genau! Ein so nen Dings ... ich habs gleich ... ein ...
+Beide gleichzeitig: Ein ... ein WAeHLER!!!
+Beide springen auf. Halt! Hiergeblieben! Ich hab ihn zuerst gesehen!
+Das ist meiner!
+Angela hakt sich bei den Waehler am rechten Arm unter. Na, mein Lieber?
+Gerhard legt dem Waehler seine Pranke auf die linke Schulter. Tach,
+Kollege!
+Angela: So geht das nicht, Gerd! Ich war zuerst da!
+Gerhard: Hoer doch auf, Angie! Den hol ich mir!
+Angela: Meiner!
+Gerhard: Nein, meiner!
+Angela: Na gut, wenn du es so willst, dann werden wir das hier und
+jetzt ausfechten!
+Gerhard (taenzelt von einem Bein aufs andere): Na dann wehr dich! Du
+haeltst doch hoechstens eine halbe Runde durch!
+Angela: Was? Du willst mich schlagen? Das koennte dir so passen! Nein,
+wir knobeln das aus! Tsching, tschang, tschong!
+Gerhard: Tschong? Uh ... mit diesem komplizierten Zeug willst du mich
+doch bloss durcheinanderbringen! Das ist unfair!
+Angela: Ach ja? Und was waere fair, deiner Ansicht nach? Aber bitte
+keine Gewalt!
+Gerhard: Schon gut, aber bitte keine Denksportaufgaben.
+
+Beide gruebeln.
+
+Angela: Ich glaub, ich hab's.
+Gerhard: Ja?
+Angela: Wir luegen!
+Gerhard: Luegen?
+Angela: Ja! Wir luegen! Wer besser luegt, kriegt ihn!
+Gerhard: Hahaha! Da hast du doch keine Chance!
+Angela: Wart's ab!
+Gerhard: Na schoen. Du faengst an.
+Angela: Gut. Also. Wir werden nach der Wahl ... die Buerokratie
+abbauen!
+Gerhard: Aha. Naja.
+Angela: Jetzt du.
+Gerhard: Okee. Aehmm ... Wir haben aus Deutschland einen attraktiven
+Wirtschaftsstandort gemacht!
+Angela: Hihi. Und wir ... wir werden nach der Wahl auch die
+Subventionen abbauen!
+Gerhard: Hoho. Wir dagegen, wir haben die Rentenkasse auf eine gesunde
+Grundlage gestellt!
+Angela: Hahaha! Das macht Spass! Wir werden nach der Wahl die Steuern
+senken, jedenfalls die meisten!
+Gerhard: Hehehe! Wir wollen uns auch nach der naechsten Wahl an der
+Arbeitslosenzahl messen lassen!
+Angela: Arbeitslose? Haha! Wir werden durch Flexibilisierung
+Arbeitsplaetze schaffen!
+Gerhard: Hoho! Ich habe Holzmann im Alleingang gerettet!
+Angela: Hihi! Alle Ein-Euro-Jobber koennen ihre Steuererklaerung in
+Zukunft auf einem Bierdeckel machen!
+Gerhard: Hehe! Nicht schlecht! Wir werden das Gesundheitswesen mit
+einer Buergerversicherung sanieren!
+Angela: Haha! Eine Kopfpraemie ist viel billiger!
+Gerhard: Hoho! Die Freiheit Deutschlands wird auch am Hindukusch
+verteidigt!
+Angela: Hihihi ... glucks ... kicher ...
+Sie wischt sich die Traenen aus den Augen.
+Angela: So, und nun nimm das: Von den Amerikanern lernen heisst siegen
+lernen!!
+Gerhard: Huahahahaha ... ich kann nicht mehr ... aber pass auf ...
+einen hab ich noch ...
+
+Ploetzlich erscheint Gregor Gysi.
+
+Gregor: Das ist ja nicht zum Aushalten hier! Hier wird ja gelogen, dass
+sich die Reichstagskuppel biegt! Endlich zeigt sich mal das wahre
+Gesicht der verlogenen Wessipolitik! Ich sage euch, sowas haette es bei
+uns im Osten nicht gegeben!!!
+
+Angela sieht Gerhard an.
+Gerhard sieht Angela an.
+Angela: Tja ...
+Gerhard: Schon gut, Gregor. Nimm ihn. Du hast gewonnen.
+
+-----------------------------------------------------------------------------
+
+
+
+Zur Wahl. (Ronda, 17. Sep 2005, 23:06:34):
+Newsgroups: de.soc.recht.misc
+Subject: Re: Briefwahl: was ist, wenn eingeschickt, aber nun anders
+From: Peter Bruells <pb@ecce-terram.de>
+Date: 15 Sep 2005 13:06:09 +0200
+Message-ID: <m28xxyoaji.fsf@rogue.ecce-terram.de>
+
+Holger Pollmann <hihp@uboot.com> writes:
+
+>> "Rainer Wilkins" <beihotmailanmelden@hotmail.de> schrieb:
+>>
+>
+>>>> interessante Problemstellung: was ist, wenn jemand per Briefwahl
+>>>> waehlt, seinen Wahlzettel eine Woche vorher einschickt, dann aber
+>>>> merkt, so wollte er gar nicht waehlen. Kann er nochmal beantragen?
+>
+>>
+>> Nein, er hat schon gewaehlt. Wenn du im Wahllokal deinen Stimmzettel in 
+>> die Wahlurne geschmissen hast, kannst du den auch nich tnochmal 
+>> rausholen lassen, damit du nochmal abstimmen kannst.
+>>
+>
+>>>> Seine Willenserklaerung sozusagen anfechten? 
+>
+>>
+>> Die Wahl ist keine WIllenserklaerung in dem Sinne, in dem das Wort 
+>> ueblicherweise benutzt wird; schon gar nicht finden Regeln des 
+>> Privatrechts auf die Wahlentscheidung Anwendung.
+
+
+Schade. Sonst haetten Briefwaehler ja ein zweiwoechiges Rueckgaberecht der
+Regierung....
+
+-----------------------------------------------------------------------------
+
+
+
+Junggesellenabschied. (Ronda, 26. Sep 2005, 23:45:51):
+From: Michael Obenland <obenland@t-online.de>
+Newsgroups: de.talk.romance
+Subject: Re: Junggesellenabschied
+Date: Wed, 21 Sep 2005 22:45:57 +0200
+Message-ID: <dgsgq4$3q1$04$1@news.t-online.com>
+
+Hallo Elina,
+
+
+>>In 3 Wochen steht bei uns ein Junggesellinnenabschied an und ich brauche
+>>noch Ideen, welche "Fiesigkeiten" wir an dem Abend mit der Braut anstellen
+>>koennen,
+
+
+Die Ehe als solche reicht nicht? Warum soll sie noch mehr leiden?
+
+Gruesse,
+
+Michael
+
+-----------------------------------------------------------------------------
+
+
+
+Auf der Suche nach Liebe. (Ronda, 26. Sep 2005, 23:50:07):
+Newsgroups: de.talk.romance
+Subject: Re: ...auf der Suche nach Liebe...
+From: Sabine 'Sani' Schulz <foo@albasani.net>
+Date: Wed, 21 Sep 2005 02:07:50 +0200
+Message-ID: <u0gf9tbd.fsf@nemo.im.schnuerpel.net>
+
+* Am 21.09.2005 begab es sich, dass Angelique Presse schrieb:
+
+
+>> Martina Diel schrieb am Mittwoch, 14. September 2005 15:55 in
+>> de.talk.romance:
+
+
+>>>> Schietegal. Du kannst ihn auch fragen, ob er nicht ne
+>>>> Briefmarkensammlung hat, die du mal anschauen darfst. Oder ob ihr
+>>>> nicht zusammen einen Kernel kompilieren wollt. ;-)
+>
+>>
+>> LOL
+>> YMMD
+>> Das muss ich mir merken.
+>> *saeusel* Duuu, Du kennst Dich doch sooo gut mit Computern aus. Ich wollte
+>> immer schon mal wissen, wie man nen Kernel kompiliert. Magst Du mir das
+>> nicht noch zeigen?
+
+
+"Ja sicher, das haben wir in 10 Min. ..." ... Stunden spaeter, draussen
+wird es gerade hell, raetselt er dann immer noch, warum der Kernel ne
+Panik hervorruft und ist vom Compi nicht mehr wegzubringen, waehrend man
+selbst beschliesst, zukuenftig wieder auf Bewaehrtes wie die
+Briefmarkensammlung zurueckzugreifen.
+
+:-)
+
+Gruesse
+Sabine
+
+-----------------------------------------------------------------------------
+
+
+
+Glaskugeln und Kartenleger im Support (Ronda, 28. Sep 2005, 23:57:02):
+[SN: Aus der Support-NG eines grossen oesterreichischen ISP]
+
+Message-Id: <43382030$0$1663$79720d31@newsreader.inode.at>
+From: Daniel Tiefnig <support@inode.at>
+Subject: Re: was ist mit den E-mail Server los!!!!
+Newsgroups: at.inode
+Date: Mon, 26 Sep 2005 18:22:07 +0200
+
+Bernhard Filipic wrote:
+
+>> ich glaube das kann dauern, ich meine gehoert zu haben das entweder
+>> die Wahrager und oder Kartenleger auf Urlaub sind, oder die
+>> Kristallkugeln bei Inode beim letzten Gewitter Schaden genommen
+>> haben.
+
+
+Der Wahrsager war tatsaechlich im Urlaub, und Kartenleger sind fuer
+diese Faelle nicht zustaendig, die kuemmern sich nur um netzwerkseitige
+Probleme.
+Das mit den Glaskugeln ist so eine Sache, wir haben zwar schon mal
+welche bestellt, aber die wurden vom Controlling nicht freigegeben,
+weil wir sie nicht von der Wertschoepfung der Investition ueberzeugen
+konnten. Jetzt vielleicht.
+
+
+HTH, HAND.
+daniel
+
+-----------------------------------------------------------------------------
+
+
+
+Vorteile von VoIP (Ronda, 28. Sep 2005, 23:58:08):
+Message-ID: <I12FIt.44E@greenie.muc.de>
+Subject:     Re: Zwangstrennung bei T-DSL vom Provider oder von der 
+From:        Gert Doering <gert@greenie.muc.de>
+Newsgroups:  de.comm.internet.infrastruktur
+Date:        Sun, 18 Jul 2004 20:56:53 GMT
+
+Nils Ketelsen <$ENV{USER}@druecke.strg-alt-entf.org> writes:
+
+
+>>Und Du kannst nichtmal mal Deinen Internetprovider anrufen um ihm zu sagen,
+>>dass das Internet nicht geht. Ein Feature, dass gerade in Firmen gerne
+>>uebersehen wird: Wenn ich VoIP mache, und Email wegen Netzwerkproblemen
+>>nicht mehr geht, habe ich auch Fax und Telefon als Fallback verloren.
+
+
+Fuer die Admins ist das doch prima - endlich in Ruhe die Fehler suchen und
+beheben, statt dauernd vom Telefon genervt zu werden ;-)
+
+gert
+
+-----------------------------------------------------------------------------
+
+
+
+Notebooks und Ergonomie (Ronda, 29. Sep 2005, 00:17:05):
+Was ich besonders passend finde: Roland Moesl ist beruehmt-beruechtigt fuer
+seine Ansichten was Notebooks angeht. Passend (???) zu diesem Artikel ist,
+dass er mal bei HP einen Preis bei einem Fotowettbewerb gewonnen hat zu
+"modernem Arbeitsstil" -
+http://notebook.pege.org/2003-digital-kamera/hp-fotowettbewerb.htm - man
+beachte besonders sein Foto...
+
+Ronda
+
+Message-ID: <t01ej116tvc3k4a1uk00gh8no50gos65lj@4ax.com>
+From: T.C. <Devil505@despammed.com>
+Newsgroups: de.comp.sys.notebooks
+Subject: Re: Testgeraete gesucht
+Date: Mon, 26 Sep 2005 11:45:00 +0200
+
+On Sun, 25 Sep 2005 20:07:55 +0200, Roland Moesl <founder@pege.org>
+wrote:
+
+[SN: ... ext. Tastatur & Maus vs. gute interne Varianten ...]
+
+
+>> Unsinn, da ist ja dann das Notebook total verkabelt.
+>> Da koennte man sich ja nicht mehr mit dem Notebook
+>> bequem ins Bett legen zum Arbeiten
+>> sonst ist der
+
+
+Ergonomie am Arbeitsplatz orientiert sich NICHT daran, ob man Laptops
+mit Kabeln versehen muss - noch daran, ob man vorzugsweise im Bett
+arbeitet - im Bett sitzend mit dem Laptop auf dem Schoss ist NICHT
+allgemein ergonomisch, im Gegenteil: viele Menschen ermueden dabei
+recht schnell, weil es fuer die meisten Nicht-Prostituierten eben ein
+ungewohnter Arbeitsplatz mit ungewohnter Haltung ist...
+
+T.C.
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Notebooks und Ergonomie (Gloinson, 29. Sep 2005, 00:25:59):
+~#! rn=Ronda rt=1127945825 rg=schmarrn.netdigest
+~#! tid=1127945825
+Mein Notebook ist teilweise verkabelt und ich lieg grad im Bett auf dem Bauch
+vor dem Teil herum. Ist das jetzt schlecht?
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Notebooks und Ergonomie (Ronda, 29. Sep 2005, 00:27:25):
+~#! rn=Gloinson rt=1127946359 rg=schmarrn.netdigest
+~#! tid=1127945825
+So lange das nicht so http://notebook.pege.org/2000/moderner-arbeitsstil.htm
+aussieht - und Du dafuer noch nen 8. Platz bei nem Fotowettbewerb gewinnst! -
+dann ist das schon ok... bzw. mir ziemlich egal ;-)
+
+Ronda
+,
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Notebooks und Ergonomie (Gloinson, 29. Sep 2005, 00:28:05):
+~#! rn=Ronda rt=1127946445 rg=schmarrn.netdigest
+~#! tid=1127945825
+Traegt der nur das Shirt beim modernen Arbeiten? Eeekelig.
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: Notebooks und Ergonomie (Grimmborn, 29. Sep 2005, 21:34:03):
+~#! rn=Gloinson rt=1127946485 rg=schmarrn.netdigest
+~#! tid=1127945825
+Uebrigens war das gequotete eher nicht von Herrn Moesl, soweit ich das
+erkennen kann.
+
+GdA
+
+-----------------------------------------------------------------------------
+
+
+
+Geloescht oder nicht geloescht, das ist hier die Frage... (Ronda, 10. Okt 2005, 20:04:33):
+... und irgendwie erinnert mich das an das Unternehmen, dass ALLE Dokumente in
+den Ordner "/Temp" gelegt hat. Spannenderweise haben die dann mit nem anderen
+Unternehmen der Branche fusioniert, die auch ALLE Dokumente in "/Temp" hatten.
+Mein Gesicht war angeblich sehenswert, als sie mir das erklaert haben.
+
+Ronda *ok, bei Documentum sind Verzeichnisnamen manchmal egal - aber so
+egal???*
+
+Ok, aber nun der de.alt.netdigest ;-)
+
+[Anonymisierte Anfrage am internen Helpdesk nach Domaenenmigration]
+
+Subject: Geloeschte Mails
+Date: Fri, 7 Oct 2005 15:56:28 +0200
+To: "IT-Helpdesk" <it@***.**>
+From: "*** ***" <***@**>
+
+Hallo,
+
+bei mir war am Dienstag der Ordner "geloeschte Objekte" leer. Wurden
+diese Mails nicht migriert bzw. wie komme ich an die Mails ran?
+
+Danke und Gruss
+******
+
+-----------------------------------------------------------------------------
+
+
+
+Wahr, wahr... *sigh!* (Ronda, 14. Okt 2005, 00:51:10):
+From: Florian Weimer <fw@deneb.enyo.de>
+Newsgroups: de.admin.net-abuse.mail
+Subject: Re: 100000 PC Besitzer vor Gericht gestellt?
+Date: Tue, 11 Oct 2005 13:44:49 +0200
+Message-ID: <87oe5wtgzy.fsf@mid.deneb.enyo.de>
+
+* Rainer Zocholl:
+
+
+>> Hm, was ich mich frage:
+>> Koennte man die 100.000 PC besitzer nicht auch vor den Kadi zerren?
+>> Sie haben -grob fahrlaessig- Kriminellen ihren PC fuer eine Straftat
+>> zur Verfuegung gestellt.
+
+
+Nein, der Betrieb kompromittierter Windows-Rechner am Internet ist
+nicht fahrlaessig, sondern Stand der Technik. 8-P
+
+-----------------------------------------------------------------------------
+
+
+
+"Seltsame Vorstellungen" (Ronda, 16. Okt 2005, 23:32:32):
+Naja, was manche Leute so "Seltsame Vorstellungen" nennen. Und es war mein
+Grossvater. Und es waren x Gehirne, sorgsam in Alkohol konserviert. Und ja, es
+duerfte recht unueblich sein, so was im Testament aufzufuehren...
+
+Ronda
+
+Betreff: Re: Illumination
+Absender: Eva Preuss <huev0622@ph-karlsruhe.de>
+Datum: Thu, 13 Oct 2005 15:05:57 +0200
+Newsgruppe: de.alt.talk.unmut
+Message-ID: <qb2223-6u1.ln1@7thportal.arcor.de>
+
+Ralph A. Schmid, DK5RAS wrote:
+
+[menschlicher Schaedel auf dem Schrank]
+
+
+>> Ist das eine Gesetzesuebertretung, Stoerung der Totenruhe oder sowas?
+>> Angeblich ist der Schaedel ca. 200 Jahre alt.
+
+
+Ich nehm mal an, das kommt drauf an, wo du ihn herhast:
+
+Wenn du ihn in so einem ummauerten Bereich mit vielen grossen Steinen mit 
+Namen drauf ausgebuddelt hast, ist das Stoerung der Totenruhe.
+
+Wenn du ihn aus der Biologiesammlung deiner Schule hast mitgehen lassen, 
+ist das Diebstahl.
+
+Wenn du ihn in einem Muellsack in einem See gefunden hast, ist das 
+Beweismittelbeseitigung.
+
+Aus einem Museum waere vielleicht Kustdiebstahl.
+
+Aus einer Kirche koennte man dich wegen Reliquiendiebstahl drankriegen 
+(und ggf. gleich noch exkommunizieren).
+
+Hast du ihn selber abmontiert waere das je nach voherigem Zustand Mord 
+oder Leichenschaendung.
+
+Unterschlagung von archaeologischen Funden waere auch noch eine Moeglichkeit.
+
+Wenn nichts oben genanntes dir jetzt ein schlechtes Gewissen gemacht 
+hat, dann hast du ihn vielleicht von irgendeinem Arzt geschenkt bekommen 
+(keine Ahnung, wo 'die* sowas herhaben) oder dein Uropi hatte seltsame 
+Vorstellungen in seinem Testament geaeussert? In diesem Falle, denke ich, 
+kannst du ihn ganz beruhigt weiter verstauben lassen.
+
+
+hth,
+
+    Eva
+
+-----------------------------------------------------------------------------
+
+
+
+Endlich! Der Unterschied zwischen Maennern und Frauen ist entdeckt! (Ronda, 16. Okt 2005, 23:37:50):
+Treffend. Passend. Kann das endlich das andere Geschlecht auch mal kapieren,
+bitte?
+
+Ronda *daran immer wieder verzweifelnd*
+
+From: Gerhard Faehling <gf.news@comsulting.de>
+Subject: Re: Businesskleidung
+Newsgroups: de.etc.beruf.selbstaendig
+Date: Thu, 13 Oct 2005 22:38:08 +0200
+Message-ID: <3r7uthFietq7U1@individual.net>
+
+Peter Racz schrieb:
+
+
+>> Gut zu wissen, dass ich doch nicht alleine bin:-)
+
+
+Frau:
+Geht in den Laden, probiert 5 Jeans an - die fuenfte passt perfekt. Aber 
+es muessen mindestens weitere 10 anprobiert werden - es koennte ja 
+schliesslich noch eine perfektere darunter sein.
+
+Mann:
+Geht in den Laden, probiert eine Jeans an. Passt nicht. Mann verlaesst den 
+Laden - es ist einfach nicht der Tag zum Jeanskaufen...
+
+
+Ciao
+
+    Gerhard
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Endlich! Der Unterschied zwischen Maennern und Frauen ist entdeckt! (Humni, 16. Okt 2005, 23:40:16):
+~#! rn=Ronda rt=1129498670 rg=schmarrn.netdigest
+~#! tid=1129498670
+Das ist kompletter Bloedsinn.
+
+Mann geht in den Laden, probiert eine Jeans an. Zu klein. Mann denkt "Naja,
+nehm ich halt ab" und kauft.
+
+Mann geht in den Laden, probiert eine Jeans an. Zu gross. Mann denkt "Naja,
+hab ich Platz zum dicker werden".
+
+Humni
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Endlich! Der Unterschied zwischen Maennern und Frauen ist entdeckt! (Gloinson, 16. Okt 2005, 23:40:18):
+~#! rn=Ronda rt=1129498670 rg=schmarrn.netdigest
+~#! tid=1129498670
+Komischer Mann. Realitaet:
+
+Mann:
+Geht in den Laden, nimmt eine Jeans, probiert, korrigiert Entscheidung ggf. in
+Bund oder Beinlaenge auf Herstellerfehlertoleranz, probiert, kauft. Wieso?
+Weil die alte Zweitjeans vor zwei Tagen endgueltig versagt hat.
+Welcher Mann geht denn bitte ohne Motivation in einen Jeansladen?! Immer diese
+Metrosexuellen.
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Endlich! Der Unterschied zwischen Maennern und Frauen ist entdeckt! (Marcus, 17. Okt 2005, 08:22:44):
+~#! rn=Gloinson rt=1129498818 rg=schmarrn.netdigest
+~#! tid=1129498670
+Jep.
+
+Ich habe nur am WE Zeit zum einkaufen,
+- da wo die Verkaeufer am aufdringliuchsten
+- die Einkaeufer am nervigsten sind
+
+Wenn ich meine Jeans habe, bin ich im Cafe und dann wieder heim.
+
+Module huebscher Jeansverkaeuferin natuerlich, aber auch die reissens
+net raus.
+
+Ciao, Marcus
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Endlich! Der Unterschied zwischen Maennern und Frauen ist entdeckt! (Bambi, 17. Okt 2005, 21:24:46):
+~#! rn=Marcus rt=1129530164 rg=schmarrn.netdigest
+~#! tid=1129498670
+Ich grad zur Freundin: Oh nein, sie fangen an, darueber zu diskutieren, wie
+Maenner Jeans kaufen.
+Daraufhin sie: Wer diskutiert? Nur Frauen wahrscheinlich.
+Ich: Nein, nur Maenner. Sofern man *** als Mann bezeichnen kann.
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: Endlich! Der Unterschied zwischen Maennern und Frauen ist entdeckt! (Gloinson, 17. Okt 2005, 21:26:12):
+~#! rn=Bambi rt=1129577086 rg=schmarrn.netdigest
+~#! tid=1129498670
+Da draengt sich sofort die Frage auf: Wen von uns hast du denn schon alles
+"ausprobiert"?
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^5: Endlich! Der Unterschied zwischen Maennern und Frauen ist entdeckt! (Bambi, 17. Okt 2005, 21:26:48):
+~#! rn=Gloinson rt=1129577172 rg=schmarrn.netdigest
+~#! tid=1129498670
+Sagen wir's so: bei wievielen bist Du Dir sicher, dass ichs noch nicht
+probiert habe? :)
+
+-----------------------------------------------------------------------------
+
+
+
+Re^6: Endlich! Der Unterschied zwischen Maennern und Frauen ist entdeckt! (Gloinson, 17. Okt 2005, 21:27:38):
+~#! rn=Bambi rt=1129577208 rg=schmarrn.netdigest
+~#! tid=1129498670
+Ich bin mir nicht mal bei mir sicher, du kuschelst ja immer mit allem was
+nicht bei 3 im Wald ist.
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^7: Endlich! Der Unterschied zwischen Maennern und Frauen ist entdeckt! (Bambi, 17. Okt 2005, 21:28:04):
+~#! rn=Gloinson rt=1129577258 rg=schmarrn.netdigest
+~#! tid=1129498670
+Ach in den Wald rennt ihr? Gut zu wissen...
+
+-----------------------------------------------------------------------------
+
+
+
+Re^8: Endlich! Der Unterschied zwischen Maennern und Frauen ist entdeckt! (Gloinson, 17. Okt 2005, 21:28:34):
+~#! rn=Bambi rt=1129577284 rg=schmarrn.netdigest
+~#! tid=1129498670
+Deine Freundin hiess Herbert, oder?
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^9: Endlich! Der Unterschied zwischen Maennern und Frauen ist entdeckt! (Beldaran, 17. Okt 2005, 21:31:04):
+~#! rn=Gloinson rt=1129577314 rg=schmarrn.netdigest
+~#! tid=1129498670
+Nein.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^10: Endlich! Der Unterschied zwischen Maennern und Frauen ist entdeckt! (Darklor, 18. Okt 2005, 21:34:10):
+~#! rn=Beldaran rt=1129577464 rg=schmarrn.netdigest
+~#! tid=1129498670
+Der kam gut... ;)
+
+Darklor
+
+-----------------------------------------------------------------------------
+
+
+
+Fuer Bahnreisende (Ronda, 28. Okt 2005, 21:48:23):
+Betreff: Re: Betriebseinstellung wg Herbst auf der KBS 458
+Wuppertal-Remscheid-Solingen-Ohligs
+Absender: Christian Lorch <dev0@jmh.mhn.de>
+Datum: Sun, 23 Oct 2005 14:53:25 +0200
+Newsgruppe: de.etc.bahn.eisenbahntechnik
+
+Matthias Dingeldein wrote:
+
+
+>> Matthias Warkus schrieb:
+>> 
+>
+>>>> Am Fri, 21 Oct 2005 22:25:32 +0200 schrieb Bjoern Schliessmann:
+>>
+>>>>>> jede Verspaetungsdurchsage mit einem
+>>>>>> dahingesabbelten unehrlichen, fast selbstverstaendlichen
+>>>>>> "wirbiddnumihrverstaendnisvielendank" endet,
+>>
+>>>> 
+>>>> Wie haettest du's denn gerne? Soll da ein Bahnmensch persoenlich die
+>>>> Hand jedes Betroffenen auf dem Bahnsteig schuetteln, damit man in
+>>>> seinem Auge die Traene quellen sieht?
+>
+>> 
+>> Nein, einfach nur halt ehrlich statt aufgesetzt. Also statt
+>> "Sehr geehrte Damen und Herren, wegen einer Verzoegerung im
+>> Betriebsablauf wird sich die Abfahrt des Zuges 4711 von Koeln ueber
+>> Riechau nach Duftingen vsl. um 10 Minuten verzoegern. Wir bitten um Ihr
+>> Verstaendnis."
+>> zum Beispiel
+>> "Werte Fahrgaeste Richtung Duftingen, der Zug 4711 hat derzeit 10
+>> Minuten Verspaetung, wir bemuehen uns, die Verspaetung zu reduzieren
+>> und bitten um Entschuldigung"
+>> oder
+>> "*bingbong* Durch eine Stoerung an $KOMPONENTE hat sich der Zug 4711
+>> nach Duftingen eine Verspaetung von 10 Minuten eingehandelt. Wir bitten
+>> um Ihr Verstaendnis."
+>> oder
+>> "Achtung an Gleis 5, wegen schwieriger Schienenverhaeltnisse konnte Zug
+>> 4711 nach Duftingen seine Fahrzeiten leider nicht einhalten und ist
+>> derzeit etwa 10 Minuten verspaetet. Um die Verspaetung trotzdem so
+>> gering wie moeglich zu halten bitten wir Sie, sich moeglichst
+>> gleichmaessig auf alle Tueren des Zuges zu verteilen und danken fuer
+>> Ihre Mithilfe bei der zuegigen Abwicklung des Fahrgastwechsels".
+>> IMHO hat fast jeder Verstaendnis fuer Verspaetungen, wenn er mitkriegt,
+>> dass die Eisenbahner ihr Moeglichstes tun; automatisierte Ansagen oder
+>> vorgeschriebene Wortlaute sind da nicht unbedingt hilfreich.
+
+
+da hab ich in Ulm vor Jahren (zur Zeiten der brennenden 103-er :-) mal etwas
+recht schoenes erlebt:
+
+zu erst die Standardansage: Wegen einer Betriebsstoerung hat der IC/EC von
+Stuttgart nach Muenchen blabla Verspaetung. Bitte weichen sie auf den
+nachfolgenden ICE Richtung Muenchen aus...
+
+ein paar Minuten spaeter die Ansage, dass der IC/EC nun nicht ein paar
+Minuten sondern 20-30min Verspaetung habe und man ohne Aufpreis den ICE
+benutzen solle.
+
+Kurz Zeit spaeter etwa in der Art.
+
+Verehrte Fahrgaeste (es war kalt und regnerisch),
+leider koennen Sie auch nicht mit dem ICE fahren, hab ich ganz vergessen, da
+der ja hinter dem IC/EC festhaengt, tut uns echt leid. Das einzige, was wir
+grad machen koennen haben wir bereits gemacht, eine Ersatz-103 ist auf dem
+Weg um den Zug von der Steige zu bekommen. Uebrigens kommt die Verspaetung
+daher, dass die Lok des IC/EC gebrannt hat und fahruntuechtig ist. Es ist
+aber niemand zu Schaden gekommen!
+
+wenige Minuten spaeter.
+Verehrte Fahrgaeste, ach scheisse, die Ersatzlok ist auf dem Weg dorthin auch
+liegengeblieben. Wir denken nach, was wir jetzt machen koennen... Bis dahin
+kommen sie doch vom Bahnsteig ins Gebaeude, da ist es waermer, wir
+informieren sie rechtzeitig vor Ankunft irgendeines Zuges.
+
+bissl spaeter:
+Achtung eine Durchsage: es tut uns allen echt leid, aber die Strecke
+Stuttgart-Ulm ist momentan wegen der liegengebliebenen modernen Loks
+komplett blockiert. Wir rufen mal bei den Dampflokfreunden an, ob die ne
+Dampflok uebrig haben und sie uebermorgen einsatzbereit ist...
+
+bissl spaeter:
+die fleissigen Fahrgaeste haben den kaputten IC/EC nun in den naechsten
+Bahnhof geschoben, dankeschoen. Dafuer duerfen sie jetzt im ICE Richtung
+Muenchen weiterfahren. Der Zugchef hat uns aber darueber informiert, dass der
+Zug recht voll ist, aber der ICE danach steht ja auch schon dahinter, wenn
+sie im ersten keinen Platz mehr bekommen, der zweite kommt gleich und
+brennende ICEs sind mir unbekannt..
+
+...usw.
+
+Verehrte Fahrgaeste an Gleis x, endlich ist der Mist vorbei, wir haben einen
+Zug an ihren Bahnsteig gebracht, steigen sie ein und wir hoffen, sie kommen
+trotzdem mal wieder vorbei. So etwas wie heute macht uns auch keinen Spass.
+
+
+Wie oft hat da der halbe Bahnsteig gelacht und natuerlich haben wir uns
+geaergert aber durch die menschliche Art wurde es ertragbar.
+
+Automatische Ansagen ueber die naechsten Reisemoeglichkeiten meinetwegen, aber
+fuer Entschuldigungen braucht es IMHO immer eine persoenliche Person, die
+persoenlich Informationen weitergibt :-)
+
+Schoen Tag noch!
+
+Locke
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Fuer Bahnreisende (Anatol, 28. Okt 2005, 22:05:28):
+~#! rn=Ronda rt=1130528903 rg=schmarrn.netdigest
+~#! tid=1130528903
+Erinnert mich an eine Zugfahrt vor ein paar Monaten...:
+
+"Sehr geehrte Fahrgaeste, wir erreichen nun Bonn Hauptbahnhof. Leider
+konnten wir unsere Verspaetung nicht ganz wieder aufholen, so dass
+etwa fuenf Minuten nach planmaessiger Ankunft dort eintreffen - Wir 
+bitten um Ihr Verstaendnis.
+Zu Ihren Anschlussmoeglichkeiten achten Sie bitte auf die oertlichen
+Lautsprecherdurchsagen. Wir sagen dankeschoen, dass Sie mit uns gefahren
+sind und wuenschen Ihnen einen schoenen Tag. Vergessen Sie beim
+Aussteigen Ihre Schirme nicht, denn auch in Bonn regnet es."
+
+Wir haben sehr gelacht. Das ganze ist uns in der 7-Uhr-Regionalbahn
+(Berufspendler aus der Umgebung) von Euskirchen nach Bonn passiert. ;)
+
+
+-----------------------------------------------------------------------------
+
+
+
+An die LehrerInnen unter Euch... (Ronda,  7. Nov 2005, 20:50:05):
+... ist marsriegeln noch ok?
+
+Ronda
+
+From: "Tobias J. Becker" <tobias.becker@online.de>
+Subject: Re: Wie weit darf ich als Fussgaenger an die Autobahn?
+Newsgroups: de.etc.sprache.deutsch
+Date:Fri, 28 Oct 2005 12:07:15 +0200
+Message-ID: <djst84$31g$04$1@news.t-online.com>
+
+Jens Arne Maennig schrieb:
+
+
+>>>>Vielleicht haben die Polizisten auch was Sinnvolleres zu tun, als auf
+>>>>der Autobahn anzuhalten (!) und harmlose Fotografen zu massriegeln.
+
+
+>> Heisst das nicht "marsriegeln"?
+
+
+>> | mars|rie|geln, Verschenken von Suessigkeiten durch Ordnungskraefte an die
+>> | Bevoelkerung zum Behufe der Verbesserung der oeffentlichen Ordnung.
+
+
+Waehrend meiner Schulzeit erwaehnten ein Lehrer und ein Schueler immer
+wieder mal, wie ersterer einige Jahre zuvor vermutlich fuer besondere
+Leistungen Mars-Riegel verteilte. Als er dem Schueler den Riegel durch
+den Klassensaal zuwarf - wenn ich micht recht entsinne, schuldete er ihm
+diesen schon laenger -, traf er ihn mit voller Wucht an der Stirn. Und
+so, wie er das erzaehlte und man ihn auch sonst kannte, spielte dabei
+durchaus ein Hauch von Sadismus mit. Jedenfalls drohte der Lehrer immer,
+wenn der Schueler spaeter mal wieder im Unterricht stoerte oder aufmuckte,
+mit einem sueffisanten Laecheln, er werde ihm wieder ein Mars an den Kopf
+schleudern.
+
+*Das* ist Marsriegeln.
+
+-----------------------------------------------------------------------------
+
+
+
+Aus dem Biomechanical-Newletter... (Gabylon,  9. Nov 2005, 22:56:15):
+
+HARD TO CLASSIFY:
+
+COULD CLASSIFY THIS ONE UNDER "COMPARATIVE", "LOCOMOTION",
+
+"RELIGIOUS", OR "DOES MARK DENNY HAVE ACCESS TO SUBJECTS OTHERS ONLY
+
+DREAM OF"?
+
+Denny, M. W. (2004). "Paradox lost: answers and questions about
+
+walking on water." Journal of Experimental Biology 207(10): 1601-1606.
+
+
+gab
+
+-----------------------------------------------------------------------------
+
+
+
+Amazon, Phosphor und Harry Potter... (Ronda, 11. Nov 2005, 00:18:18):
+Subject: Zaubern mit Phosphor: Amazon empfiehlt...
+Date: Wed, 09 Nov 2005 10:00:51 +0100
+From: Christian Hoffmann <brcwcs@gmx.net>
+Newsgroups: de.alt.recovery.scientist
+
+Hallo,
+
+habe heute bei Amazon.de ein Buch gesucht und sofort gefunden:
+
+   ISBN:        0-8493-1949-8
+   Inorganic Phosphors ...
+   Kategorie(n): Professional & Technical, Science, Engineering
+
+Empfehlung dazu:
+
+   Harry Potter 6: Get your copy of Harry Potter and the Half Blood
+   Prince now! See all English Harry Potter Volumes...
+
+Gruss:
+
+Christian
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Amazon, Phosphor und Harry Potter... (Maharet, 11. Nov 2005, 09:35:51):
+~#! rn=Ronda rt=1131664698 rg=schmarrn.netdigest
+~#! tid=1131664698
+Aber das empfehlen die doch seit Monaten schon standardmaessig, egal, was du
+da kaufst.
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Amazon, Phosphor und Harry Potter... (Gloinson, 11. Nov 2005, 11:59:14):
+~#! rn=Maharet rt=1131698151 rg=schmarrn.netdigest
+~#! tid=1131664698
+Waere "Goblet of Fire" zu "Phosphor" nicht empfehlsnwerter?
+
+
+-----------------------------------------------------------------------------
+
+
+
+HP meets MP. (Ronda, 14. Nov 2005, 23:36:05):
+[SN: SPOILER! Wer 'Harry Potter und der Halbblutprinz' noch nicht 
+gelesen hat, bitte nicht weiterlesen!]
+
+From: Dorte =?iso-8859-1?Q?Sch=FCnecke?= <schuenecke@web.SPAMISEVILde>
+Newsgroups: de.alt.fan.harry-potter
+Subject: Re: Was =?ISO-8859-1?Q?w=E4re?= wenn...
+Date: Fri, 11 Nov 2005 12:22:17 +0100
+Message-ID: <1intwxds8k8m$.ls89n86kpibr.dlg@40tude.net>
+
+On Fri, 11 Nov 2005 12:05:33 +0100 Stefan Rauter wrote:
+
+
+>> "Ellen Fink" <talena@talena.de> schrieb am 11.11.05:
+>
+>>>> On Thu, 10 Nov 2005 12:38:00 +0100, Georg Burkhard
+>>>> <Georg.Burkhard@roma-online.de> wrote:
+>
+>>
+>
+>>>>>> * <spoilerspace>
+>>>>>> * Lorem ipsum dolor sit amet, consectetuer adipiscing
+>>>>>> * elit. Ut nec quam. Sed egestas justo at tortor. Nulla
+>>>>>> * at neque ac leo feugiat condimentum. Cum sociis
+>>>>>> * natoque penatibus et magnis dis parturient montes,
+>>>>>> * nascetur ridiculus mus. Aliquam cursus fermentum diam.
+>>>>>> * Pellentesque id quam in orci feugiat condimentum. Sed
+>>>>>> * adipiscing fermentum pede. Vivamus congue metus non
+>>>>>> * enim. Integer nec libero eget sem gravida viverra. Ut
+>>>>>> * erat. Nam tortor eros, venenatis et, vehicula in,
+>>>>>> * aliquam malesuada, magna. Pellentesque vel pede sit
+>>>>>> * amet orci fringilla scelerisque. Aenean mattis felis
+>>>>>> * a ligula. Integer sed odio. Suspendisse gravida. In
+>>>>>> * sodales fringilla tortor. Ut placerat lobortis nisl.
+>>>>>> * Integer augue enim, varius vel, accumsan ut, imperdiet
+>>>>>> * nec, pede. Donec consectetuer. Donec vitae dui id
+>>>>>> * massa tincidunt fermentum. Phasellus rhoncus sem at
+>>>>>> * eros. Vivamus orci massa, feugiat sed, porta vitae,
+>>>>>> * fringilla ac, enim. Nam facilisis.  Mauris commodo
+>>>>>> * sollicitudin ante. Phasellus eu velit ac felis ultrices
+>>>>>> * suscipit. Vestibulum rutrum dolor quis quam. Ut
+>>>>>> * dignissim. Sed nisl wisi, nonummy ut, egestas nec,
+>>>>>> * tempus in, tortor. Praesent venenatis felis vitae magna.
+>>>>>> * Nullam hendrerit eros eget est. Proin nibh velit,
+>>>>>> * accumsan eu, tempus id, vestibulum in, nulla. Ut at
+>>>>>> * leo. Vivamus at urna. Quisque justo purus, malesuada sit.
+>>>>>> * </spoilerspace>
+
+
+[Dumbledore lebt doch noch]
+
+The Dead Parrot Sketch
+
+Harry Potter: I wish to complain about this headmaster whom I
+purchased a few years ago from this very ministry.
+Fan of the Books: Oh yes, the, uh, the strange old fellow...What's,
+uh...What's wrong with him?
+HP: I'll tell you what's wrong with him, sir. 'E's dead, that's what's
+wrong with him!
+FotB: No, no, 'e's uh,...he's resting.
+HP: Look, matey, I know a dead headmaster when I see one, and I'm
+looking at one right now.
+FotB: No no he's not dead, he's, he's resting! Remarkable headmaster,
+the old Dumbledore, isn'it, ay? Beautiful beard!
+HP: The beard don't enter into it. He's stone dead.
+FotB: Nononono, no, no! 'E's resting!
+HP: All right then, if he's resting, I'll wake him up! (shouting at
+the coffin) 'Ello, Brian! I've got a lovely fresh sherbet lemon for
+you if you show...
+(Fan of the Books kicks the coffin)
+FotB: There, he moved!
+HP: No, he didn't, that was you kicking the coffin!
+FotB: I never!
+HP: Yes, you did!
+FotB: I never, never did anything...
+HP: (yelling and kicking the coffin repeatedly) 'ELLO BRIAN!! Testing!
+Testing! Testing! Testing! This is your nine o'clock alarm call!
+(Takes headmaster out of the coffin and thumps him head on the
+counter. Throws him up in the air and watches him plummet to the
+floor.)
+HP: Now that's what I call a dead parrot.
+FotB: No, no.....No, 'e's stunned!
+HP: STUNNED?!?
+FotB: Yeah! Snape stunned him! Headmasters stun easily, lad!
+HP: Um...now look...now look, mate, I've definitely 'ad enough of
+this. That headmaster is definitely deceased, and when I purchased it
+some years ago, you assured me that even Unforgivable Curses wouldn't
+harm him because he's Voldemorts Nemesis or something.
+FotB: Well, he's...he's, ah...probably pining for the fjords.
+HP: PINING for the FJORDS?!?!?!?What kind of talk is that? Look, the
+second Snape aimed that wand at him and this green light came, he
+dropped down DEAD!
+FotB: The headmaster  prefers keeping on it's back! Remarkable fellow,
+isn't he, squire? Lovely beard!
+HP: Look, I took the liberty of examining that headmaster when I got
+him home, and he's been Avada Kedavraed.  (pause)
+FotB: Well, o'course he was Avada Kedavraed! If Snape hadn't Avada
+Kedavraed him, he would have ruined the whole series by defeating all
+Death Eaters and thus robbing you of the great showdown in volume
+seven... but that doesn't mean he's dead. He'll come back in the next
+book, all twinkling eyes and energy, VOOM! Feeweeweewee!
+HP: "VOOM"?!? Mate, this headmaster wouldn't "voom" if you put four
+millionvolts through it! 'E's bleeding demised!
+FotB: No no! 'E's pining!
+HP: 'E's not pining! 'E's passed on! This headmaster is no more! He
+has ceased to be! 'E's expired and gone to meet 'is maker! 'E's a
+stiff! Bereft of life, 'e rests in peace! 'E's right now pushing up
+the daisies! 'Is metabolic processes are now 'istory! 'E's off the
+twig! 'E's kicked the bucket, 'e'sshuffled off 'is mortal coil, run
+down the curtain and joined the bleeding choir invisibile!! THIS IS AN
+EX-HEADMASTER!! (pause)
+FotB: But Snape is a good guy, he wouldn't do such a thing. So
+Dumbledore isn't dead. He may appear so, he may have been buried, all
+wizarding experts said he's dead but as a Fan of the Books I know he's
+not. I mean, come on, Harry! Are we expected to think that the
+juvenile hero will have to face his enemy alone in the last book of a
+series? How clich is that?
+HP: But -
+FotB: As if his death would make you any more determined to end
+Voldermort's terror! Hah! It's not like you draw any consequences. Not
+even leaving school, eh, to protect your friends or anything like
+that, eh? Not declaring that now you'll really go out to fight
+Voldemort, eh?
+HP: Yes, I did all of that.
+FotB: (blinks) You did?
+HP: Yes.
+FotB: When?
+HP: Well, after Dumbledore died.
+FotB: After he APPEARED to have died, you mean!
+HP: You're hopeless. (puts Dumbledore back in coffin and leaves the
+shop)
+
+
+
+
+Dorte
+
+-----------------------------------------------------------------------------
+
+
+
+DEN... (Ronda, 15. Nov 2005, 21:40:00):
+... fand meine bessere Haelfte gar nicht witzig. Hm.
+
+Ronda
+
+From: Lutz Schulze <lschulze@netzwerkseite.de>
+Subject: Re: Kreditkarte Einkommen Ehepartner
+Newsgroups: de.etc.finanz.misc
+Date:Sun, 13 Nov 2005 13:58:04 +0100
+Message-ID: <b2een1liuo9628vo5tqtupd0votliusnst@4ax.com>
+
+>>>> Wenn eine Ehefrau keinen eigenen Verdienst hat, kann sie dann eine
+>>>> Kreditkarte beantragen, und zaehlt das Einkommen ihres Mannes dann bei
+>>>> der Bonitaetspruefung fuer sie mit oder bleibt ihr eine eigene Karte
+>>>> grundsaetzlich verwehrt?
+
+
+...
+
+
+>>Was spricht gegen eine Partnerkarte auf ihren Namen ueber das Konto des
+>>Ehemanns?
+
+
+Der Ehemann?
+
+-----------------------------------------------------------------------------
+
+
+
+Passt grad so schoen ins Mud... (Ronda, 25. Nov 2005, 20:38:40):
+From: "Matthias P. Wuerfl" <do.not.REMOVETHAT@trullala.de>
+Newsgroups: de.alt.recovery.webauthor
+Subject: Re: Was ich gerade mache
+Date: Wed, 09 Nov 2005 09:54:19 +0100
+Message-ID: <3tdrpnFsdb8gU3@individual.net>
+
+Michael Praast schrieb:
+
+
+>> Oh, du gebierst schon wieder?
+
+
+Ich lasse gebaehren. Oder wie das im MTV-Deutsch Heutzutage 
+wahrscheinlich heisst: "Extreme Niederkunfting"
+
+Gruesse, Matthias
+
+-----------------------------------------------------------------------------
+
+
+
+Geschichten... (Ronda, 30. Nov 2005, 20:42:02):
+... die das Leben schreibt. Oder das Usenet. Trotzdem nett. Irgendwie.
+
+From: "Olaf Baumann" <newsgroup@olaf-b.de>
+Newsgroups: bln.verkehr
+Subject: Re: OT [BerlZ] Polizei mit sich selbst beschaeftigt
+Date: Fri, 25 Nov 2005 19:59:04 +0100
+Message-ID: <43875f24$0$20842$9b4e6d93@newsread2.arcor-online.net>
+
+Auch OT:
+Jemand war dieser Tage bei der Brandenburger Polizei, zu einer Art 
+Einstellungstest mit integriertem Bewerbungsgespraech und Psychotest.
+Frage der Polizeioberen an den Bewerber (genauer Wortlaut nicht bekannt):
+"Was wuerden sie machen, wenn sie in ihrem Revier auf Streife sind, das 
+Wetter sehr heiss und absolut nichts los ist?"
+...
+"Ein schattiges Plaetzchen suchen und blitzen."
+
+Und diese Antwort kam NICHT vom Bewerber.
+
+Gruss,
+Olaf 
+
+-----------------------------------------------------------------------------
+
+
+
+Manches WILL man nicht wissen. (Ronda,  9. Dez 2005, 23:52:13):
+From: Arnim Sommer <arnim@fahr-zur-hoelle.org>
+Newsgroups: de.alt.sysadmin.recovery
+Subject: Re: Disclaimer an emails...
+Date: Wed, 07 Dec 2005 10:42:31 +0100
+
+Gabriele Conrad schrieb:
+
+>> Arnim Sommer schrieb:
+>> 
+>> 
+>
+>>>>Was ist mit Netzhemden?
+>
+>> 
+>> 
+>> Was soll damit sein, ausser dass sie geschmacklos sind?
+>> 
+
+_Das_ stimmt so nicht. Wenn man die ordentlich durchschwitzt, werden die 
+salzig...
+
+A!S
+
+-----------------------------------------------------------------------------
+
+
+
+Nett. (Ronda, 10. Dez 2005, 00:03:36):
+Subject: Re: Translation
+From: Andreas Kabel <andreas.kabel@gmx.net>
+Date: Wed, 30 Nov 2005 15:27:50 -0800
+Message-ID: <dmlcej$5js$1@news.Stanford.EDU>
+Newsgroups: de.etc.sprache.deutsch
+
+Max Leibniz wrote:
+
+
+>> Ich habe eine Zeit lang geglaubt, Alpinski (Endung wie in Schimanski) sei
+>> der groesste Veranstalter von Wintersportreisen.
+
+
+Hervorragend. Tadeusz Alpinski, der polnische Erfinder der
+Sicherheitsbindung. Mindestens so gut wie der Bulgare
+Bogomil Poweronoff (Netzschalter).
+
+-----------------------------------------------------------------------------
+
+
+
+A little C programming (Ronda, 11. Dez 2005, 19:31:40):
+From: cxdocs.enet!dcha...@decwrl.UUCP (Dale - Colo Spgs ESDP 523-2202
+29-May-1991 0747)
+Newsgroups: rec.humor.funny
+Subject: A little C programming...
+Message-ID: <S2cd.1dd5@looking.on.ca>
+Date: 4 Aug 91 23:30:05 GMT
+
+For many years molecular biologists have been mystified by the fact that
+very little of an organism's DNA seems to serve any useful function.
+ 
+I have solved the mystery.
+ 
+The reason why only 30% of human DNA performs any useful function is that
+the rest of it is comments.
+ 
+Once we decode a typical human genome, we see that the contents begin as
+follows:
+ 
+===
+/* HUMAN_DNA.H
+ *
+ * Human Genome
+ * Version 2.1
+ *
+ * (C) God
+ */
+ 
+/* Revision history:
+ *
+ * 0000-00-01 00:00  1.0  Adam.
+ * 0000-00-02 10:00  1.1  Eve.
+ * 0000-00-03 02:11  1.2  Added penis code to male version. A bit messy --
+ *                        will require a rewrite later on to make it neater.
+ * 0017-03-12 03:14  1.3  Added extra sex drive to male.h; took code from
+ *                        elephant-dna.c
+ * 0145-10-03 16:33  1.4  Removed tail.
+ * 1115-00-31 17:20  1.5  Shortened forearms, expanded brain case.
+ * 2091-08-20 13:56  1.6  Opposable thumbs added to hand() routine.
+ * 2501-04-09 14:04  1.7  Minor cosmetic improvements -- skin colour made
+ *                        darker to match my own image.
+ * 2909-07-12 02:21  1.8  Dentition inadequate; added extra 'wisdom' teeth.
+ *                        Must remember to make mouth bigger to compensate.
+ * 4501-12-31 14:18  1.9  Increase average height.
+ * 5533-02-12 17:09  2.0  Added gay option, triggered by high population
+ *                        density, to try and slow the overpopulation
+problem.
+ * 6004-11-04 16:11  2.1  Made forefinger narrower to fit hole in centre of
+ *                        CD.
+ */
+ 
+/* Standard definitions
+ */
+ 
+#define SEX male
+#define HEIGHT 1.84
+#define MASS 68
+#define RACE caucasian
+ 
+/* Include inherited traits from parent DNA files.
+ *
+ * Files must be pre-processed with MENDEL program to provide proper
+ * inheritance features.
+ */
+ 
+#include "mother.h"
+#include "father.h"
+ 
+#infndef FATHER
+#warn("Father unknown -- guessing\n")
+#include "bastard.h"
+#endif
+ 
+/* Set up sex-specific functions and variables
+ */
+#include <sex.h>
+ 
+/* Kludged code -- I'll re-design this lot and re-write it as a proper
+ * library sometime soon.
+ */
+struct genitals
+   {
+#ifdef MALE
+   Penis *jt;
+#endif
+   /* G_spot *g;   Removed for debugging purposes */
+#ifdef FEMALE
+   Vagina *p;
+#endif
+   }
+ 
+/* Initialization bootstrap routine -- called before DNA duplication.
+ * Allocates buffers and sets up protein file pointers
+ */
+DNA *zygote_initialize(Sperm *, Ovum *);
+ 
+/* MAIN INITIALIZATION CODE
+ *
+ * Returns structures containing pre-processed phenotypes for the organism
+ * to display at birth.
+ *
+ * Will be improved later to make output less ugly.
+ */
+Characteristic *lookup_phenotype(Identifier *i);
+===
+ 
+...and so on.
+ 
+ 
+[ Note that God uses three-space tabs ]
+
+-----------------------------------------------------------------------------
+
+
+
+Die drei Urelemente (Ronda, 12. Dez 2005, 22:37:15):
+From: Mathias.Boewe@t-online.de (Mathias Bwe)
+Newsgroups: de.talk.romance
+Subject: Re: Wie Frau in Strassenbahn kennenlernen?
+Date: Thu, 8 Dec 2005 20:39:43 +0100
+Message-ID: <1h79lgn.1asl20axzis6qN@Mathias.Boewe.dialin.t-online.de>
+
+Rainer Ziegenbein <rainer.ziegenbein@e-technik.tu-chemnitz.de> wrote:
+
+
+>> Wie kann die Lehre von den vier Urelementen Feuer, Wasser, 
+>> Luft und Erde entstehen,
+
+
+*Drei* Urelemente bitte, nur drei. Durch einen bedauerlichen Fehler bei
+einer Transkription wurde ein Komma zuviel gesetzt, und dieser Felher
+zieht sich wie der hohe Eisengehalt des Spinats durch die Literatur. Im
+Origial sind lediglich Feuerwasser, Erde und Luft erwaehnt.
+
+Mathias
+
+-----------------------------------------------------------------------------
+
+
+
+Neee... (Ronda, 14. Dez 2005, 21:39:48):
+... ich mein den jetzt nicht persoenlich - aber ich find den trotzdem gut.
+
+Ronda
+
+From: Falk Willberg <FaWEGLASSENSPAMlk@dl3daz.de>
+Subject: Re: Disclaimer an emails...
+Newsgroups: de.alt.sysadmin.recovery
+Date: Wed, 07 Dec 2005 10:18:42 +0100
+Message-ID: <dn69dd$40c$1@news01.versatel.de>
+
+Andrea 'Princess' Wardzichowski schrieb:
+
+
+>> Lukas Barth <tinloaf_usenet@klo.goerresonline.de> wrote:
+
+...
+
+>>>> Todsichere Methode: In den Schrank schauen, Hand ausstrecken, das was
+>>>> oben liegt greifen, anziehen.
+
+
+Wie sonst?
+
+
+>> Das erinnert mich an meinen ersten Fehlgri^wFreund der aus diesem Grunde
+>> NUR blaue und wei?e Sachen kaufte
+
+
+Zwei Fehler: *Zwei* *Farben* - Aber wer wie ein Papagei rumlaufen will,
+soll das tun.
+Sonst: Schwarz.
+
+Falk
+
+-----------------------------------------------------------------------------
+
+
+
+Eierlikoer. Sachgerechte Verwendung. (Ronda, 23. Dez 2005, 20:26:33):
+From: Juergen Nieveler <juergen.nieveler.nospam@arcor.de>
+Subject: Re: Eierlikoer - wie trinkt man den?
+Newsgroups: de.alt.rec.getraenke
+Date: 19 Dec 2005 18:31:24 GMT
+Message-ID: <Xns9731C66279B2Ajuergennieveler@nieveler.org>
+
+Thomas Adams <thomas.o.adams@gmail.com> wrote:
+
+
+>> Trinkt man Eierlikoer pur?
+
+
+Wenn Du weiblich und aelter als 60 bist: Ja.
+
+Wenn Du der Werbung glaubst: Mit Bitter Lemon auffuellen.
+
+Wenn Du mir glaubst: Eierlikoerflasche vorsichtig nehmen, in den
+Muelleimer werfen, und stattdessen einen guten Single-Malt eingiessen.
+
+Juergen Nieveler
+
+-----------------------------------------------------------------------------
+
+
+
+Der Sinn der Eject-Taste. (Ronda, 23. Dez 2005, 20:27:19):
+From: Norman Brinks <norman_brinks@yahoo.de>
+Newsgroups: de.alt.fan.aldi
+Subject: Re: Tchibo Fernbedienung
+
+Message-ID: <1255kxabmlefd.28uzfaghawoe$.dlg@40tude.net>
+
+Sebastian Fischer <fischer82@gmx.de> schrieb:
+
+
+>>Matthias Wendt schrieb:
+>
+>>>>Hallo,
+>>>>kann es sein, dass auf der Tchibo-Fernbedienung nirgendwo eine eject-Taste
+>>>>definiert ist?
+>
+>>
+>>Nur so interssehalber, wozu braucht man eine Taste fuer eine Funktion,
+>>die man nicht aus der Entfernung nutzen kann? Hab ich mich schon immer
+>>gefragt....
+
+
+Wenn mein Sohn zu dicht vorm Fernseher hockt, kann ich ihn bequem von
+der Couch aus umschubsen.
+
+-----------------------------------------------------------------------------
+
+
+
+Hm. Ist das witzig - oder tragisch? (Ronda, 23. Dez 2005, 20:30:29):
+Subject: Re: Rosa Fluidum
+From: Michael Klaas <folie@gmx.net>
+Date: Mon, 12 Dec 2005 03:10:20 +0100
+Message-ID: <4044h0F18ao59U1@news.dfncis.de>
+Newsgroups: de.alt.talk.unmut
+
+Nico Hoffmann wrote:
+
+>> Sepp Neuper schreibt:
+
+
+[...]
+
+
+>>>> Nach meiner persoenlichen Meinung waren die 80er Jahre der letzte
+>>>> Zeitraum, in dem noch einigermassen hoerbare Musik produziert wurde.
+>>>> Danach kam groesstenteils nur noch Muell.
+>
+>> 
+>> Meine Mutter ist der Ansicht, dass die Zeit der einigermassen hoerbaren
+>> Musik in die 50er und die 60er Jahre fiel.
+>> 
+>> Wir werden eben alle aelter.
+
+
+Nunja. Ich wuerde, so rein musiktechnisch gesehen, trotzdem nur sehr
+ungern zur heutigen Jugend gehoeren.
+
+Frueher[tm] war doch alles einfacher, die Rollenverteilung war klar
+definiert: die Jugend entdeckt eine neue Musikrichtung, die geeignet
+ist, den vollstaendigen Verfall der guten Sitten und die endgueltige
+Verrohung der nachwachsenden Generation einzuleiten, und die Eltern-
+generation zeigt sich schockiert bis angewidert.
+
+Und heute? Der kleine Hosenscheisser kommt mit Tokio Hotel und/oder
+US5 um die Ecke, und Papa zeigt sich nicht etwa erschuettert, nein, er
+zeigt dem Kleinen wo der Hammer haengt, indem er mal kurz seine alten
+Punk-, NDW- und/oder Metal-Platten rauskramt und den Lautstaerke-
+regler auf Anschlag dreht. Das muss fuer den Nachwuchs doch frustrierend
+sein.
+
+Gruesse,
+Michael
+
+-----------------------------------------------------------------------------
+
+
+
+BINGO! (Ronda, 25. Dez 2005, 20:50:23):
+From: Stephan Lahl <s.lahl@gmx.de>
+Newsgroups: de.etc.sprache.deutsch
+Subject: Re: Herausgeber von Rechtschreibsoftware raet derzeit von
+Date: 14 Dec 2005 09:03:16 GMT
+Message-ID: <40a5ekF19mpstU1@news.dfncis.de>
+
+Michael Holdt <o-michl@ist-ganz-allein.de> wrote:
+> > Und im Denglisch heisst das ganze dann "Ich dishwatere mein Geschirr" 
+> > oder noch schlimmer "Ich dishwatere meinen Abwasch"
+
+Nein. "Ich besorge flexibel, teamfaehig und leistungsorientiert das asset
+management im food processing segment durch ganzheitliche Steuerung der
+hausinternen tool cleaning facility im operativen Betrieb unseres
+weltweit fuehrenden jungen Haushalts und leiste damit einen 
+entscheidenden Beitrag zur Werterhaltung der nahrungsorientierten 
+Investitionen im Rahmen unserer wegweisenden und innovativen culinary 
+key assets maintenance and servicing Strategie fuer das neue Millenium."
+
+Step"Bingo! Bingo! Bingbingbingbingo!"han
+
+-----------------------------------------------------------------------------
+
+
+
+Bahnhof?! (Ronda,  9. Jan 2006, 00:43:09):
+Date: Fri, 06 Jan 2006 13:45:13 +0100
+From: Ansgar Kursawe <A.Kursawe@nurfuerspam.de>
+Newsgroups: de.alt.recovery.scientist
+Subject: Re: Neujahrsvorsatz
+
+Joerg Dorchain schrieb:
+
+>> >> Haeufigste Frage an einen Soziologen: "Wozu braucht man das?"
+> > Zur Unterscheidung zwischen Soziologen und Psychologen:
+> > "Wissen Sie vielleicht, wo der Bahnhof ist?"
+
+Ein Zweizeiler? Ich bitte dich.
+
+Es antworten ihm ...
+
+ein Gespraechstherapeut: "Sie moechten wissen, wo der Bahnhof ist?"
+ein Psychoanalytiker: "Sie meinen diese dunkle Hoehle, wo immer 'was 
+Langes rein- und rausfaehrt?"
+ein Verhaltenstherapeut: "Heben Sie den rechten Fuss, schieben Sie ihn 
+nach vorn. Setzen Sie ihn auf. Sehr gut. Hier haben Sie ein Bonbon."
+ein Gestalttherapeut: "Du, lass es voll zu, dass du zum Bahnhof willst."
+ein Hypnotherapeut: "Schliessen Sie die Augen. Entspannen Sie sich. 
+Fragen Sie Ihr Unterbewusstsein ob es Ihnen bei der Suche behilflich 
+sein will."
+ein Provokativ-Therapeut: "Ich wette, da werden Sie nie draufkommen."
+ein Reinkarnationstherapeut: "Geh zurueck in der Zeit - bis vor Deine 
+Geburt. Welches Karma laesst dich immer wieder auf die Hilfe anderer Leute 
+angewiesen sein?"
+ein Familientherapeut: "Was ist dein sekundaerer Gewinn, wenn du mich 
+nach dem Weg zum Bahnhof fragst. Moechtest du meine Bekanntschaft machen?"
+ein Bioenergetiker: "Machen Sie mal sch... sch... sch...!"
+ein Esoteriker: "Wenn du da hin sollst, wirst du den Weg auch finden."
+ein Soziologe: "Bahnhof? Zugfahren? Welche Klasse?"
+ein NLP'ler: "Stell' dir vor, du bist schon im Bahnhof. Welche Schritte 
+hast du zuvor getan?"
+ein Coach: "Wenn ich Ihnen die Loesung vorkaue, wird das Ihr Problem 
+nicht dauerhaft beseitigen."
+ein Benchmarker: "Kennen Sie jemanden, der aehnliche Logistikprobleme 
+bereits erfolgreich geloest hat? Wie laesst sich dessen Vorgehen sinnvoll 
+auf Ihre Situation uebertragen?"
+ein Moderator: "Welche Loesungswege haben Sie schon angedacht? Schreiben 
+Sie alles hier auf diese Kaertchen."
+ein Zeitplanexperte: "Haben Sie ueberhaupt genuegend Pufferzeit fuer meine 
+Antwort eingeplant?"
+ein Manager: "Fragen Sie nicht lange. Gehen Sie einfach los."
+ein Priester: "Heiliger Antonius, gerechter Mann, hilf, dass er ihn 
+finden kann. Amen."
+ein Sozialarbeiter: "Keine Ahnung, aber ich fahr dich schnell hin."
+
+
+> > Joerg, noch geschaedigt von einem Dipl.-Soziologen als IT-Projektleiter
+
+Klingt fast schlimmer wie "MBA". Wir hatten drei dieser 
+Powerpoint-Junkies in der Firma und sind gluecklicherweise alle 
+losgeworden. Und die Firma hat es ausnahmsweise sogar ueberlebt. Ich frag 
+mich, wann McKinsey & Co auf den Trichter kommen, dass jemand der mehr 
+als 50% seiner Arbeitszeit an Powerpoint verbringt weder produktiv noch 
+intelligent sein kann.
+
+/Ansgar
+
+
+-----------------------------------------------------------------------------
+
+
+
+Ich freu mich echt... (Ronda,  3. Feb 2006, 22:29:45):
+... auf das Wochenende mit meinen beiden Neffen (5 3/4 und 2 1/2). Ja, tu ich.
+Aber ich kann das hier doch irgendwie nachvollziehen.
+
+Ronda
+
+From: "Christian E. Naundorf" <CEN@online.invalid>
+Newsgroups: de.soc.recht.strafrecht
+Subject: Re: Wie bekomme ich einen Anwalt nach Verhaftung?
+Date: Sun, 22 Jan 2006 02:45:36 +0100
+
+
+
+Christoph Neumann schrieb:
+
+> > Eine Vernehmung ist ja auch kein Kindergeburtstag.
+> > Nichtsdestotrotz ist das was Jens geschrieben hat ohne Zweifel
+> > unzulaessig, denn ein Wachhalten durch laute Geraeusche und grelles Licht
+> > ohne Sitz- oder Liegegelegenheit ist nichts anderes als 
+
+... ein Kindergeburtstag. Genau so laufen die ab.
+
+SCNR, gezeichnet: ein Vater
+
+-----------------------------------------------------------------------------
+
+
+
+Wow, sind ICE schnell! (Ronda,  7. Feb 2006, 23:35:54):
+Erstaunlich, was die Deutsche Bahn so alles schafft...
+
+Ronda
+
+From: Rainer Koenig <Rainer.Koenig.Usenet@gmx.de>
+Newsgroups: ger.ct
+Subject: Der neue ICE-Geschwindigkeitsrekord
+Date: Sun, 05 Feb 2006 19:06:23 +0100
+Message-ID: <87acd58yu8.fsf@Rainer.Koenig.Abg.dialin.t-online.de>
+
+Hallo,
+
+gerade beim Lesen der Wochenendausgabe unserer Zeitung auf folgenden
+Absatz gestossen:
+
+<Zitat Quelle="Augsburger Allgemeine vom 4.2.2006 Seite 11">
+Im ICE brems ein weiteres Problem ungestoerte Telefongespraeche aus: die 
+Geschwindigkeit. "Vereinfacht ausgedrueckt: Wenn der Zug schneller faehrt, 
+als die Wellen des Telefonsignals sich fortbewegen ist keine Verbindung
+moeglich", erklaert Vodafone-Mann Andersch. Dies sei bei Geschwindigkeiten
+von 300 Kilometern in der Stunde der Fall. Eine Loesung fuer dieses 
+Problem sei nicht in Sicht.
+</Zitat>
+
+Wow, wie gut dass wir nun das Einstein-Jahr schon hinter uns haben und
+alle auf dem Mozart-Trip sind. Oder hat die in meiner Perry Rhodan 
+Heftserie erwaehnte Erhoehung der Hyperimpdedanz tatsaechlich stattgefunden
+und die Ausbreitungsgeschwindigkeit der elektromagnetischen Wellen ist
+auf 300 km/h gesunken? Oder bewegen sich unsere ICE-Zuege gar mit 
+relativistischer Geschwindigkeit vorwaerts? 
+
+Grinsende Gruesse
+Rainer
+
+-----------------------------------------------------------------------------
+
+
+
+Ts... (Ronda,  9. Feb 2006, 23:10:20):
+... wenn der wuesste. Goetter sind ja auch nicht doof.
+
+Ronda *fies - und fast goettlich - grinsend*
+
+Subject: Re: Strg+Alt+Entf
+From: Klaus Urban <urban.nospam@lycos.de>
+Date: Wed, 08 Feb 2006 11:26:38 +0100
+Newsgroups: microsoft.public.de.german.windowsxp.sonstiges
+Message-ID: <dsch0p$3j1$03$1@news.t-online.com>
+
+
+Hallo Markus,
+
+Markus Burkhardt schrieb:
+
+[ergaenzt]
+>> > > Hallo,
+>> > > seit ca. 3 Tagen funktioniert der Task-Manager nicht mehr (Ich hatte
+mehrere 
+> >                                                                      
+^^^^^^
+>> > > Viren/Trojaner auf dem PC!). 
+> >   ^^^^^^^^^^^^^^
+[/ergaenzt]
+
+[..]
+> > 
+> > Setz den PC neu auf - alles andere waere so, als wuerdest du in einer
+> > Kupferruestung auf einem hohen Berg bei einem Jahrhundertgewitter die
+> > Goetter verfluchen - und zwar alle gleichzeitig.
+> > 
+netter Vergleich, aber die Ritterruestung ist ein Faradayscher Kaefig.
+
+Klaus
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Ts... (Orktoeter,  9. Feb 2006, 23:13:07):
+~#! rn=Ronda rt=1139523020 rg=schmarrn.netdigest
+~#! tid=1139523020
+Was nuetzt es dir, das es innerhalb des schmelzenden Kupfers fuer kurze Zeit
+Feldfrei ist?
+
+OrkT.
+
+-----------------------------------------------------------------------------
+
+
+
+Geschlechtsneutrale Formulierungen... (Ronda, 19. Feb 2006, 00:50:18):
+... beliebtes Thema. Hatte bei uns an der Uni dazu gefuehrt, dass ein
+kleinerer Studiengang mal jahrelang ohne gueltige Pruefungsordnung lief, weil
+die Ordnung wegen fehlendem fraueneinbeziehendem Sprachgebraucht nicht durch
+den Senat kam (es fehlte "Professorinnen und Professoren" - es gibt da
+trotzdem immer noch keine Professorin in dem Bereich) und wegen der
+Verzoegerung eine Rahmenordnung in Kraft trat, mit der das ganze dann
+endgueltig in den Rundordner ging.
+
+Aber eigentlich kommt hier nen netdigest-Artikel...
+
+Ronda
+
+From: Thomas Hochstein <thh@inter.net>
+Subject: Re: 1. RfD: Geschlechtsneutrale Formulierung der
+Einrichtungsregeln
+Newsgroups: de.admin.news.regeln
+Date: Fri, 17 Feb 2006 19:48:03 +0100
+Message-ID: <danr.0602171948.1372@windlord.akallabeth.de>
+
+Uwe Tetzlaff schrieb:
+
+> >Und wieder jemand, der den Unterschied zwischen Genus und Sexus nicht
+> >gepeilt hat. 
+
+Ich erinnere mich mit einem gewissen Vergnuegen an die Ueberarbeitung
+der Satzung einer Sprecherkonferenz der Rechtsreferendare, bei der man
+auch mit diesem Uns^Wwichtigen Anliegen ankam. IIRC stand die Mehrzahl
+der Teilnehmer der Sprecherkonferenz dem Vorhaben positiv gegenueber,
+war aber der Ansicht, dass ein solcher umfangreicher Eingriff dann auch
+direkt richtig gemacht werden sollte, um nicht erneute Aenderungen nach
+sich ziehen zu muessen und vor allem nicht eine "Diskriminierung" durch
+eine zu ersetzen.
+
+So bestand im wesentlichen Einigkeit darueber, dass es nicht ausreichen
+kann, jeweils "Referendare" durch "Referendarinnen und Referendare" zu
+ersetzen, denn da die bisherige Form eine Diskriminierung der
+weiblichen Referendare darstellte, waere das natuerlich eine
+Diskriminierung der maennlichen solchen, weil es keinen sachlichen
+Grund gibt, die - gleichberechtigten - Frauen immer zuerst zu nennen
+und ihre maennlichen Kollegen hintenan zu setzen. Insofern wurde es als
+erforderlich empfunden, mit der Formulierung regelmaessig abzuwechseln,
+wobei breites Einverstaendnis herrschte, aus Gruenden der ueberkommenen
+Hoeflichkeit bei der ersten Nennung den Damen den Vortritt zu lassen.
+Ein wenig strittig war hingegen, ob jeweils generisch zu wechseln sei
+oder spezifisch, sprich, da nicht nur "Referendare", sondern bspw.
+auch "Ausbilder" genannt waren, ob man jeweils zwischen
+"Referendarinnen und Referendare" und "Referendare und
+Referendarinnen" zu wechseln habe, auch wenn dazwischen
+"Ausbilderinnen und Ausbilder" (oder "Ausbilder und Ausbilderinnen")
+genannt werden, ob einfach ganz allgemein immer auf das Tupel
+"weiblich-maennlich" ein solches mit "maennlich-weiblich" folgen sollte,
+egal, ob es dort gerade um Referendare, Ausbilder oder kleine gruene
+Maenn^WWesen vom Mars ging.
+
+Leider konnte diese interessante Frage nicht mehr ausdiskutiert
+werden, da bereits zuvor die Frage eingebracht wurde, wie denn bei
+spaeteren Satzungsaenderungen zu verfahren sei, wenn eine Nennung
+zwischendrin wegfaellt oder hinzukommt. Es wurde die m.E. richtige
+Ansicht vertreten, dass man dann im gesamten Text neu die Verteilung
+der maennlich-weiblichen und weiblich-maennlichen Formen angleichen
+muesste. Bevor es zu weiteren Meinungsaeusserungen hierzu kommen konnte,
+kam dann leider ein Geschaeftsordnungsantrag auf Schluss der Debatte und
+sofortige Abstimmung dazwischen, der nahezu einstimmig angenommen
+wurde. [1] (Die Abstimmung dauerte allerdings noch ein wenig, weil
+inzwischen fast ein halbes Dutzend Antraege zur Abstimmung standen und
+es einiger Anstrengung der Versammlungsleitung bedurfte, den richtigen
+Abstmmungsmodus auszklamuesern, von wegen "zunaechst wird ueber den am
+weitesten gehenden Antrag abgestimmt" - ich war auch der Ansicht, dass
+man zu keiner richtigen, satzungsgemaessen Loesung kam, aber es herrschte
+eine allgemeine Diskussionsmuedigkeit, und aus irgendwelchen Gruenden
+wurden auch die folgenden, eigentlich durchaus wichtigen und
+kontroversen Tagesordnungspunkte nur noch eher formal durchgewinkt...)
+
+-thh
+
+(Ich sollte vielleicht gelegentlich mal meine wegweisenden Beitraege
+zur Frage der Gleichstellung und Chancengleichheit unter besonderer
+Beruecksichtigung des Sports oder ueber notwendige grammatikalische
+Anpassungen im Zuge der Verwirklichung des gender mainstreaming auch
+in der deutschen Sprache (wieder [2]) veroeffentlichen - aber besser
+nicht hier, glaube ich, und eigentlich fehlt mir dazu auch absolut die
+Zeit ...)
+
+[1] Die Antragstellerin, die den Aenderungsantrag urspruenglich
+eingebracht hatte, wirkte im uebrigen danach recht eingeschnappt und
+beklagte "mangelnde Ernsthaftigkeit". Mir unverstaendlich, ich habe
+diese nicht unwesentliche Fragen selten in dieser Ernsthaftigkeit und
+Tiefe diskutiert erlebt. Vielleicht war sie auch einfach beleidigt,
+weil ihr der Ausgang der Abstimmung nicht gefiel, es gibt ja solche
+Leute, denen demokratische Entscheidungen nur genehm sind, wenn sie
+die "richtigen" Ergebnisse haben. (Alle diesbezueglichen
+Aenderungsantraege wurden mit grosser Mehrheit abgelehnt.)
+
+[2] Letztere habe ich bereits vor nunmehr ~ 13 Jahren in einer
+Schuelerzeitung ... Es aendern sich eben nicht die Themen, sondern nur
+die Namen. Nicht nur im Usenet.
+
+-----------------------------------------------------------------------------
+
+
+
+Ich sag nur: Karlsruhe... (Ronda, 19. Feb 2006, 23:15:56):
+Newsgroups: de.etc.bahn.stadtverkehr
+Subject: Re: Karlsruher Tunnelplaene
+From: Branko Simic <Branko.Simic@gmx.at>
+Date: Thu, 16 Feb 2006 19:57:31 +0100
+Message-ID: <43F4CB1B.8BB65282@gmx.at>
+
+Marc Haber schrieb:
+> > 
+> > Nein, damit der Buergermeister aller Autos nicht bei jedem Blick aus
+> > dem Fenster daran erinnert wird, dass die von ihm regierte Stadt
+> > _nicht_ wegen ihrer wegweisenden Autotauglichkeit ueberregional
+> > bekannt ist.
+
+ach, sooo toll ist euer Fussballclub auch wieder nicht...
+;-)
+
+
+lg, BS
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Ich sag nur: Karlsruhe... (Bambi, 25. Feb 2006, 00:20:06):
+~#! rn=Ronda rt=1140387356 rg=schmarrn.netdigest
+~#! tid=1140387356
+Welcher Idiot bezeichnet Karlsruhe als autotauglich? Oder meinte er mit
+"autotauglich" so etwas, wie: "da will keiner mit dem Auto rein, also haben
+wir das Ziel erfuellt."?
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Geschlechtsneutrale Formulierungen... (Kellybundy, 27. Feb 2006, 19:31:16):
+~#! rn=Ronda rt=1140306618 rg=schmarrn.netdigest
+~#! tid=1140306618
+:winkt verzweifelt und auf verlorenem Posten mit einem 'Stoppt die
+Diskriminierung maennlicher Geiseln!'-Faehnchen.
+
+-----------------------------------------------------------------------------
+
+
+
+Weiss nicht... (Ronda,  4. Mar 2006, 23:45:43):
+... ob das ausser mir zum Schmunzeln findet. Schauen wir mal.
+
+Ronda
+
+From: Juergen Nieveler <juergen.nieveler.nospam@arcor.de>
+Subject: Re: Disclaimer in E-Mails
+Newsgroups: de.soc.recht.datennetze
+Date: 27 Feb 2006 15:53:01 GMT
+Message-ID: <Xns9777AAEE68286juergennieveler@nieveler.org>
+
+Walter@Loepsinger.de wrote:
+
+>> >> Was kann der Admin dafuer das der DAU zu bloed ist die 
+>> >> richtige Adresse einzutippen?
+> > 
+> > Alles.
+> > 
+> > 1. jeder Admin hat die DAUs die er verdient.
+
+Totschlag ist in .de immer noch verboten.
+
+> > 2. Sag mal ehrlich: werden bei Euch wirklich immer
+> > noch die Mailadressen jedesmal von Hand eingetippselt? 
+
+Nicht immer, letztens rief ein DAU bei uns an und wollte das sein 
+Adressbucheintrag geaendert wird. Seine lieben Kollegen sind leider zu 
+doof den richtigen Hn. Mueller aus dem Adressbuch zu waehlen, trotz 
+unterschiedlicher Vornamen und Namenszusaetze die eben dies ermoeglichen 
+sollen.
+
+Ich habe dann den Vorschlag gemacht das er seinen Nachnamen aendern 
+lassen soll - das wollte er aber auch nicht ;-)
+
+Juergen Nieveler 
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Weiss nicht... (Muadib,  4. Mar 2006, 23:49:35):
+~#! rn=Ronda rt=1141512343 rg=schmarrn.netdigest
+~#! tid=1141512343
+LART LART LART
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Weiss nicht... (Ronda,  4. Mar 2006, 23:57:05):
+~#! rn=Muadib rt=1141512575 rg=schmarrn.netdigest
+~#! tid=1141512343
+Grad schoene Erklaerungen zu LART und Co gefunden:
+http://de.wikipedia.org/wiki/LART
+... besonders Picnic (problem in chair not in computer) und
+UserNotQualifiedException haben was.
+
+Ronda
+
+-----------------------------------------------------------------------------
+
+
+
+Exmatrikulation... (Ronda,  5. Mar 2006, 00:14:31):
+... und Ausweisung nach Paderborn drohte den Verfassern dieser Zeilen (man
+beachte die Gruppenangabe).
+
+Ronda
+
+From: Matthias Botzen <matthias.botzen@rwth-aachen.de>
+Newsgroups: rwth.test
+Subject: Re: ARGH
+Date: Mon, 27 Feb 2006 16:57:00 +0100
+
+David Kolf schrieb:
+> > 
+> > 
+> > Hmm...ja, ich habe gerade gemerkt, dass das gestern nur der
+> > Kinderkarneval war. Und zwei Tage ist mir jetzt doch ein bisschen zu viel.
+> > 
+
+ZWEI?
+Und was war mit Donnerstag?
+
+> > Und ueberhaupt, wie haben die diese Demo-Route vom Ordnungsamt genehmigt
+> > bekommen?
+
+Im Gegensatz zu Studidemos oder irgendwelchen Zeckenaufmaerschen besteht
+bei den Karnevalisten halt nicht die Gefahr, dass sie die Stadt und
+Schutt und Asche legen.
+
+taetae
+
+Und die Strasse sieht danach auch noch ordentlich aus.
+
+taetae
+
+Und waehrend sich unbeteiligte Verkehrsteilnehmer in den erstgenannten
+Faellen ueber die Behinderungen und Wartezeiten aergern, wird ihnen dies
+beim Karneval durch die lustigen Koestueme und mitreissende Musik versuesst,
+sodass sie das alles sogar gerne in Kauf nehemen.
+
+taetae taetae taetae
+
+mfg
+matthias
+
+-----------------------------------------------------------------------------
+
+
+
+Festplatten (Ronda,  5. Mar 2006, 00:27:36):
+Wie funktioniert das eigentlich dann bei den neuen Platten mit dem
+"Perpendicular Writing" (oder wie auch immer das marketingtechnisch genannt
+wurde?) - muss man dafuer die Festplatte am SCSII-Kabel Lasso-aehnlich
+herumwirbeln?
+
+Ronda
+
+From: Christian Schneider <strcat@gmx.net>
+Newsgroups: de.comp.os.unix.linux.misc
+Subject: Re: Linux und Festplatten
+Date: Sat, 25 Feb 2006 11:33:12 +0100
+Message-ID: <2006-02-25T11-32-30@bofh.my-fqdn.de>
+
+Thus spake Frank Werner (frank@wesoft.de):
+>> >> Die Platte schoen waagerecht einbauen, damit die Bits und Bytes nicht
+>> >> unbewerkt runterfliessen.
+> >
+> > Die Einbaurichtung ist voellig unwichtig. Durch die hohen Fliegkraefte
+werden
+> > die Bits und Bytes eh an den Rand der Platten gedrueckt.
+
+Davor aber allen Dateien das Sticky-Bit verpassen, damit sie durch die
+Fliehkraft nicht von der HD fallen.
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Festplatten (Jimdigriz,  5. Mar 2006, 00:34:02):
+~#! rn=Ronda rt=1141514856 rg=schmarrn.netdigest
+~#! tid=1141514856
+Dazu sollte man sich unbedingt den Film von
+Hitachi anschauen, der das erklaert, natuerlich mit Sound
+
+"GET PERPENDICULAAAAAAAAAAAAAR!"
+
+http://www.hitachigst.com/hdd/research/recording_head/pr/PerpendicularAnimatio
+n.html
+
+Jdg
+
+-----------------------------------------------------------------------------
+
+
+
+Bombig. (Ronda,  5. Mar 2006, 00:36:26):
+Find ich zumindest.
+
+Ronda *Newsgroups aufarbeitend*
+
+From: Matthias Klodt <MatthiasKlodt@gmx.de>
+Newsgroups: de.alt.fan.tabak
+Subject: Re: Was raucht ihr gerade
+Date: Fri, 24 Feb 2006 15:19:07 +0100
+Message-ID: <dtn4ks$p0d$01$1@news.t-online.com>
+
+Moin daft,
+
+nach einem Spaziergang am Strand bei herrlichem Wetter nun MB Mix in 
+neuer Parker :-).
+
+Kleine Anekdote: Bei uns herrscht Vogelgrippealarm. Beim Spaziergang 
+wurden wir am Weitergehen von der Polizei gehindert (im Radio war was 
+von Schutzzone zu hoeren). Ich ganz locker zu dem Beamten: "Wir sind 
+geimpft". Der darauf: "Ach, gegen Fliegerbomben?" (Die wurde gerade bei 
+Hafenarbeiten gefunden). Nun ja, es wurde eh Zeit umzukehren ... ;-)
+
+Gruss
+Matten
+
+-----------------------------------------------------------------------------
+
+
+
+Gilt das so auch fuer die MPA-Diskussionen? (Ronda,  5. Mar 2006, 00:46:53):
+From: Cornell Binder <cobi@dafhs.org>
+Newsgroups: de.alt.folklore.usenet
+Subject: Re: Ein weitgehend vergessener Dienst
+Date: 22 Feb 2006 14:40:21 GMT
+Message-ID: <dtht4l$tbb2@cobis.msgid.de>
+
+Wolfgang Broeker <wolfgang@broeker.com> tat schreiben tun:
+> > Adrian Suter schrub[tm]:
+>>> >> >Pah, Modem. Ich habe noch per Floppyaustausch Usenet und E-mail
+bezogen.
+>> >> 
+>> >> Pah, Floppy. Ich habe noch Mails mit Federkiel und Tintenfass
+geschrieben.
+> > 
+> > Pah, Tinte. Mails werden mit Bronzewerkzeug auf Steinplatten oder
+Tontafeln
+> > verfasst, siehe <http://de.wikipedia.org/wiki/Bibliothek_in_Mesopotamien>
+> > fuer die Technik und
+<http://www.stub.unibe.ch/stub/vorl96/03/mes.html#bei>
+> > fuer eine reales Beispiel politischer Korrespondenz per stone mail.
+
+Mit diesen Mails konnten man seine Argumente wenigstens
+anderen um die Ohren schlagen und war sich der erhofften
+Wirkung sicher.
+
+
+CoBi
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Weiss nicht... (Muadib,  5. Mar 2006, 12:58:32):
+~#! rn=Ronda rt=1141513025 rg=schmarrn.netdigest
+~#! tid=1141512343
+ich empfehle das JargonFile
+http://www.jargon.net/
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Weiss nicht... (Kellybundy,  5. Mar 2006, 13:40:39):
+~#! rn=Ronda rt=1141513025 rg=schmarrn.netdigest
+~#! tid=1141512343
+Hupps. Hab das wort DAU wohl ganz falsch benutzt, da dazu nicht nur unkenntnis
+und dummheit, sondern auch Lernresistenz gehoeren. Danke fuer die Aufklaerung
+;-)
+
+-----------------------------------------------------------------------------
+
+
+
+Wie nennt man nun so einen Artikel? (Ronda,  9. Mar 2006, 22:25:05):
+Message-ID: <dn3qcq$8le$01$1@news.t-online.com>
+Subject:     Re: V: MSI-Dualboard mit 2x Tualatin
+From:        Sentuerk Ugras <sentuerk.ugras@web.de>
+Newsgroups:  de.markt.comp.hardware.cpu+mainboard
+Date:        Tue, 06 Dec 2005 11:49:36 +0100
+
+Alexander Tratsis wrote:
+
+> > Ich hab gestern Office 2003 auf ner Single-CPU-Kiste in 5 Minuten
+> > installiert. Tagelanges Compilieren ist was fuer Leute mit viel Zeit
+Das ist der unterschied zwischen sex und liebe
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Wie nennt man nun so einen Artikel? (Muadib,  9. Mar 2006, 22:26:31):
+~#! rn=Ronda rt=1141939505 rg=schmarrn.netdigest
+~#! tid=1141939505
+trollfood
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Wie nennt man nun so einen Artikel? (Knurps, 10. Mar 2006, 04:10:54):
+~#! rn=Muadib rt=1141939591 rg=schmarrn.netdigest
+~#! tid=1141939505
+Fanboy!
+
+-----------------------------------------------------------------------------
+
+
+
+Dell... (Knurps, 13. Mar 2006, 19:16:15):
+http://forum.digitalspy.co.uk/board/showthread.php?t=353477
+
+-----------------------------------------------------------------------------
+
+
+
+Fragt mich bitte NICHT... (Ronda, 13. Mar 2006, 23:06:42):
+... warum der Artikel "I love you!" heisst. Weiss ich nicht. Ich weiss nur,
+dass ich schmunzeln musste.
+
+Ronda
+
+From: "Christian Seidl" <seidl@indoger.unizh.ch>
+Subject: Re: I love you!
+Newsgroups: de.etc.sprache.deutsch
+Date:Thu, 9 Mar 2006 19:01:35 +0000 (UTC)
+Message-ID: <23eab3ca1be3d057e711389122063a1b.9343@mygate.mailgate.org>
+
+>> > > Hatte Pilatus ueberhaupt das Graecum? Und wenn ja, das kleine oder das
+grosse?
+
+> > Ob Pilatus gebildet war? Als hoeherer Staatsbeamter hatte er sicher Abitur
+...
+
+Nicht unbedingt. Kaiser Augustus hat den Gouverneur der Provinz 
+Aegypten abgesetzt hat (und das war so ziemlich die wichtigste Provinz 
+ueberhaupt, vergleichbar etwa mit dem Freistaat Bayern;), weil der mal
+in einem Brief "ixi" statt "ipsi" geschrieben hatte (offensichtlich,
+weil er beides gleich aussprach, naemlich als [issi]). Das koennte man
+sich heute gar nicht vorstellen, dass etwa der Bayerische Minister-
+praesident Muehe mit der deutschen Sprache hat.
+
+-----------------------------------------------------------------------------
+
+
+
+"Ich haette da gern mal nen iPaq mit Karos..." (Ronda, 24. Mar 2006, 23:42:30):
+... oder so aehnlich...
+
+Ronda
+
+Date: Sun, 19 Mar 2006 20:27:40 +0100
+From: Mirko Liss <mirko.liss@web.de>
+Newsgroups: de.alt.sysadmin.recovery
+Subject: Re: PDA fuer den Alzheimer-Admin
+
+
+Oliver Schad:
+> > kann jemand einen kleinen aber feinen PDA empfehlen, mit dem ich meine
+> > Alzheimer etwas besser in den Griff kriege, als mit 5 Millionen Zetteln,
+> > die ich staendig am Koerper tragen muss?
+
+Nimm ein Notizbuch aus Papier.  Damit kommst Du in den Genuss einer
+echten, nicht simulierten Multi-Page Appliance, und einer
+Displaygroesse, die im Verhaeltnis zur Geraetedimensionierung
+unschlagbar ist.  Und das Beste:  Du benoetigst keine Batterien!
+Lediglich die im Alltag allgegenwaertigen Stifte benoetigen alle
+paar Monate Ersatzminen.
+
+
+> > Wichtig waere Synchronisation unter Linux mit diversen KDE-Programmen.
+
+Als Schnittstelle dient zum Einen das 10-Finger-System, eine versatile
+Middleware, die direkt im Hirn installiert wird. 
+
+In der Gegenrichtung hat man die Auswahl zwischen einer Vielfalt von
+Schriftsystemen und -typen.  Besondere Erwaehnung verdient die unter
+Ingenieuren beliebte "Normschrift", sowie das anspruchsvollere "Steno",
+obwohl Kenner auf Kalligraphie nach dem Vorbild der Operina schwoeren.
+
+Hyperlinks sind nach Formatierung (Seitenzahlen) moeglich, Icons am
+Seitenrand vereinfachen ein schnelles Wiederauffinden von Informationen.
+
+Ein Notizbuch ermoeglicht die Ablage von Geschaeftskarten, Post-Its und
+Zetteln beliebiger Herkunft und beliebigen Inhalts, sogar von
+Papiergeld.  Die Verwendung eines Schubers oder eines umgeklappten
+Deckblatts stellt die Datenintegritaet dieser eingeschobenen
+Informationen sicher und gewaehrt zusaetzlichen Schutz in besonders
+rauen Umgebungen, etwa beim Sport oder auf der Flucht vor amoklaufenden
+Eingeborenen (der naechste Karneval kommt bestimmt).
+
+
+> > Das Display sollte man auch bei Sonnenlicht noch lesen koennen und einen
+> > Bollerwagen will ich ebenfalls nicht hinter mir herziehen muessen, um das
+> > Ding zu tranportieren.
+
+Die Lesbarkeit eines Notizbuchs ist gerade bei unguenstigen
+Lichtverhaeltnissen unuebertroffen.  Ein Notizbuch ist stossfest, bei
+Verwendung eines Kugelschreibers spritzwassergeschuetzt und auf
+Jahrzehnte archivierbar.
+
+Notizbuecher gibt es in einer Vielzahl von Formaten, die sich u. U.
+sogar vom Benutzer an die eigenen Beduerfnisse anpassen lassen.
+
+
+Und jetzt nennt mir einen PDA, der das alles bieten kann...
+
+-----------------------------------------------------------------------------
+
+
+
+Ein Schelm... (Ronda, 25. Mar 2006, 00:03:17):
+... der dabei an MPA Artikel denkt. Wie kann man nur!
+
+Ronda
+
+From: "Berthold Bronisz" <sparks667-killspam1@yahoo.de>
+Newsgroups: de.markt.arbeit.d
+Subject: Re: Die Hartz-Stasi kommt
+Date: Sat, 18 Mar 2006 19:40:15 +0100
+Message-ID: <dvhk6f$271$03$1@news.t-online.com>
+
+"Peter Voelpel" schrieb:
+
+> > Nein, ich glaube vielmehr, dass Dir jemand ins Gehirn geschissen hat,
+> > um mal bei Deinem Posting Stil zu bleiben
+
+Meine Postings sind Meilensteine an intellektueller Aussagekraft,
+tiefgruendige, sinnvolle Gedankenwerke, informative und wortgewaltige
+Loesungsansatze, Beitraege voller Authentitaet und Eigenstaendigkeiten,
+Inspirationen und Sachkenntnisse. Die facettenreiche
+Wortbildung, die schicksalhaften Variationen der Problemdarstellung und
+die sich steigernde Dramaturgie machen diese rudimentaer progressiv
+angehauchte Buchstabenkonstellationen zu einem phantastischen Erlebnis
+das man nie wieder vergisst und dich lehren soll, dass man, anstelle
+sich fortzubilden, auch genauso gut den Schaedel an einer Betonwand
+einrennen kann.
+
+Gruss
+Bert
+
+-----------------------------------------------------------------------------
+
+
+
+Wie viel Chaos... (Ronda, 25. Mar 2006, 00:06:39):
+... muss man eigentlich bei der WM erwarten? In Dortmund war jedenfalls die
+Woche trotz Spiel gegen die USA fast nichts zu merken...
+
+Ronda *hatte da wenigstens mit nen bisschen Stau oder so gerechnet...*
+
+Ps: Aeh. Ja, der Grund fuers Posting ist nen de.alt.netdigest-Artikel. Hier
+isser...
+
+From: Volker Marquardt <spampott@100.dbx.de>
+Subject: Re: WM-2007 minus 1 logo fuer alle
+Newsgroups: de.etc.beruf.selbstaendig
+Date: Sat, 18 Mar 2006 09:27:11 +0100
+Message-ID: <481upmFhcfr3U1@individual.net>
+
+[Quoting ergaenzt]
+
+Lutz Schulze schrieb:
+>> >>Ich welchen Land ist eigentlich diesmal
+>> >>die WM?
+
+> > Ich hoerte von einer geplanten Regelaenderung, dass der Gastgeber fuer
+> > das Endspiel gesetzt wird ;-)
+
+...fast richtig! Die Regel besagt, dass die Gastgeber-Mannschaft aus der 
+ersten Reihe des Stadions zuschauen darf ;-)
+
+Volker
+
+-----------------------------------------------------------------------------
+
+
+
+NEIN, das ist NICHT witzig! (Ronda, 25. Mar 2006, 00:09:25):
+From: Florian Weimer <fw@deneb.enyo.de>
+Subject: Re: Cebit
+Newsgroups: de.alt.sysadmin.recovery
+Date: Fri, 17 Mar 2006 22:42:33 +0100
+Message-ID: <878xr8lpdi.fsf@mid.deneb.enyo.de>
+
+* Arnim Sommer:
+
+> > Apropos: auf http://www.heise.de/cebit/highlights/ct/2006/06046/
+> > "Bei Microsoft wirft eine komplett neue Office-Generation ihre
+> > Schatten voraus - mit grundlegend neuer Bedienoberflaeche, neuem
+> > Dokumentenformat und Drumherum."
+
+Microsoft ist offenbar die einzige Firma, die in der Lage ist, ein mit
+Office nicht kompatibles Buerosoftwarepaket einzufuehren.
+
+-----------------------------------------------------------------------------
+
+
+
+Aeltere Leute mit graphischen Oberflaechen. Oder so aehnlich. (Ronda, 25. Mar 2006, 00:21:44):
+Erinnert mich an die aeltere (> 75 Jahre) alte Dame, die bei mir im
+Computerkurs war. Sie klagte, dass der Austausch der Grafikkarte ziemlich
+schwer waere. Weil das Rumrutschen auf den Knien einfach nicht mehr so einfach
+ginge und ihr Tower mit x Erweiterungen einfach zu schwer waere, um ihn auf
+den Tisch zu wuchten.
+Und ja: Die restlichen Fragen und Gespraeche machten klar, dass sie WIRKLICH
+alles an ihrem PC selbst rumschraubte. Sie hat sich uebrigens prima mit dem
+aelteren Herrn (ca 80) verstanden, der meinte, dass er schon so nen bisschen
+erstaunt war, als die Frau (nee, nicht die 75jaehrige...) auf der anderen
+Seite der Webcam ploetzlich angefangen haette sich auszuziehen.
+Seitdem bin ich ganz vorsichtig, was aeltere Menschen und Computer angeht.
+
+Ronda.
+
+Ps: Schon wieder den Artikel vergessen. Hier isser:
+[submitter's note: auf das wesentliche gekuerzt]
+
+From: Oliver Schnell <meine-wahrheit-deine-wahrheit@arcor.de>
+Subject: Re: Fehlende Bargeldannahme ausserhalb der
+Schalteroeffnungszeiten (warRe: Warum "Onlineticket" eingeschraenkt auf
+Fahrten von mindestens 51 km?)
+Newsgroups: de.etc.bahn.tarif+service
+Date: Fri, 17 Mar 2006 21:00:46 +0100
+Message-ID: <ol4m129gql3bfp87n1hg5lqm9sgj0v5tpl@4ax.com>
+
+On 17 Mar 2006 11:31:02 -0800, "Carsten Kanther" <jeanlucp@online.de>
+wrote:
+> >Im uebrigen haben gerade
+> >aeltere Leute, die nicht gerade mit graphischen Oberflaechen
+> >grossgeworden sind, so ihre Probleme.
+
+Dem Klischee hing ich auch mal an, bis mich eines Morgens (als es die
+online-Tickets erst wenige Monate lang gab) eine aeltere Dame (so Typ,
+weisshaarige, gut situierte Baden-Badenerin) im ICE KA - HH ansprach,
+als der Zub grade mein Online-Ticket kontrollierte, ob ich mit dem
+Mozilla auch immer Probleme haette, das Pdf-File angezeigt zu bekommen
+(oder irgend so ein Krempel in der Art). Das heisst nicht, jeder
+aeltere Mensch kommt mit neumodischem Krempel zurecht, es werden aber
+immer mehr, u.a. deshalb weil wir alle schlie?sslich aelter werden.
+
+Oliver Schnell
+
+-----------------------------------------------------------------------------
+
+
+
+Sockenschuss-Kalauer (Ronda, 25. Mar 2006, 00:26:40):
+Message-ID: <dumgo3$bao$1@news1.zdv.uni-mainz.de>
+Subject:     Re: Durchfall - Aepfel
+From:        Klaus Pommerening <pom@imbei.uni-mainz.de>
+Newsgroups:  de.alt.folklore.urban-legends
+Date:        Wed, 08 Mar 2006 12:54:08 +0100
+
+Dieter Bruegmann wrote:
+> > -<| Eva Preuss | Tue, 07 Mar 2006 15:29:45 +0100 |>-
+>> >>Schokolade stopft angeblich auch.
+> > Bloedsinn. Ich habe mal eine Tafel Schokolade an meine kaputten
+> > Socken gelegt, aber die Socken blieben kaputt.
+
+Du haettest Sie *in* die Socken legen sollen, natuerlich ausgepackt,
+und die Socken dann anziehen. Danach alles gut trocknen lassen.
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Wie viel Chaos... (Bambi, 27. Mar 2006, 23:33:26):
+~#! rn=Ronda rt=1143241599 rg=schmarrn.netdigest
+~#! tid=1143241599
+Zum erwarteten Chaos: Waehrend der WM-Spiele, an denen die englische
+Mannschaft (potenziell) teilnimmt, gilt fuer uns erhoehte Gefahrenstufe.
+
+-----------------------------------------------------------------------------
+
+
+
+Wie definiert man Liverollenspiel? (Ronda, 31. Mar 2006, 23:48:50):
+Betreff: Re: Pagan/Viking Metal
+Datum: Sat, 18 Mar 2006 05:50:43 +0100
+Von: Alexander Stein <al-xs@web.de>
+Organisation: 1&1 Internet AG
+Newsgruppen: de.alt.music.metal
+
+Wilko Finke schrieb:
+> > Steve Voeller schrieb:
+> > 
+>> >> Heino Tiedemann schrieb:
+>>> >>> Jetzt stellt sich natuerlich die Frage:
+>>> >>> Wa ist der Unerschied zuwischen Folk und Pagan Metal?
+>> >> Folk ist langsamer und "freundlicher" (z.B. Otyg) waehrend Pagan schon 
+>> >> von der Atmosphaere her dunkler ist und auch schneller.
+>> >> Folk: ueber die Wiese springen
+>> >> Pagan: durch den dunklen Wald gehen
+> > 
+> > Cool! Und was ist dann im Dunkeln besoffen ins Unterholz kacken und 
+> > quasi in Zeitlupe in die Brennesseln kippen, einpennen und am naechsten 
+> > Morgen mit 4 Zecken an den Afterballen aufwachend, plus Waldameisen im 
+> > Gemaecht rumwuseln habend?
+
+Das nennt man dann Liverollenspiel ;)
+
+Gruss
+alex
+
+-----------------------------------------------------------------------------
+
+
+
+Wie wuerde man das weiterfuehren? (Ronda,  1. Apr 2006, 00:25:00):
+Verstoss gegen Lebensmittelgesetz (Stichwort: Glykol): ab nach .at. Illegales
+Glueckspiel/Wettbetrug: ab nach .de?
+
+Ronda
+
+From: Thomas Huehn <huehn@usenet.arcornews.de>
+Newsgroups: de.soc.recht.strafrecht
+Subject: Re: Internationales Strafrecht
+Date: Thu, 23 Mar 2006 22:28:26 +0100
+Message-ID: <1k8maepzj0cff$.dlg@blackbox.thomas-huehn.de>
+
+Am Thu, 23 Mar 2006 20:59:55 +0100 schrieb Thomas Hochstein:
+> > Christian E. Naundorf schrieb:
+> >
+>> >> In absehbarer Zeit moeglicherweise doch. Ein entsprechender
+>> >> Regelungsvorschlag zum Ausschluss doppelter Strafverfolgung
+>> >> zumindest im Schengenraum, wenn nicht EU-weit, existiert
+>> >> bzw. wird derzeit diskutiert. Dann heisst es "NL eingestellt,
+>> >> ueberall eingestellt".
+> >
+> > Bin ich der einzige, der der Ansicht ist, man sollte vielleicht erst
+> > einmal die Rechtssysteme harmonisieren, bevor man die Entscheidungen
+> > gegenseitig anerkannt, oder waere das irgendwie uncool?
+
+Das sorgt aber doch fuer mehr Wettbewerb!
+
+Zukuenftig kann der Straftaeter seinen Gerichtsort frei in der EU waehlen;
+die
+Mitgliedsstaaten konkurrieren dann miteinander um die Kundschaft.
+
+Eventuell koennte man auch Spezialisierungen vornehmen, wodurch
+Kompetenzen
+in einzelnen Mitgliedsstaaten oder auch Teilen von Mitgliedsstaaten
+gebuendelt wuerden.
+
+Die Niederlande koennten beispielsweise den ganzen Btm-Bereich
+uebernehmen,
+die Italiener kriegen Korruption und sonstige Wirtschaftsstrafsachen.
+
+Undsoweiter undsofort.
+
+Thomas
+
+-----------------------------------------------------------------------------
+
+
+
+Sex versus Elektrosmog (Ronda,  1. Apr 2006, 00:32:45):
+Note: Der OP machte sich Sorgen um eine Verstaerkung von "Elektrosmog"
+durch Federkernmatratzen...
+
+From: Sebastian Blatt <sblatt+usenet0603@havens.de>
+Newsgroups: de.sci.physik,de.alt.recovery.scientist
+Subject: Re: Magnetfelder durch Federkernmatrazen?  (Re: Beurteilung
+von Giftstoffen - PUR-Schaum und Latexherstellung)
+Date: Tue, 21 Mar 2006 22:59:08 -0700
+Message-ID: <87ek0v3tqr.fsf@munin.blatt.net>
+
+Also: nach laengerem Nachdenken komme ich zu folgendem Schluss: Da die
+Federkernmatratze im (moeglicherweise schaedlichen!) Erdmagnetfeld
+gelagert ist, sollte man sich zunaechst einmal darueber Gedanken
+machen. Das Magnetfeld der Erde ist schliesslich ziemlich gross[1] und
+das sollte einem schon wesentlich mehr Sorgen machen als so ein Handy
+in der Hosentasche.
+
+Wenn man jetzt allerdings bedenkt, dass in so einer Federkernmatratze
+tatsaechlich potentielle Spulen (die Federn) eingebaut sind, ist die
+Loesung schon sehr nahe: Wenn die Spulen in Bewegung sind, induziert
+das Magnetfeld der Erde einen Strom in den Spulen. Nach der Lenzschen
+Regel[2] produziert dieser induzierte Strom ein seiner Ursache
+_entgegenwirkendes_ Magnetfeld!
+
+Demnach ist also eine Federkernmatratze in jedem Fall die bessere
+Schlafloesung, denn selbst ein bisschen Bewegung daempft das
+Erdmagnetfeld ein wenig aus.
+
+Die Loesung ist also sehr naheliegend und besticht durch ihre
+Einfachheit[3]: wir halten die Spulen in der Matratze staendig in
+Bewegung und verhindern somit Kontamination durch etwaige
+Magnetfelder[4].
+
+Fazit: Kinder sollten staendig auf ihren Betten huepfen, und ihre
+Eltern koennen sich kreativere Methoden zur Federkernoszillation
+einfallen lassen.
+
+HTH,
+Sebastian
+
+
+[1] http://www.ngdc.noaa.gov/seg/geomag/data.shtml
+[2] http://de.wikipedia.org/wiki/Lenzsche_Regel
+[3] http://de.wikipedia.org/wiki/Ockhams_Rasiermesser
+[4] Das Ganze funktioniert natuerlich nicht nur fuers Erdmagnetfeld,
+    sondern ist eine allgemeine Loesung dieser Probleme.
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Sex versus Elektrosmog (Ronda,  1. Apr 2006, 00:33:55):
+~#! rn=Ronda rt=1143844365 rg=schmarrn.netdigest
+~#! tid=1143844365
+Mal als Selbstreply, da im gleichen Thread.
+
+Ronda
+
+From: Patrick Kursawe <Patrick.Kursawe@web.de>
+Newsgroups: de.alt.recovery.scientist
+Subject: Re: Magnetfelder durch Federkernmatrazen?  (Re: Beurteilung von
+Date: Wed, 22 Mar 2006 14:20:18 +0100
+Message-ID: <48d18bFje98nU1@news.dfncis.de>
+
+Michael Holzt wrote:
+> > Sebastian Blatt wrote:
+>> >> Das Magnetfeld der Erde ist schliesslich ziemlich gross[1] und
+>> >> das sollte einem schon wesentlich mehr Sorgen machen als so ein Handy
+>> >> in der Hosentasche.
+> >
+> > Suizid waere eine Loesung fuer dieses Problem. Vermutlich auch die
+einzige.
+
+Nur wenn man Reinkarnation ausschliessen kann.
+
+Mein ja nur...
+
+Patrick
+
+-----------------------------------------------------------------------------
+
+
+
+Zeichensaetze, Fonts und die Maus (Ronda, 12. Apr 2006, 21:30:46):
+From: Michael Schierl <schierlm-usenet@gmx.de>
+Newsgroups: de.comm.software.newsreader
+Subject: Re: Wie Zeichensatz austauschen?
+Date: Thu, 06 Apr 2006 22:13:50 +0200
+Message-ID: <4435767d$0$11078$9b4e6d93@newsread4.arcor-online.net>
+
+Reinhard Zwirner <reinhard_zwirner@web.de> wrote:
+
+> >Michael Depke schrieb:
+>> >> 
+> >[...]
+>> >> Unterscheide bitte Zeichensatz und Font. 
+> >
+> >ich glaub's Dir ja, aber fuer mich besteht da irgendwie kein greifbarer 
+> >Unterschied.
+
+<mausmodus>
+
+Hallo. Heute erklaeren wir euch den Unterschied zwischen Zeichensatz
+und Font.
+
+Das ist ein Computer. Wir haben euch schon ein paar mal gezeigt, dass
+ein Computer nur mit Einsen und Nullen umgehen kann.
+
+Das ist der Reinhard. Er will einen Brief schreiben. Mit dem Computer.
+Der kann nur mit Einsen und Nullen umgehen. Irgendwie wird das aber
+ein komischer Brief, wenn der nur Einsen und Nullen haben darf. Aber
+obwohl der Computer nur mit Einsen und Nullen umgehen kann, kann der
+Reinhard trotzdem "Hallo" schreiben. Klingt komisch, ist aber so.
+
+Wie macht der Computer das? Er verwendet fuer jeden Buchstaben einfach
+8 Einsen oder Nullen. Beispielsweise nimmt er fuer ein A ein 01000001.
+Woher weiss der Computer aber, dass das ein A ist? Dafuer gibt es den
+Zeichensatz. Der Zeichensatz legt fest, welcher Buchstabe mit welcher
+Folge von Nullen und Einsen dargestellt wird.
+
+Diejenigen von euch, die schon in der Schule sind, haben vielleicht
+ausgerechnet, dass man mit diesen 8 Nullen und Einsen aber nur 256
+Zeichen darstellen kann - es gibt aber auf der Welt viel mehr Zeichen.
+Das ist der Grund, warum es verschiedene Zeichensaetze gibt, die auch
+nicht alle nur 8 Nullen und Einsen haben. Einer dieser Zeichensaetze,
+Unicode, verwendet ganz lange Folgen von Nullen und Einsen, um alle
+Zeichen, die es gibt (Fuer die Star-Trek-Fans: Ja, auch Klingonisch),
+darzustellen.
+
+Das will man aber nicht, weil dann brauchen die Zeichen auf der
+Festplatte so viel Platz. Deshalb gibt es noch andere Zeichensaetze,
+die nur einen Teil der Zeichen abdecken, und fuer jedes Zeichen 8
+Nullen oder Einsen brauchen. Nachdem im Unicode-Zeichensatz alle
+Zeichen drin sind, kann man diese Zeichensaetze ineinander umrechnen,
+indem man als Zwischenschritt Unicode nimmt. Dabei gehen aber, da
+jeder Zeichensatz verschiedene Zeichen enthaelt (sonst bringt es
+nichts), ein paar Zeichen verloren und werden durch Fragezeichen
+ersetzt.
+
+Nachdem es Leute gibt, die gaaanz viele Sprachen sprechen, brauchen
+die auch einen Zeichensatz. Dafuer hat ein ganz schlaues Kerlchen UTF-8
+erfunden. Das verwendet fuer haeufige Zeichen nur 8 Nullen oder Einsen,
+genauso wie die anderen Zeichensaetze; fuer seltenere Zeichen verwendet
+es aber mehr Nullen und Einsen.
+
+
+So, jetzt weisst du was ein Zeichensatz ist. Der Computer weiss jetzt
+also, wenn er 01001000 01100001 01101100 01101100 01101111 sieht, dass
+das Hallo heissen muss, und zwar indem er das nach Unicode umrechnet.
+Der Reinhard weiss das, wenn er die Einsen und Nullen sieht, aber nicht
+(und der Empfaenger des Briefes genausowenig). Der wuerde sich viel
+leichter tun, wenn er Buchstaben sehen wuerde, so aehnliche wie er mit
+der Hand schreiben kann. Nachdem der Computer aber keine Hand hat,
+braucht er eine Menge kleiner Bildchen [Schwenk auf einen Kasten mit
+Karteikarten], fuer jede Unicode-Nummer eines. Okay, nicht fuer jede,
+sondern nur fuer die Zeichen die der Reinhard benutzen will. Ein
+solcher Karteikasten mit Bildchen fuer die Unicodenummern heisst
+Schriftart oder Font. Die legt fest, wie die Buchstaben auf dem
+Bildschirm oder Drucker nachher aussehn.
+
+Verschiedene Schriftarten koennen verschiedene Zeichen darstellen. Das
+hat aber nichts mit dem Zeichensatz zu tun, sondern einfach damit,
+dass Schriftarten-Maler nicht so viel Zeit haben, um alle Zeichen zu
+malen.
+
+Nachdem der Reinhard eine Schriftart ausgewaehlt hat, kann er sein
+"Hallo" sehen und in Ruhe seinen Brief fertigschreiben.
+
+</mausmodus>
+
+Wie ueblich bei der Maus etwas vereinfacht (es gibt auch Schriftarten,
+die nicht mit Unicode indiziert werden), aber so grob passt's :)
+
+Michael
+
+-----------------------------------------------------------------------------
+
+
+
+Anwaelte und die Hoelle (Ronda, 12. Apr 2006, 21:34:14):
+Betreff: Re: Eigenes Buch risikolos nachdrucken
+Absender: Mark Obrembalski <markobr@web.de>
+Datum: Tue, 04 Apr 2006 23:05:34 +0200
+Message-ID: <49g5cuFo9cd8U3@individual.net>
+
+Michael 'Mithi' Cordes <mithrandir@news-2006-04.dvd-welt.de> schrieb:
+> > Mark Obrembalski fuellte insgesamt 69 Zeilen u.a. mit:
+> > 
+>> >>Der einzig sichere Weg,
+>> >>alle rechtlichen Risiken zu vermeiden, besteht sowieso im Selbstmord.
+>> >>Toten kann man keine Klage mehr zustellen.
+> > 
+> > SEHR gefaehrlicher Rat. Selbstmoerder kommen bekanntlich in die Hoelle,
+und
+> > was glaubst du wo Anwaelte nach ihrem Tod hinkommen? Na? Na?
+
+Nur schlechte Anwaelte kommen in die Hoelle. Gute Anwaelte verstehen es,
+ihren Prozess vor dem Juengsten Gericht auf ewig zu verzoegern.
+
+Gruss,
+Mark
+
+-----------------------------------------------------------------------------
+
+
+
+2001 - oder als das Internet noch ganz ganz neu war... (Ronda,  6. Mai 2006, 23:29:20):
+... fuer manche Polizisten...
+
+Ronda *ausm Urlaub wieder daheim und d.a.n abarbeitend*
+
+From: Kathinka Wenz <kathinka@rrr.de>
+Newsgroups: de.soc.recht.strafrecht
+Subject: Re: Was bewirkt Anzeige wegen Verleumdung?
+Date: Tue, 02 May 2006 19:49:22 +0200
+Message-ID: <e38d43.1vo.1@mausi.schnauze-sonst-beule.de>
+
+Stefan Schmitz <ss32@gmx.de> wrote:
+
+> >Lohnt sich eine Anzeige ueberhaupt? Faengt die Staatsanwalt Ermittlungen 
+> >an, oder werde ich direkt auf Privatklage verwiesen?
+
+Sie faengt an zu ermitteln, zumindest tat sie das bei mir, als ich
+http://groups.google.de/group/de.alt.technik.waffen/msg/c5bcc7379ed2c945?hl=de
+&
+anzeigte.[1] Der Name des Schreiberin wurde auch ermittelt, passiert ist
+trotzdem nichts (ausser, dass sie nie wieder im Usenet auftauchte).
+
+Die Frage ist, was du willst. Wenn es dir reicht, dass dein Kontrahent
+einen Schreck kriegt, weil sich ploetzlich die Polizei bei ihm meldet,
+dann koennte eine Anzeige reichen. Ob er dadurch die Bewertung
+zurueckzieht, ist aber schwer abzuschaetzen. Moeglich ist es natuerlich.
+Aber das dauert alles.
+
+Gruss, Kathinka
+[1] Selten so viel Spass gehabt wie bei der Aufgabe dieser Anzeige. Junge
+Polistin mit Schreibmaschine und keiner Interneterfahrung:
+P: Was war denn der Tatort?
+Ich: Das Internet.
+P: Nein, wo waren Sie, als sie das gelesen habe.
+Ich: Zu Hause in meinem Arbeitszimmer.
+P (tippt): Tatort: Arbeitszimmer
+
+-----------------------------------------------------------------------------
+
+
+
+RFID - Schmarrn? (Ronda,  6. Mai 2006, 23:37:01):
+From: "Lutz Sacher" <gs1150@onlinehome.de>
+Newsgroups: de.talk.tagesgeschehen,de.talk.jokes
+Subject: Re: Levi Strauss naeht RFID-Chips ein - und hat die Hosen voll
+Message-ID: <e32khi$7c7$1@online.de>
+
+
+"Holger Marzen" <holger@marzen.de> schrieb im Newsbeitrag 
+news:e32amj$3s1$2@bluebell.intern.marzen.de...
+> >* On Sun, 30 Apr 2006 14:13:23 +0200, Arthur Mai wrote:
+> >
+>> >> Koennte es nicht sein, dass man dann spaeter sich selbst ein solches
+>> >> RFID-Lesegeraet kaufen kann, das man an den PC anschliesst. Dann koennte
+man
+> >
+> > Ja.
+>> >> doch selbst nachgucken, was drauf ist und ggf. die Inhalte aendern?!? 
+>> >> Teuer
+>> >> kann das doch eigentlich nicht sein?
+
+Aendern ist da nicht
+> >
+> > In den meisten wird wohl ausser einer eindeutigen Nummer nicht viel drin
+> > stehen und auch nicht zu aendern sein. Richtig wertvoll sind die Daten ja
+> > erst, wenn sie mit einer Person verknuepft werden koennen, weil du die
+> > Ware mit Karte bezahlt hast (oder mit einem Geldschein, in dem ebenfalls
+> > ein Etikett ist und den du am Automaten mit deiner Karte geholt hast).
+> >
+>> >> Klingt das doof?
+> >
+> > Nein.
+> >
+> > Der Handel mit diesen Daten und auch das Auswerten wird ein ganz
+> > lukrativer Markt sein.
+
+Der Handel mit Daten IST ein lukrativer Markt..
+
+Mal ganz schwarz gesehen:
+
+Du wirst im Karstadt mit Namen gegruesst.
+Im C&A wird gefragt, ob es nicht eine neue Unterhose sein soll
+- deine ist ja schon 5 Jahre alt...
+Die Probefahrt bei Porsche wird aus der Kenntnis abgelehnt,
+das deine Komplettgarderobe 100 Euro nicht uebersteigt.
+Douglas macht die Tueren zu, da du ja eh nie kaufst....
+
+Deine Frau kann im Internet deine Hose geocodieren
+und sieht dass die Hose gerade in einem bekanntem
+Lokal an der Kasse ist, mit einer 0900 er nummer
+wird sie die Internetkamera zuschalten....
+
+Die Verkaeuferin im Edeka sieht dich vertraeumt an,
+sie weis, das du heute ohne Unterhose gekommen bist,
+mit einem blick auf den Verbrauch an Kondomen im letzten viertel Jahr
+kennt sie deine Aktivitaet.
+
+Deine Krankenkasse erhoeht die Beitraege um 1000%,
+ru rauchst und hast noch nie ein Sportgeraet gekauft,
+und isst zu fett.
+
+Die Polizei nimmt dich mit - weil dein Anorak ganz in der Naehe
+eines Tatortes gesehen wurde. Sie hat natuerlich Zugriff auf alle Daten
+wegen der Terrorgefahr.
+
+Nachdem die Geldscheine - wegen der zu haeufigen Faelschungen
+auch mit RFID ausgestattet wurde brauchst du kein Kassenbuch
+mehr fuehren. Du kannst es im Internet downloaden...
+
+Schon beim Laden betreten rennt jeder Verkaeufer hinter dir her
+- schliesslich hast du grade 5000 Eu in der Tasche.
+(die an der Tuer - an der Alarmanlage gegen Ladendiebstal
+"zufaellig" mit ausgelesen werden..)
+
+Den Psychologen kannst du dir sparen, aufgrund deiner
+Gewohnheiten, (Ausgewaehlte Filme in der Videothek,
+besuch diverser Shop`s und deinem Zeitungsabonement,
+der Kneipenrechnungen und des Zeitpunktes und der
+Zeitdauer) kommt der Ausdruck an jedem Automat.
+
+Natuerlich kann jeder Beamte nachvollziehen, dass
+du immer Dienstags gegen 16.00 Uhr eine Hartz4
+Empfaengerin mit 100 Eu. "beglueckst" die Sie dann
+sofort (ohne Meldung und Steuerabzug) sofort in den Aldi
+schafft. (Die duerfen die Daten wegen der Schwarzarbeit
+Europaweit ansehen..die Eu hat entsprechend verordnet.)
+
+Dein Kuehlschrank hat dich beim "fremdgehen" ertappt,
+das Kondom das er frueh noch "sehen" konnte
+ist jetzt nicht mehr da....dafuer hast du einen Slip
+den die Jenny, deine Nachbarin immer an hat,
+sehr nah an deinem Jeanshosen RFID Chip...
+(dein Sohn hat den Kuehlschrank wegen der Spiele
+mit der neuen Russischen Software gekrackt..)
+
+Die Waschmaschine macht bei einer voellig
+Anonymen umfrage mit und meldet dem
+Waschmittelhersteller den Zusammenhang
+deiner Unterhose und dem erhoehten
+Waschmittelverbrauch. Die Daten werden natuerlich
+mit dem neuen Sicherheitsstandard und der Nummer
+der Waschmaschine uebertragen.
+
+Die ersten Schadenersatzprozesse gegen Arbeitgeber
+sind grade gelaufen, nach dem im Intranet
+der Waeschewechsel der Angestellten in einer Exelliste
+aufgetaucht ist. (nicht nur die Preise , wechselintervalle,
+auch die Links zu den Herstellerbildern der Reizwaesche
+der Damen, die mit den Bildern der PersoAbteilung
+abgeglichen wurden, waren zu sehen...)
+Ausgelesen durch den RFID Zugangsrechner
+am Betriebstor, der die Arbeitszeit registrieren soll.
+
+fup zu de.talk.jokes konnte ich mir nicht verkneifen.
+Lutz
+
+-----------------------------------------------------------------------------
+
+
+
+Singles und Kinder und Kleenex. (Ronda,  6. Mai 2006, 23:50:27):
+From: Andreas Kroschel <kro@pobox.com>
+Newsgroups: de.alt.talk.unmut
+Subject: Re: Vom Untergang.
+Date: Fri, 28 Apr 2006 07:02:15 -0000
+Message-ID: <4371.4451bdf7.d7eb8@zabaione.sinusforschung.com>
+
+* Joerg Middendorf:
+
+> > ich habe eine Idee: Vielleicht sollte der Staat nicht immer nur an die
+> > Leute denken, die schon Kinder haben, sondern an diejenigen, die dazu
+> > praedestiniert sind, Kinder in die Welt zu setzen, naemlich Singles.
+
+Das kommt davon, wenn man Biologie abwaehlt. Beim Versuch, ein Kind in
+die Welt zu setzen, sollte einem normalgebildeten Single spaetestens beim
+Entsorgen des Kleenex auffallen, dass da, aehm, irgendwo eine Luecke im
+Zeugungsprozess ist.
+
+Andreas
+
+-----------------------------------------------------------------------------
+
+
+
+Schneewittchen, Zipfelmuetzen und so. (Ronda, 12. Mai 2006, 22:45:10):
+Da es grad passenderweise auf -allgemein um "haesslich mit Zipfelmuetze" ging,
+passt das schon irgendwie. Vorsicht: Bedingt jugendfrei. Amerikanische Leser
+bitte hier nicht weiterlesen.
+
+Ronda
+
+Subject: Sneewittchen und die (Ver-)Faelscher
+From: "A.Lange" <die_werbung_hierher@gmx.de>
+Date: Sat, 06 May 2006 20:49:55 +0200
+Message-ID: <445cedfc$0$4501$9b4e6d93@newsread2.arcor-online.net>
+Newsgroups: de.alt.talk.unmut
+
+Ja, nun kommt die juengste auch in das Alter, sich fuer das wohl schoenste 
+und deutscheste (Falls es da einen Superlativ gibt) Maerchen zu 
+begeistern.
+
+Und, wie um mich zu aergern, begann es mit dem Disney-Film und einem dazu 
+passenden Bilderbuch. Ganz abgesehen davon, dass die ganze Geschichte so 
+gut wie nichts mit dem eigentlichen Maerchen zu tun hat, koennte sie auch 
+sehr gut von gruenen Feministinnen der 68er Generation versaut worden 
+sein. Junge Frau findet versiffte Maennerbude, laesst Tiere aufraeumen und 
+kommandiert am gleichen Abend die Beitzer und Bewohner der Huette rum und 
+greit in ihre Privatangelegenheiten, wie Koerperhygiene, ein.
+
+Neben dieser wahrscheinlich schlechtesten Stoffadaption weltweit habe 
+ich auch noch Schallplatten mit dem schoenen Aufdruck "Litera", wo die 
+Koenigin wenigstens dreimal vorbeikommt, aber das Ende von humanistischen 
+Weicheiern um den Hochzeitstanz in gluehenden Schuhen bereinigt wurde. 
+Frau Koenigin faellt stattdessen tot zu Boden.
+
+Einzig eine Version in einem bei den Banater Schwaben gedruckten 
+Maerchenbuch hat das grauselige Ende drinne.
+
+Aber abgesehen davon, wenn man die Schallplatte 30mal gehoert hat, macht 
+man sich doch beim Lesen des Buches ein paar Gedanken und es tun sich 
+menschliche Abgruende auf:
+
+1. Mutter stirbt, Koenig (wohl eher Graf oder Edelmann) nimmt neue Alte, 
+die am 7. Geburtstag vom Spiegel unangenehmes hoert und das Stiefkind 
+ermorden lassen will. Der Vater hat wohl nichts zu melden, denn man 
+erfaehrt nirgend, ob er seine Tochter vermisst.
+Selbst wenn man annimmt, dass die Koenigin nicht sofort handelte, aelter 
+als 9 oder 10 wird Schneewittchen bei der Flucht nicht gewesen sein.
+
+2. Findet die Bergmannsbude, erzaehlt ihre Geschichte, ruehrt das Herz der 
+Zwerge "So dass ihr vor lauter Mitleder jeder einen Dienst erweisen 
+wollte." Jaja. Ich kann mir auch genau vorstellen, was die Zwerge sich 
+da vorgestellt haben. Bleiben durfte sie aber nur, wenn sie den Haushalt 
+schmeisst.
+
+3. Die Nummer mit dem Guertel kann man noch verstehen, aber wenn sie 
+aelter als 10 ist, kann man die wiederholte Daemlichkeit mit Kamm und 
+Apfel nur mit Lernresistenz erklaeren. Schoen, aber strohdoof.
+
+4. "Weil sie im Tode genauso schoen..." wie vorher war, stellten die 
+Zwerge den Sarg auf eine einsame Lichtung. Was wollten die denn da? 
+Glaeserner Sarg, einsame Ecke, gute Ausleuchtung. War das ihre Wichsecke?
+
+5. Der Prinz, ein paar Tage spaeter, stoert die Zwerge in ihrer Andacht, 
+kommt wieder und will die Kiste haben. Gibt an, er sei verliebt. Was 
+denn, nekrophiler Adliger?
+
+6. Schneewittchen wird wach und ohne zu zoegern willigt sie ein, den 
+paedophilen Leichenfreak zu heiraten. Beispielhafte Undankbarkeit den 
+Zwergen gegenueber, man weiss eben, wo man standesgemaess hingehoert Wie alt 
+wird sie da wohl sein...?
+
+7. Der erfreulichste Teil, die Hochzeit, zu der die boese Koenigin auch 
+hingeht, typisch weiblich Neugier. Da bereitet der Henker eiserne 
+Pantoffel vor, in der die Stiefmutter, nachdem sie zur Weissglut gebracht 
+wurden, bis zum Tode tanzen musste. Ich will nicht wissen ,wie das 
+gestunken hat. Abgesehen davon, dass das wohl eine ziemlich ungwoehnliche 
+Hochzeitsfeier war.
+
+So gesehen, bleibt von meinme Lieblingsmaerchen eigentlich nichts 
+positives uebrig, ich verkuendige hiermit meinen Unmut, durch staendiges, 
+ununterbrochenes Hoeren der Schallplatten zum Nachdenken angeregt worden 
+zu sein.
+
+Gruss
+Andreas
+
+-----------------------------------------------------------------------------
+
+
+
+Gastgeschenke. Ernsthaft. (Ronda,  7. Jun 2006, 22:49:13):
+... ich greife gern mal - aus aktuellem Anlass - die Frage dieses Postings
+auf: Was ist ein typisch Deutsches Mitbringsel, ueber das sich Indische
+Kollegen freuen koennten?
+
+Ronda *auf dem Weg nach MEZ +3,5*
+
+[Notiz des Einreichers: anonymisiertes firmeninternes Fundstueck]
+
+Newsgroups: xxxxxx.infoboerse
+Subject: Re: Geschenk fuer indische Kollegen?
+From: $VORNAME $NAME <$adresse@$firma.com>
+Date: Fri, 02 Jun 2006 09:11:14 +0200
+Message-ID: <e5ooai$ep1$1@xxxxxxxxxxx.de>
+
+>> >>von indischen Kollegen, die in XXX zu Besuch sind, werden wir ja des
+oefteren
+>> >>mit netten Gastgeschenken erfreut, kleine Buddha-Statuen "Gott der
+Weisheit"
+>> >>etc. Worueber freuen sich indische Kollegen, wenn ein Gegenbesuch
+stattfindet?
+> > 
+> > Manch einer wird denken ich meine das nicht Ernst, aber doch: Kuckucksuhr.
+> > Also was typisch Deutsches.
+
+Da habe ich den Verdacht, dass sich der indische Kollege zwar ueber die 
+Geste freut, mit der Kuckucksuhr selbst aber ungefaehr genausoviel 
+anfangen kann wie der durchschnittliche Deutsche mit einer Buddha-Statue.
+
+Viele Gruesse,
+
+-----------------------------------------------------------------------------
+
+
+
+Werktage und parken. (Ronda,  7. Jun 2006, 22:53:23):
+Parkgebuehren und so. Wobei man kaum teurer parken kann als in Amsterdam.
+Besonders wenn man sich eine Klammer einhandelt. Aber netterweise haben die da
+ne internationale Hotline und man kann mir Kreditkarte zahlen.
+
+Ronda
+
+From: Helmut Richter <hhr-m@web.de>
+Subject: Re: unter der Woche
+Newsgroups: de.etc.sprache.deutsch
+Date:Mon, 5 Jun 2006 11:03:58 +0200
+Message-ID: <Pine.LNX.4.63.0606051100510.13068@lxhri01.lrz.lrz-muenchen.de>
+
+> > Neben Fahrplaenen wirken auch Verkehrszeichen bildend: Es kann teuer
+> > werden, samstags dort zu parken, wo das Parkverbot nur werktags gilt.
+
+Ein so Bestrafter hat dann versucht, bei Ordnungsamt oder bei der Polizei 
+telefonisch den Amtsleiter oder wenigstens seinen Stellvertreter zu 
+erreichen. Das Gespraech ist etwa so verlaufen:
+
+- Wie gibts denn das? Am Werktag ist keiner zu erreichen?
+
+- Heute ist nicht Werktag; heute ist Samstag!
+
+- Danke, das wollte ich von Ihnen hoeren.
+
+Geholfen hats aber nichts. 
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Gastgeschenke. Ernsthaft. (Muadib,  7. Jun 2006, 22:58:46):
+~#! rn=Ronda rt=1149713353 rg=schmarrn.netdigest
+~#! tid=1149713353
+gurken
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Gastgeschenke. Ernsthaft. (Orktoeter,  7. Jun 2006, 23:00:06):
+~#! rn=Muadib rt=1149713926 rg=schmarrn.netdigest
+~#! tid=1149713353
+Einen Porsche/Audi/BMW/Mercedes.
+
+OrkT.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Gastgeschenke. Ernsthaft. (Darklor,  8. Jun 2006, 18:14:12):
+~#! rn=Orktoeter rt=1149714006 rg=schmarrn.netdigest
+~#! tid=1149713353
+Kondome?
+
+Darklor
+
+-----------------------------------------------------------------------------
+
+
+
+Bei Zimmer-frei hiesse das: "Im Artikel ist der Wurm drin" (Ronda, 15. Jun 2006, 00:01:08):
+Flach, ich weiss. Duennbrett halt. Empfehlung: Drei Weizenbier, dann passt der
+Artikel.
+
+Ronda
+
+From: "Christian Kraft" <ckraft@telebel.de>
+Subject: Re: Holzwurm
+Newsgroups: de.soc.recht.wohnen
+Date:Sun, 11 Jun 2006 22:14:05 +0200
+Message-ID: <op.tazztrq7dub5v1@pc281.domain.invalid>
+
+[SN: Teilzitat]
+
+> > Ich will hier nicht selber Holzwurmbekaempfung betreiben. Ich will eine
+> > einwandfreie Mietsache. Mich interessiert also durchaus die juristische
+> > Komponente der Sache. Kann ich den Vermieter zu einer "ordentlichen"
+> > Holzwurmbehandlung zwingen?
+
+Kommt auf Deinen Mietvertrag an - wurde der Wurm mitvermietet?
+
+-----------------------------------------------------------------------------
+
+
+
+Baeren. Und Baeren-Aufbinden. (Ronda, 15. Jun 2006, 00:52:50):
+From: Bjoern Schreiber <usenet-september@bjoernschreiber.de>
+Newsgroups: de.rec.fahrrad
+Subject: Re: Boxer springt Radfahrer an
+Date: Fri, 9 Jun 2006 07:19:01 +0200
+Message-ID: <1xuvk33wqb4q3$.dlg@bjoernschreiber.de>
+
+Am Thu, 8 Jun 2006 15:24:56 +0200 schrieb Konrad Hund:
+
+>> >> Bei den meisten Outdoor-Laeden (/-Versendern) gibt es Pfefferspray in 
+>> >> unterschiedlichen Packungsgroessen zu kaufen; mit Pfefferspray kann man 
+>> >> sogar ausgewachsene Baeren verjagen ...
+> > 
+> > Diesen Tipp sollte man allen Radfahrern in der Gegend um Mittenwald
+> > mitteilen. Wenn ich mir das gerade so vorstelle ... der Baer kommt,
+Radfahrer
+> > nestelt hektisch Pfefferspraydose hervor ...
+
+| Weil in letzter Zeit die Begegnung mit Grizzly Baeren und Touristen
+| drastisch zugenommen hat, gibt das Tourismus-Buero von Alaska folgende
+| Warnung an Wanderer, Fischer und jeden, der in der Wildnis herumstreift,
+| heraus:
+|
+| Wir raten allen, kleine, laute Gloeckchen an der Kleidung zu tragen,
+| damit Baeren nicht aufgeschreckt werden, wenn man sich ihnen naehert. Wir
+| raten weiter, eine Pfefferspray-Dose mit sich zu tragen, um den Baeren
+| damit abzuwehren. Vor allem sollte man immer nach Baerenaktivitaeten
+| Ausschau halten. Dazu ist es wichtig, dass man den Kot von Schwarzbaeren
+| und Grizzly-Baeren unterscheiden kann. Schwarzbaeren-Kot ist kleiner und
+| es befinden sich viele Beeren und Eichhoernchenfell darin. Grizzly-Kot
+| hat kleine Gloeckchen darin und riecht nach Pfeffer.
+
+HTH
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Baeren. Und Baeren-Aufbinden. (Darklor, 15. Jun 2006, 05:22:40):
+~#! rn=Ronda rt=1150325570 rg=schmarrn.netdigest
+~#! tid=1150325570
+Ich seh schon die Leute mit abgebissenen Armen durch die Gegend rennen... 
+
+Und viel witziger waer ja gewesen Ranger zum Touristen: "Und sehen sie diese
+Broeckchen? - Das war mal ein Mensch."
+
+Darklor
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Baeren. Und Baeren-Aufbinden. (Kellybundy, 16. Jun 2006, 21:10:31):
+~#! rn=Ronda rt=1150325570 rg=schmarrn.netdigest
+~#! tid=1150325570
+Und den Unterschied zwischen Schwarzbaer und Grizzly merkt der werte Wanderer
+wie folgt: Der Schwarzbaer klettert auf den Baum hinterher, der Grizzly faengt
+an, den Baum zu faellen...
+*GG*
+
+-----------------------------------------------------------------------------
+
+
+
+Fussball. Anders. (Ronda, 16. Jun 2006, 22:33:48):
+Na, die Sache klingt schraeg genug zum Nachmachen.
+
+Ronda
+
+Ps: Gibts andere "Locations", die den gleichen Schraegheitsgrad oder besser
+haben?
+
+From: Joerg Jonas <usenet.NOSPLAM.200510@ebbelex.de>
+Newsgroups: de.etc.bahn.stadtverkehr
+Subject: WM in der Strassenbahn
+
+Hallo,
+
+dank DVB-T, einem Notebook und einem USB-Stick ist es heutzutage
+ungeheuer leicht, sich ueberall von der Glotze berieseln zu lassen. So
+habe ich mir vorgenommen, das eine oder andere WM-Spiel an einem
+ungewoehnlichen Ort [tm] zu schauen. Begonnen habe ich die Serie mit
+dem Polen-Spiel, welches ich im Frankfurter Stadtwald auf dem
+Goetheturm sah. Das England-Spiel, das in Frankfurt stattfand, wollte
+ich in einem Zug der Linie 14 ansehen.
+
+Trotz massiver Verspaetungen auf meiner Zubringerlinie 16 konnte ich
+puenktlich zum Anpfiff einen Sitzplatz mit Tischchen in einem Pt-Wagen
+auf der Linie 14 bekommen. Ich baute mein Equipment auf, das Bild
+stabilisierte sich und nach wenigen Sekunden schoss Paraguay das
+Eigentor zum 1:0 Endstand - das konnten wir natuerlich nicht wissen.
+Die (wenigen) Fahrgaeste begannen, sich um die impovisierte Glotze zu
+klumpen. Immer, wenn die Bahn eine etwas hoehere Geschwindigkeit hatte,
+mutierte das bewegte Bild zu einem Standbild, was der Stimmung in der
+Strassenbahn keinen Abbruch tat.
+
+Zwischenzeitlich wurde der Zug durch demonstrierende Studenten
+aufgehalten, so dass wir 20 Minuten Verspaetung sammeln konnten. Nur
+zwei Ungeduldige stiegen vorzeitig aus, die anderen glotzten einfach
+weiter Fussball.
+
+Unser Zug wurde an der Louisa vorzeitig gewendet, der
+Strassenbahnfahrer kam in seiner Pause vorbei und wollte ein
+Zwischenergebnis wissen. Dann ging es wieder los in Richtung Bornheim.
+Auf der Obermain- - aeh - Ignatz-Bubis-Bruecke hatten wir freien Blick
+auf die im Main geparkten Videowaende und die englische Kulisse. Alle
+waren in Feierstimmung. Als die Strassenbahn an der Endhaltestelle in
+Bornheim wendete, blieben noch einige Fussballjunkies sitzen, auch der
+Fahrer sah sich noch einige Minuten des doch recht oeden Kicks an,
+bevor es wieder weiterging.
+
+Ich erhoffte mir eine spannende Schlussphase, als wir die letzten 10
+Minuten des Spiels in Neu Isenburg die Wendezeit abwarteten. Leider
+kam da nichts mehr rueber.
+
+Fazit: Es ist eigentlich ganz lustig, mit wildfremden Menschen ein
+Fussballspiel an einem Ort zu gucken, wo man normalerweise keine Spiele
+guckt. Vielleicht mache ich das nochmal in der Bahn. Als naechstes sehe
+ich mir ein Spiel im MiniMal an. Da gibt es dann wenigstens genug Bier
+in Reichweite.
+
+-JJ
+
+-----------------------------------------------------------------------------
+
+
+
+Kreuzfahrten und Diaabende. (Ronda, 19. Jun 2006, 22:38:33):
+From: Sascha Rheker <sascha@srheker.de>
+Newsgroups: de.rec.fotografie
+Subject: Re: Das Labor in Dielsdorf macht dicht
+Date: Thu, 15 Jun 2006 13:54:53 +0200
+Message-ID: <e6rhqd$rlu$03$1@news.t-online.com>
+
+>>> >>>Der legendaere Urlaubsdiaabend ist zurueck und die Geschichte
+wiederholt 
+>>> >>>sich mal wieder...
+>> >>
+>> >>Nur das man sich mittlerweile sehr viel mehr verunglueckte Bilder
+>> >>anschauen darf. In der Kroenung ist das eine mit Musik und
+>> >>Ueberblendeffekten versehen Multimediashow.
+> >
+> > Aber bitte immer "neue" Ueberblendeffekte, Saegezahn, Wellen, Puzzle,... 
+> > Dann wird's so richtig *gut*!
+
+
+"Ach, Gerda! Die Fotos die Heinz von unserer Kreuzfahrt gemacht hat
+sind spitzenklasse und waren als Diashows so beeindruckend als waere
+man dabei gewesen. Die Gaeste beim Diaabend waren genauso seekrank wie
+wir und haben sich uebergeben muessen. Einfach toll diese Digicam und
+das Slideshow-Progamm, viel besser als frueher."
+
+
+
+SASCHA
+
+-----------------------------------------------------------------------------
+
+
+
+Kindermund tut Wahrheit... oder isst in Wahrheit...? (Ronda, 19. Jun 2006, 22:39:25):
+Betreff: [OT] Re: Katzen-schimpf-thread (was: Katzen-schimpf-thread)
+Datum: Fri, 9 Jun 2006 20:35:54 +0200
+Von: Laurent Wirmer <news@wirmer.de>
+Rueckantwort: news@wirmer.de
+Foren: de.rec.tiere.katzen
+Referenzen: <e6bgvj$gag$00$1@news.t-online.com>
+<44896cc9$0$11628$4c56b896@news-read1.lambdanet.net>
+<e6c7bb$sq4$03$1@news.t-online.com>
+
+Am Fri, 9 Jun 2006 18:24:06 +0200 schrieb Patricia Hammerschmidt:
+> >
+> > Stimmt, dann waere es ziemlich oede...... es sei denn, ich haette da
+ausserdem
+> > noch den kleinen zweibeinigen Krabbelkaefer, der grade zu meinen Fuessen
+> > rumrutscht und mir am Bein zerrt ..... und den ich heute schon dreimal
+> > komplett umgezogen habe, weil er sowohl den Karottenbrei als auch den
+> > Reisschleim ( klingt ja auch schon so eklig ) teilweise rueckwaerts
+gegessen hat.
+
+Kennst du schon die Kinder-Diaet? Hier isse:
+
+Die neue Kleinkind-Diaet!
+
+Sie werden bemerkt haben, dass die meisten Zweijaehrigen ziemlich schlank
+sind.
+
+Nach Ruecksprache mit Kinderaerzten, Roentgenologen und verzweifelten
+Muettern war ein Freund von mir in der Lage, diese neue Diaet zu
+formulieren. Sie ist preiswert, bietet abwechslungsreiche Mahlzeiten und
+ausreichende Mengen.
+
+Bevor Sie mit der Diaet beginnen, konsultieren Sie Ihren Arzt. (Sonst
+muessen Sie Ihn moeglicherweise hinterher aufsuchen.)
+
+Viel Glueck!
+
+Erster Tag
+
+Fruehstueck: ein Ruehrei, ein Stueck Toastbrot mit Pflaumenmus. Essen Sie
+zwei Bissen Ei mit den Fingern, das restliche Ei werfen Sie auf den
+Boden. Nehmen Sie einen Happen Toast und schmieren Sie das Pflaumenmus
+auf Ihr Gesicht und Ihre Kleidung.
+
+Mittagessen: Vier Wachsmalkreiden (Farbe ist egal), eine Handvoll
+Kartoffelchips und ein Glas Milch (3 Schluck, den Rest kippen Sie auf
+dem Tisch aus.)
+
+Abendessen: Eine Salzstange, zwei Eincent- und ein Fuenfcentstueck, vier
+Schluck abgestandenes Bier.
+
+Snack: Toasten Sie ein Stueck Brot und werfen Sie es auf den
+Kuechenfussboden.
+
+Zweiter Tag
+
+Fruehstueck: Scheibe Toastbrot vom Vortag vom Kuechenboden. Dazu eine halbe
+Flasche Vanilleextrakt oder ein Schnapsglas Pflanzenfarbe.
+
+Mittagessen: Einen halben Lippenstift Farbe "Pulsating Pink" und einen
+Zigarettenstummel (essen, nicht rauchen!). Dazu einen Eiswuerfel.
+
+Snack: Lutschen Sie einen Dauerlutscher gut feucht, nehmen Sie ihn dann
+mit in den Garten und werfen ihn in den Matsch. Dann lutschen Sie ihn
+wieder sauber. Danach auf den Teppich kleben.
+
+Abendessen: einen Kieselstein oder eine trockene Erbse wird bis zum
+Anschlag in das rechte Nasenloch gesteckt. Giessen Sie ein Glas Eistee
+ueber Kartoffelbrei und geniessen Sie dies mit einem Loeffel.
+
+Dritter Tag
+
+Fruehstueck: zwei Pfannkuchen mit recht viel Sirup, mit den Fingern
+gegessen.
+Den Rest in die Haare schmieren. Von einem Glas Milch trinken Sie die
+Haelfte, dann stopfen Sie ein Stueck Pfannkuchen in das Glas. Nach dem
+Fruehstueck holen Sie den Dauerlutscher von gestern vom Teppich, lutschen
+die Fusseln ab und legen ihn auf Ihren besten Sessel.
+
+Mittagessen: Drei Streichhoelzer und ein Sandwich mit Erdnussbutter und
+Marmelade. Spucken Sie einige Bissen davon auf den Fussboden. Giessen Sie
+ein Glas Milch auf dem Tisch aus und schluerfen Sie auf.
+
+Abendessen: ein Becher Eiskrem, eine Handvoll Kartoffelchips, etwas
+Wein, danach kalter Kaffee.
+
+Letzter Tag
+
+Fruehstueck: eine Vierteltube Zahnpasta (Geschmack egal), ein Bissen
+Seife, eine Olive. Geben Sie ein Glas Milch ueber eine Schuessel
+Cornflakes, dazu eine halbe Tasse Zucker. Wenn die Cornflakes gut
+eingeweicht sind, schluerfen Sie die Milch auf und fuettern die Cornflakes
+dem Hund.
+
+Mittagessen: Suchen Sie die Kruemel vom Kuechenfussboden und vom Teppich im
+Esszimmer und essen Sie sie auf. Holen Sie den Dauerlutscher vom Sessel
+und lutschen Sie ihn fertig.
+
+Abendessen: Spaghetti mit Fleischkloesschen, dazu Kakao. Lassen Sie die
+Fleischkloesschen auf dem Teller. Als Nachtisch stecken Sie sich das
+Buerstchen aus der Wimperntusche in den Mund.
+
+Viel Erfolg!
+
+-----------------------------------------------------------------------------
+
+
+
+Vielosoffen. (Ronda, 28. Jun 2006, 23:22:39):
+Siehe auch "Die Philosoffen" von den Wise Guys:
+http://www.wiseguys.de/liedtexte/philosoffen.htm
+
+From: Volker Gringmuth <einklich@gmx.net>
+Newsgroups: de.alt.recovery.webauthor
+Subject: Re: Hallo Leute, brauche dringend Hilfe
+Date: Mon, 26 Jun 2006 20:40:48 +0200
+Message-ID: <44A02A30.7010208@gmx.net>
+
+Wolfgang Krietsch schrieb:
+
+> > Das Wort Philosophie kommt auch urspruenglich aus dem Russischen, es ist
+> > eine Ableitung der Redensart "Mein Schwager Boris, der soff so viel". Die
+> > Vielosoffie wurde in Russland erfunden von Juri Aristotenow und Alexej
+> > Pythagorej. Die Griechen behaupten nur immer, sie seiens gewesen, um von
+> > den nackten Knaben auf den alten griechischen Vasen abzulenken.
+
+Drueck Dich doch mal Clara aus.
+
+Stellen sie die Behauptung, die Vielosoffie erfunden zu haben, auf, um
+dadurch (wen einklich?) von den nackten Knaben abzulenken, oder
+behaupten sie, die Vielosoffie zum Zwecke der Ablenkung (wessen
+einklich?) von den nackten Knaben erfunden zu haben?
+
+
+vG, verwirrt
+
+-----------------------------------------------------------------------------
+
+
+
+Welchen Titel nimmt man denn da? (Ronda, 29. Jun 2006, 00:36:52):
+- "Makaber: Britischer 'Humor'"?
+- "Die Amerikaner werden so was nie lernen..."
+
+Ronda
+
+From: Markus Machner <Machner-Markus@t-online.de>
+Newsgroups: de.soc.recht.strafrecht
+Subject: Re: In Italien eine festgeschriebene Straftat!
+Date: Mon, 26 Jun 2006 12:03:11 +0200
+
+Carlos Duerschmidt schrieb:
+
+> > Abgesehen
+> > davon sollten die ausgeloesten Geiseln bei der Lieferung
+> > noch aus allen ihren Organen einschliesslich Blut bestehen.
+
+Das erinnert mich an den britischen Brief der SAS an Beduinen in sechs
+Sprachen. Kennst Du den auch?
+
+Lieber Beduine,
+Der Ueberbringer dieses Papiers ist ein britischer Offizier. Uebergib den der
+naechsten britischen Streife und Du bekommst 5000 britische Pfund in Gold.
+Allerdings nur, wenn der britische Soldat vollstaendig ist, und jedes
+Koerperteil an seinem Platz, also die Hoden nicht in den Mund gestopft oder
+so aehnliches.
+
+Angeblich soll das Papier manchmal gewirkt haben. Die Amis im Golfkrieg
+waren ziemlich erstaunt darueber.
+
+Gruss,
+Markus
+
+-----------------------------------------------------------------------------
+
+
+
+Geiselnahme: Was traegt man bei der Gewerbeanmeldung ein? (Ronda, 29. Jun 2006, 00:39:04):
+From: Carlos Duerschmidt <carlos4444@gmx.de>
+Newsgroups: de.soc.recht.strafrecht
+Subject: Re: In Italien eine festgeschriebene Straftat!
+Date: Sat, 24 Jun 2006 00:20:18 +0200
+Message-ID: <449c691e$0$4515$9b4e6d93@newsread2.arcor-online.net>
+
+Markus Machner <Machner-Markus@t-online.de> skrev:
+
+> >Wie bekommt man als Erpresser und Geiselnehmer eine Umsatzsteuer-ID?
+
+Man beantragt sie beim Bundesamt fuer Finanzen, Aussenstelle Saarlouis.
+
+Allerdings koennte sich die USt.-IdNr. als ueberfluessig erweisen, 
+denn die Lieferung von menschlichen Organen, menschlichem Blut und 
+Frauenmilch sowie die Befoerderung von kranken und verletzten 
+Personen mit Fahrzeugen, die hierfuer besonders eingerichtet sind,
+sind gemaess 4 UStG ohnehin von der Umsatzsteuer befreit. 
+
+Ich kenne mich mit den Gepflogenheiten in der Entfuehrungsbranche
+nicht gut aus, nehme aber an, dass die Geiseln zum Zeitpunkt
+der Lieferung normalerweise nicht mehr gesund sind und mit
+Fahrzeugen transportiert werden, die durch Verdunkelung der
+Scheiben fuer diesen Zweck eingerichtet wurden. Abgesehen
+davon sollten die ausgeloesten Geiseln bei der Lieferung
+noch aus allen ihren Organen einschliesslich Blut bestehen.
+
+> >Welches Gewerbe meldet man dazu an?
+
+"Geiselnahme und Erpressung en gros und en detail" natuerlich.
+Ob das akzeptiert wird, weiss ich nicht, aber in einem mir 
+bekannten Fall war die Gewerbemeldestelle immerhin bereit, 
+"Handel mit gefaelschten Ausweisdokumenten" einzutragen.
+
+Gruss
+Carlos
+
+-----------------------------------------------------------------------------
+
+
+
+Darwin (Ronda, 29. Jun 2006, 01:19:28):
+Nein, nicht die Awards. Auch wenn die auch schoen sind.
+
+Ronda
+
+From: Dieter Bruegmann <use-replyto@bruhaha.de>
+Subject: Re: Achtelfinale
+Newsgroups: de.alt.fan.aldi
+Date:Sun, 25 Jun 2006 08:44:14 +0200
+Message-ID: <e7licu.3vv5m5n.2@boogie.bruhaha.de>
+
+-<| Achim Roessler | Sat, 24 Jun 2006 23:36:34 +0200 |>-
+
+> > Da werden seit Tagen Unmengen von Feuerwerkskoerpern zu den unmoeglichsten
+> > Tages und Nachtzeiten(!) verballert, dass an Ruhe nicht zu denken ist.
+> > Dazu das Gehupe stundenlang. Und auf dem Rueckweg vom Einkauf springten
+> > ploetzlich 5 Leute fahnenschwingend und groelend vom Gehweg auf die
+> > Strasse, so dass nur knapp (dank geringer Geschwindigkeit) ein Unfall
+> > vermieden werden konnte.
+
+Pech fuer Darwin. Aber es wird schon noch klappen.
+
+
+Da Didi
+
+-----------------------------------------------------------------------------
+
+
+
+FKK-Fahrradkauf (Ronda, 29. Jun 2006, 01:23:48):
+Brrr.... allein der Gedanke tut irgendwie weh...
+
+Ronda
+
+[Anm. d. Einreichers: Kaum zu glauben, auf was man beim Fahrradkauf
+alles achten muss und welche ungeahnten Sicherheitsrisiken trotz Helm
+noch lauern koennen. Das Posting wurde hier und da etwas gekuerzt und im
+Quoting leicht umformatiert.]
+
+From: gatzigkh@domain.invalid (Karl-Heinz Gatzig)
+Subject: Re: Offenliegende Bowdenzuege
+Newsgroups: de.rec.fahrrad
+Date: Thu, 22 Jun 2006 20:48:03 +0200
+Message-ID: <1hhcjdu.s93jv6g9pbi8N@gf6hw5k9tf4>
+
+>>>>> >>>>>Ich spiele mit dem Gedanken, mir ein neues Radl zuzulegen. [...]
+>>>>> >>>>>Eins stoert mich aber. Auf dem Oberrohr liegen zwei Bowdenzuege
+offen da
+>>>>> >>>>>Da sie offen auf dem Oberrohr verlaufen, bilde ich mir eine
+>>>>> >>>>>Verletzungsgefahr ein (Skrotum bleibt haengen).
+
+>>>> >>>>Das ist eine weit verbreitete Art, Zuege zu verlegen. [...]
+>>>> >>>>Weniger Gewicht, weniger Reibung. [...]
+>>>>> >>>>>(Skrotum bleibt haengen).
+>>>> >>>>Wie soll _das_ bitte gehen?
+
+>>> >>>[...] FKK-Urlaub an der Ostsee [...]
+
+>> >>Man koennte [...] was konstruieren. Also setze man sich, in
+>> >>FKK-Standardkleidung, direkt auf den Zughalter und betaetige die Bremse.
+Mit
+>> >>etwas Glueck^WPech zieht es nicht nur den Draht in die Halterung.
+
+>> >>Dazu muss man aber auf dem _vorderen_ Zughalter sitzen. Das Seil wird ja 
+>> >>nach _vorne_ gezogen.
+
+> >OK, Praezision:
+> >Man bremst, haelt, steigt aus dem Sattel, sitzt im Dusel, quatschend mit
+> >dem Nachbarn auf dem Zug - und laesst erst jetzt die Bremse los.
+
+Gabriele Patzner <gabriele@sprouts.org> wrote:
+> > Maenner und ihre Kastrationsaengste *kopfschuettel*
+> > Bowdenzuege sind viel zu dick und unter zu wenig Spannung, um als
+> > Eierschneider fungieren zu koennen und ihre Oberflaeche ist nicht wirklich
+rau
+> > genug, als dass sich die Befusselung darin verfangen wuerde.
+
+Moechtest Du Dich meim Absteigen vom Rad mit entbloesstem Geschlecht auf
+die offenen Bowdenzuege setzen und Dir eventuell beim Bewegen derselben
+gewisse empfindliche Haut einklemmen? Bei FKK schon moeglich.
+
+Es geht nicht um Eierschneider und verfangende Befusselung, die
+Skrotumhaut ist weich und empfindlich und sollte sich nirgendwo
+verfangen. Bei entspannten Skrotum ist sie geweitet und weich.
+Und wenn rasiert = noch empfindlicher.
+
+-----------------------------------------------------------------------------
+
+
+
+Ich will schmarrn.netdigest.witze.alt.kenn_ich_schon! (Ronda,  1. Jul 2006, 00:18:01):
+Oder waer ne DIN-Norm dazu besser?
+
+Ok, interessante Einsichten zu Kindern, Newsgroups und dem Deutschen Michel an
+sich.
+
+Ronda
+
+Subject:     Re: ich wundere mich ein wenig...
+From:        Jens Arne Maennig <maennig0606@cricetus.com>
+Newsgroups:  de.soc.familie.kinder
+Date:        Thu, 22 Jun 2006 14:20:51 +0200
+
+Michel Firholz schrieb:
+
+> > Ist es hier de.soc.familie.saeuglinge?
+> > Nur die allerweingsten ernstgemeinte Beitraege und Fragen betreffen
+> > Kindern ueber 10.
+> > Machen die mit steigendem Alter keine Problemen mehr, oder geben
+> > ihren Eltern auf?
+
+Das war ja so gewuenscht.
+
+<div id="erzaehlonkel">
+Damals wurde ja die gute, alte Grppe de.soc.familie aufgeloest und
+durch de.soc.familie.kinder, de.soc.familie.vaeter und
+de.soc.familie.misc ersetzt, weil gewisse Leute meinten, dass ein
+kompletter Ueberblick ueber den typischen Lebenszyklus einer Familie
+(Voegeln - Heiraten - Schwangerschaftsprobleme - Kleinkindprobleme -
+Eheprobleme - Scheidungsprobleme - Pubertaetsprobleme -
+Vereinsamungsprobleme - Siechtum - Tod) insbesondere Lesern, die sich
+in den Stufen 1 bis 4 befinden, nicht psychisch zumutbar sei.
+</div>
+
+So hat sich halt dsfk zur Muttergluckengruppe entwickelt, in der
+lediglich ein bedauenswerter Willibald hin und wieder versucht, etwas
+gehobene Qualitaet aus Bereichen, die ueber die Beduerfnisse von
+Kleinstkindern hinausgehen, einzubringen, wofuer er dann auch
+regelmaessig Dresche bezieht.
+
+Noch ein anderer Aspekt: Man nimmt die lieben kleinen nie wieder so
+verkrampft-wichtig, wie wenn das erste Selbstgebaute ganz klein ist.
+Beim zweiten weiss man, wie es geht und abonniert statt dsfk leiber
+wieder dtl, weil man ja inzwischen in Phase 5 (entsprechend
+obenstehender Nomenklatur) ist.
+
+Ausserdem: Wenn Kinder groesser werden, sagen sie: "Nein, ich mag nicht
+schon wieder Fischstaebchen, ueberhaupt, lass mich lieber in die Kueche,
+ich mach das schon." Es besteht als schlicht kein Grund fuer Postings 
+la "Nach dem Bananenbrei macht unser Zwerg immer so ein Baeuerchen, was
+kann ich tun?" mehr.
+
+> > Ist das fuer unsere Gesellschaft nicht ein bisschen symptomatisch ?
+
+Fuer unsere Gesellschaft symptomatisch ist es, ums Verrecken auf eine
+nur scheinbar zielgruppenorientierte Mikrosegmentierung aus zu sein.
+Wie hier das Thema Familie seinerzeit in ziemlich uninteressante
+Kleingruppen zerlegt wurde, so gibt es in "der Gesellschaft" eben
+heute Krabbelgruppen, Kindergarten, Schulhort, Teeniedisco,
+Studentenkneipen, Ue-30-Feten, After-Work-Parties, Golden-Ager-Reisen,
+Retirement Communities und Pflegeheime statt einer Grossfamilie.
+
+Insofern ist diese Gruppe sicherlich ein gutes Abbild eines kleinen
+Segments unserer Gesellschaft - was immer das auch sein mag.
+
+Jens
+
+-----------------------------------------------------------------------------
+
+
+
+Ich haette gern eine Ordin. Aber nur wenn sie/er suess ausschaut! (Ronda,  1. Jul 2006, 00:19:17):
+
+From: Volker Gringmuth <einklich@gmx.net>
+Subject: Re: Hilfe Bitte Mit Witz Um Gott und Fussball
+Newsgroups: de.etc.sprache.deutsch
+Date:Fri, 23 Jun 2006 15:16:10 +0000 (UTC)
+Message-ID: <Xns97EBAF822C3D7bx@vg.einklich.net>
+
+Horst Ruth wrote:
+
+> > Aber dieser Verlust laesst sich besser ertragen als die Lektuere der
+> > "Bibel in gerechter Sprache".
+
+Ist das die von mir schon mehrfach angefuehrte Uebersetzung oder 
+Uebersetzungin, in der Jesus oder Jesa sagt: "Jeder und jede, der oder 
+die von diesem [oder dieser, vG] Wasser trinkt, den oder die wird 
+wieder duersten; jeder und jede aber, der oder die von dem Wasser 
+trinkt, das ich ihm oder ihr geben werde, den oder die wird nicht mehr 
+duersten, denn das Wasser wird in ihm oder ihr zu einer Quelle werden 
+..."
+
+Wer oder wie das fluessig vom Blatt oder der Blaettin lesen kann, der 
+oder die verdient einen Orden oder eine Ordin.
+
+-----------------------------------------------------------------------------
+
+
+
+Kunden sind manchmal etwas besonder. (Ronda,  1. Jul 2006, 00:23:45):
+From: gerrit.brodmann@gmx.de (Gerrit Brodmann)
+Subject: Re: Kundenmails...
+Date: Thu, 22 Jun 2006 18:07:26 GMT
+Message-ID: <449fd78a.294588359@news.arcor.de>
+
+kscheller@ochs.franken.de (Konni Scheller) wrote:
+
+Ich erlaube mir mal zu antworten 8-)
+
+> >Verwenden sie Fair Trade Lebensmittel ?
+
+Fuer uns ist ein fairer Umgang mit den Lieferanten von hoechster
+Wichtigkeit. So achten wir nicht nur auf die Herkunft unserer
+Rohstoffe, wir verlangen sogar, dass uns der Schlachter nur Schnitzel
+von Schweinen liefert, welche eine natuerlichen oder Unfalltodes
+gestorben sind und welche einen Organspenderausweis besassen.
+
+> >Welche Geschirrmarken verwenden Sie ?
+
+Zu diesem Punkt kann ich Ihnen die freudige Mitteilung machen, dass wir
+seit dem Jahr 2005 unser Geschirr bar bezahlen und nicht mehr auf
+Lebensmittel- oder Geschirrmarken angewiesen sind.
+
+> >Welche Temperatur hat das Bier fuer gewoehnlich ?
+
+Diese Anfrage kann ich leider nicht beantworten, da wir kein
+gewoehnliches Bier ausschenken. Unser aussergewoehnliches Bier hingegen
+passt sich variabel den Gegebenheiten an.
+
+> >Aus welchem Holz sind ihre Sessel gefertigt und wann wurden diese ca.
+> >angeschafft ?
+
+Unsere Moebel sind ebenso wie die Bedienung aus einem ganz besonderem
+Holz und waren eigentlich schon immer da. Man merkt diese
+Materialgleichheit auch immer wieder in der Praxis. Weder die Sessel,
+noch die Kellner reagieren auf Zuruf und beide stehen staendig im Weg
+rum.
+
+> >Verwenden sie 1,2 oder 3 lagiges Toilettenpapier und welche Farbe hat
+> >dieses ?
+
+Wir verwenden sogenanntes Wendepapier, die Vorteile der beidseitigen
+Benutzung liegen offensichtlich auf der Hand.
+
+Das Papier auf der Damentoilette ist in der Regel rot.
+
+> >Wie alt ist der Koch ihres Hauses (bezueglich Erfahrung) ?
+
+Unser Koch ist 80 Jahre alt, allerdings bekommt er bei besonders
+schwierigen Rezepten noch tatkraeftige Hilfe von seiner Mutter...
+
+> >In welchem Mischverhaeltnis stehen bei der Salatabmachung die Zutaten
+> >Salz, Oel und Essig zueinander  ?
+
+Um den Geldbeutel unserer Kunden nicht zu sehr zu strapazieren,
+gleichen wir das Verhaeltnis Oel zu den anderen Zutaten variabel zum
+Oelpreis an.
+
+> >Welche Art von Wasserhaehnen verwenden sie bei den Waschbecken im
+> >Toilettenbereich ?
+
+Wir sind inzwischen auf Wasserhennen umgestiegen, da sich die
+Uebernachtungsgaeste ueber das laute Kraehen am Morgen beschwert haben.
+
+> >Haben sie echte Kristallglaeser fuer den Wein ?
+
+Wir sind der Meinung, dass sich Kristallglaeser und Wein nicht
+vertragen. Wie sie sicher wissen, wird das Kristall aus Getreide,
+genau genommen aus Weizen hergestellt. Man bekommt es Flaschenweise
+als sogenanntes Kristallweizen zu kaufen. Nun ist Weizen
+bekanntermassen ein Korn und Korn und Wein zusammen sind wie Kaviar mit
+Schlagsahne, es mag nicht wirklich miteinander harmonieren.
+
+> >In der Hoffnung auf baldige und genaue Antwort auf meine gestellten
+> >Fragen verbleibe ich
+
+Ich hoffe, dass ich alle Ihre Fragen zu Ihrer Zufriedenheit beantworten
+konnte und hoffe, dass Sie Ihre Feierlichkeiten bei uns buchen werden.
+
+MfG.....
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Ich haette gern eine Ordin. Aber nur wenn sie/er suess ausschaut! (Justavius,  1. Jul 2006, 10:16:57):
+~#! rn=Ronda rt=1151705957 rg=schmarrn.netdigest
+~#! tid=1151705957
+es heisst bitte DIE blaettin ... wenn wir schon bei gerechter sprache sind ;)
+
+-----------------------------------------------------------------------------
+
+
+
+Ich liebe tolle Titel ;-) (Ronda, 12. Jul 2006, 00:06:21):
+From: Wolfgang Krietsch <woffi42@nurfuerspam.de>
+Subject: Re: Deutsche Vermoegensberatung kommt vorbei
+Newsgroups: de.etc.finanz.misc
+Date:Sat, 08 Jul 2006 09:38:03 +0200
+Message-ID: <e8noe0$bal$1@online.de>
+
+> >(Den gei^h^h^h coolsten Titel hat mir uebrigens mal jemand von der 
+> >T-Systems praesentiert, der nannte sich allen Ernstes 
+> >"Key Account Director", und hat sich auch genau so benommen)
+
+Einen "Key Account Manager" habe ich, als ich diese Bezeichnung das erste
+Mal auf einer ueberreichten Visitenkarte las, mal gefragt, ob er den
+Schluesselkasten der Firma verwaltet. War schoen zu sehen, wie die
+vorgeschriebene Freundlichkeit und die zutiefst empfundene Empoerung sich in
+seinem Kopf ein Duell lieferten ;)
+
+-----------------------------------------------------------------------------
+
+
+
+UMTS rulez! (Ronda, 12. Jul 2006, 00:07:59):
+[SN: Es geht um die Frage, wie zu verfahren ist, wenn man getankt hat,
+die EC-Karte nicht funktioniert, man kein Bargeld dabei hat und der
+Tankwart einen nicht fahren lassen will, ehe man das Benzin bezahlt hat.]
+
+From: Dirk Moebius <dirk.nospam.moebius@gmx.de>
+Newsgroups: de.soc.recht.misc
+Subject: Re: Deadlock im Recht
+Date: 07 Jul 2006 09:56:52 +0200
+Message-ID: <jjk66phmpn.fsf@virtual.pudel.in-berlin.de>
+
+Jaakob Kind writes:
+
+> > "Arnd Schroeter" <arnd.schroeter@freenet.de> wrote in message
+> > news:1152216131.939379.93180@s26g2000cwa.googlegroups.com...
+> > Guten Abend zusammen,
+
+>> >> Wie ist diese rechtlich aufzuloesen? Darf ich "einfach" wegfahren?
+
+> > Ich wuerde meine Adresse dalassen und dem Paechter ein paar geeignete
+> > Ausweispapiere zeigen (Personalausweis, Fahrzeugschein). Und dann wuerde
+ich
+> > fahren und dafuer sorgen, dass die Tankstelle moeglichst schnell ihr Geld
+> > bekommt. Ich glaube nicht, dass der Tankstellenpaechter einen gewaltsam
+daran
+> > hindern darf, zu fahren, wie er es bei einem auf frischer Tat ertappten
+Dieb
+> > natuerlich duerfte.
+
+> > Wie hast du die Situation denn schliesslich geloest?
+
+Noch gar nicht. Er sitzt mit dem Laptop im Auto.
+
+
+
+Dirk
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Ich liebe tolle Titel ;-) (Marcus, 12. Jul 2006, 09:46:20):
+~#! rn=Ronda rt=1152655581 rg=schmarrn.netdigest
+~#! tid=1152655581
+Schlimmer ist, wenn man im "Architecture Maintenance" Team ist
+und dann jemand vermutet, das man bei den Hausmeistern hilft.
+
+ciao, Marcus (jetzt im Wachschutz, err, Security Team)
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Ich liebe tolle Titel ;-) (Rumata, 12. Jul 2006, 09:49:35):
+~#! rn=Marcus rt=1152690380 rg=schmarrn.netdigest
+~#! tid=1152655581
+Schade, dass das nicht oefter passiert, damit man merkt, wie bloed
+diese Bezeichnungen sind.
+Rumata, inhouse IT consultant
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Ich liebe tolle Titel ;-) (Zook, 12. Jul 2006, 09:51:45):
+~#! rn=Rumata rt=1152690575 rg=schmarrn.netdigest
+~#! tid=1152655581
+Auf meiner Visitenkarte steht gar keine Funktion. :)
+
+Zook.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: Ich liebe tolle Titel ;-) (Marcus, 12. Jul 2006, 09:58:05):
+~#! rn=Zook rt=1152690705 rg=schmarrn.netdigest
+~#! tid=1152655581
+Ich habe gar keine Visitenkarten.
+
+Ciao, Marcus
+
+-----------------------------------------------------------------------------
+
+
+
+Re^5: Ich liebe tolle Titel ;-) (Rumata, 12. Jul 2006, 10:00:00):
+~#! rn=Marcus rt=1152691085 rg=schmarrn.netdigest
+~#! tid=1152655581
+Dann hast Du in Japan verloren ;-)
+Rum**
+
+-----------------------------------------------------------------------------
+
+
+
+Re^6: Ich liebe tolle Titel ;-) (Zook, 12. Jul 2006, 10:06:23):
+~#! rn=Rumata rt=1152691200 rg=schmarrn.netdigest
+~#! tid=1152655581
+Ah, doch, ich seh grad.
+
++--------------------------------------+
+| Zook                                 | 
+| Mudgott                              |
+|                                      |
+|                                      |
+| E-Mail: zook@mg.mud.de               |
++--------------------------------------+
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^7: Ich liebe tolle Titel ;-) (Humni, 12. Jul 2006, 10:07:15):
+~#! rn=Zook rt=1152691583 rg=schmarrn.netdigest
+~#! tid=1152655581
+Wenn du das dem Japaner gibst haelt er Dich fuer jemanden, der komische Dinge
+im Schlamm tut...
+
+Humni
+
+-----------------------------------------------------------------------------
+
+
+
+Re^8: Ich liebe tolle Titel ;-) (Zook, 12. Jul 2006, 10:13:50):
+~#! rn=Humni rt=1152691635 rg=schmarrn.netdigest
+~#! tid=1152655581
+Ah, hm. Sollte ich mal drueber nachdenken. Das erklaert zumindest
+den einen oder anderen komischen Blick... Zook.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^9: Ich liebe tolle Titel ;-) (Kessa, 12. Jul 2006, 10:35:16):
+~#! rn=Zook rt=1152692030 rg=schmarrn.netdigest
+~#! tid=1152655581
+Bei uns an der Uni laeuft die Zeit etwas langsamer, wir haben so tolle Titel
+bisher nicht. Die Medienwissenschaftler vielleicht, die haben schon vor Jahren
+ihr 2x3-m-Buerochen zum Kompetenzzentrum ernannt. Ich geh jetzt mal in meins
+rueber und hol mir nen Cappuccino.
+
+Kessa, maintenance and custodial management
+
+-----------------------------------------------------------------------------
+
+
+
+Re^10: Ich liebe tolle Titel ;-) (Kessa, 12. Jul 2006, 10:39:02):
+~#! rn=Kessa rt=1152693316 rg=schmarrn.netdigest
+~#! tid=1152655581
+Bevor mir noch mehr Leute zum neuen Job gratulieren: ich meinte meine Kueche.
+Beeindruckend, wie das klappt mit den tollen Namen :)
+
+-----------------------------------------------------------------------------
+
+
+
+Re^9: Ich liebe tolle Titel ;-) (Muadib, 12. Jul 2006, 10:41:18):
+~#! rn=Zook rt=1152692030 rg=schmarrn.netdigest
+~#! tid=1152655581
+was denkt er wohl, wenn er "apostolischer visitator" liest
+
+-----------------------------------------------------------------------------
+
+
+
+Re^8: Ich liebe tolle Titel ;-) (Gloinson, 12. Jul 2006, 11:49:29):
+~#! rn=Humni rt=1152691635 rg=schmarrn.netdigest
+~#! tid=1152655581
+Wenn er das einem Japaner gibt, haelt der ihn fuer ein unglaublich hohes Tier,
+weil die Karte so schoen spartanisch ist.
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: Ich liebe tolle Titel ;-) (Ark, 12. Jul 2006, 12:40:01):
+~#! rn=Zook rt=1152690705 rg=schmarrn.netdigest
+~#! tid=1152655581
+Weil Du keine hast? ;)
+
+
+              *** ARK * the * Magnificent ***
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^8: Ich liebe tolle Titel ;-) (Bambi, 12. Jul 2006, 21:58:04):
+~#! rn=Humni rt=1152691635 rg=schmarrn.netdigest
+~#! tid=1152655581
+Was wuerde er bei der Bezeichnung "Bruder vom Mudgott" denken?
+
+-----------------------------------------------------------------------------
+
+
+
+Re^9: Ich liebe tolle Titel ;-) (Humni, 12. Jul 2006, 22:00:20):
+~#! rn=Bambi rt=1152734284 rg=schmarrn.netdigest
+~#! tid=1152655581
+Hmm. Gibts beim Schlammcatchen Tag-Teams, wie beim Wrestling?
+
+:geht mal in Deckung...
+
+-----------------------------------------------------------------------------
+
+
+
+Re^10: Ich liebe tolle Titel ;-) (Bambi, 12. Jul 2006, 22:04:51):
+~#! rn=Humni rt=1152734420 rg=schmarrn.netdigest
+~#! tid=1152655581
+Weiss nicht. Ich musste noch nie auswechseln. }:)
+
+-----------------------------------------------------------------------------
+
+
+
+Kein Schmarrn. WM-Fazit. Schoen. (Ronda, 20. Jul 2006, 00:26:51):
+[SN: Fuer mich das schoenste WM-Fazit.]
+
+Message-ID: <44B11D65.D6BA18D6@kulsch.de>
+Date: Sun, 09 Jul 2006 17:14:45 +0200
+From: Dietmar Kulsch <dk.nospam@kulsch.de>
+Newsgroups: de.rec.sport.fussball
+
+Neil Asset schrieb:
+ 
+> > Dieser dritte Platz bei einer WM hat mehr Spass gemacht als der Titel 1990
+> > oder der zweite Platz 1982/2002. Die Bescheidenheit, sich so sehr ueber
+den
+> > dritten Platz zu freuen, steht uns Deutschen sicher gut zu Gesicht.
+
+Ich denke auch, es hat was, wenn auf einer Party, bei der zur
+Zerstreuung der Gaeste ein sportlicher Wettkampf eingebunden ist,
+der Gastgeber nicht den Hauptpreis abraeumt, sondern diesen den Gaesten
+ueberlaesst und sich selbst mit einem Achtungserfolg begnuegt. Es darf
+nur nicht so aussehen, als habe man ganz bewusst danebengeschossen.
+
+-----------------------------------------------------------------------------
+
+
+
+Ab in den Knast! (Ronda, 20. Jul 2006, 00:31:16):
+... vorsicht: lang. Und nicht fuer jeden witzig.
+
+From: Frank Feger <frank@astro1.physik.uni-siegen.de>
+Subject: Re: 1700 Hausdurchsuchungen  - neue Fakten
+Newsgroups:
+z-netz.alt.pyrotechnik,de.sci.chemie,de.sci.physik,de.sci.electronics
+Date: Sun, 09 Jul 2006 18:55:32 +0200
+Message-Id: <e8rhkh$35r$1@news.albasani.net>
+
+peter_meier@technologist.com schrieb:
+
+> > Hier mal die Liste mit ein paar Kommentaren.
+
+Und ich kommentiere mal, warum sich die Bullen dann selber festnehmen
+muessten oder (dienstbeflissen) werden <grins>:
+
+> > 1. Propanon
+
+Hat nicht Hauptmeisterin A. Nagellackentferner mit dem Zeug?
+
+> > 2. Aluminium  (beliebiger Korngroesse!)
+
+Ganz grobes Korn: Alufelgen der Polizeiautos. Wenn kein Insasse einen
+entsprechenden Schein hat, wird's eng.
+
+> > 3. Ammoniumverbindungen
+> > a) Ammoniakwasser
+
+Wenn sich Komissarin B. von ihrem Damenbart trennen moechte, darf sie
+das nur im Knast.
+
+> > b) Chlorid
+
+Aus fuer das Laster des oertlichen Abteilungsleiters C.: Salzlakritz!
+
+> > c) das Nitrat
+
+Die Kartoffeln, die er im Garten zieht, werden wohl bald kleiner
+ausfallen muessen.
+
+> > 5. Berlinerblau
+
+Sieht schlecht aus fuer das Gemaelde des Kunstliebhabers D., der der
+oertliche Polizeichef ist.
+
+> > 7. vergaellter Aethylalkohol
+
+Die Ehefrau von C. hat sein Bild neben dem Bett gereinigt, und weil
+er das Zeug im Baumarkt gekauft hat, schauen sie sich nun im Knast
+permanent an.
+
+> > 8. Calciumverbindungen
+> > a) Carbonat
+
+Der viele Kalkmoertel der Polizeiwache spricht eine deutliche Sprache:
+hier fuehlen sich Terroristen sehr sicher.
+
+> > b) Fluorid
+
+Die Flussspatlinse im Mikroskopobjektiv des Forensikers im Keller
+zeigt schon, dass er ein gefaehrlicher Pyrotechnkier ist.
+
+> > 10. Eisenoxid
+
+Die rostige Gartenlaube der Familie B. bringt alle Mitglieder in
+das Gefaengnis.
+
+> > 11. Markenname fuer Brennstoff mit Hexmethylentetramin (bekannt etwa
+> > Brennstoff fuer Modell-Dampfmaschinen)
+
+Diesmal traf es den Minister, der wegen seiner Modell-Dampfwalze
+(in Schwarz-Messing) aus dem Buero nun im Hochsicherheitstrakt vor
+sich hin schmort.
+
+> > 12. Aethanol
+
+Nach der letzten Betriebsfeier wird nur noch der abstinente Typ,
+der im Archiv sitzt, uebrigbleiben.
+
+> > b) Propantriol
+
+Unverantwortlich von Frau B., das Zeug ihrem Kind als Einlauf zu
+geben, so etwas formt Terroristen! Da sie anscheinend Neulinge
+rekrutiert, kommt sie umgehendst in den Hochsicherheitstrakt.
+
+> > 17. Holzkohle
+
+Was den Archivar nach der naechsten Grillfete auch noch von der
+Bildflaeche verschwinden laesst ...
+
+> > 18. K2Cr2O7 (unter einem veralteten Namen)
+
+Nach der letzten Alkoholkontrolle wanderten drei Autofahrer ohne den
+"Lappen" nach Hause, aber die kontrollierenden Beamten hinter Gitter.
+
+> > 19. KClO3
+
+Die rauchende Praktikantin wird mit Streichhoelzern erwischt und dann
+sofort eingebuchtet.
+
+> > 21. KNO3
+
+Diesmal erwischt es den Cateringservice, der eine Schinkenplatte
+anliefert; in den Schweinehintern fanden sich deutliche Spuren der
+Chemikalie.
+
+> > b) Permanganat
+
+Beim Gurgeln damit wird C. erwischt und zur Strafe in Einzelhaft
+gesteckt.
+
+> > 23. CaC2
+
+Der Opa von B. hat noch etwas davon aus seiner Taetigkeit unter
+Tage uebrig - jetzt sieht er wieder kaum Sonnenlicht.
+
+> > 24. C (Russ)
+
+Ist um die schon verbotenen Alufelgen zu finden und sorgt dafuer,
+dass die frisch entlassene B. erneut inhaftiert wird.
+
+> > 25. Kupferverbindungen
+> > a) (I)-oxid
+> > b) Sulfat
+
+Aus fuer die Kristallzucht des Ehemanns von A.
+
+> > a) Magnesium
+> > b) Mg-Legierungen
+
+Die Digitalknipsen der Leute von der inneren Sicherheit bringen nicht
+nur schnell Ergebnisse, sondern auch ihre Benutzer als Angeklagte vor
+den Richter.
+
+> > 29. Natriumverbindungen
+> > a) Azid
+> > b) Carbonat
+
+Warum wohl die Kleidung ploetzlich so schlecht gewaschen ist? Ja, das
+Waschmittel brachte auch die Ehepartner der Polizeileute in arge
+Bedraengnis.
+
+> > d) Nitrit (Begruendung siehe b)
+
+Strafverschaerfung fuer den Cateringservice.
+
+> > e) Silikate
+
+Schlecht fuer die Ehepartner.
+
+> > f) ALLE(!) sonstigen Natriumverbindungen
+
+Die Strassenwaerter werden wegen Bunkerns im Tonnenmassstab verhaftet,
+der Kantinenchef hat mangels Bedarf ja rechtzeitig aufhoeren muessen.
+
+> > 36. P
+
+Schlecht fuer die Praktikantin, da sich die Streichhoelzer in einer
+entsprechenden Schachtel befanden.
+
+> > 38. HCl
+
+Damit koennte man die CaCO3-Spuren vom Mauerwerk entfernen, die alls
+Polizisten getarnten Terroristen sind offensichtlich gut ausgebildet
+und somit der El-Kaida zugehoerig.
+
+> > 40. S
+
+Pech fuer den Sohn von A. - entweder Pickel oder Geldstrafe.
+
+> > 42. Ag und seine Verbindungen
+> > a) Metall
+
+Beim naechsten Staatsempfang wird es deutlich rustikaler zugehen.
+
+> > 44. Ein anderes als Suessstoff verwendetes Hexit (S...)
+
+Der alte Ehrenpolizeichef wird wohl an diabetischem Koma sterben ...
+
+> > 46. H2O2
+
+Oh Wunder - Frau B. ist nicht naturblond.
+
+> > 48. 2-Hydroxypropantricarbonsaeure-(1,2,3)  Bekannt fuer Brausepulver
+> > als Z....-Saeure.
+
+Die Kinder der Polizisten werden nach einer Geburtstagsfeier wieder
+mit ihren inhaftierten Eltern vereint.
+
+> > Man sieht hier das mangelhafte Fachwissen der Autorin dieser Liste,
+> > was moeglicherweise eine ganz entscheidende Rolle gespielt haben
+> > koennte.
+
+Moeglicherweise?!
+
+
+Gruesse,
+
+F^2
+
+-----------------------------------------------------------------------------
+
+
+
+Engineering and Theology (Ronda, 22. Jul 2006, 17:08:39):
+... und liest da noch wer ausser mir erst "Santa Claus"?
+
+Ronda
+
+From: Rich Seifert <usenet@richseifert.com.invalid>
+Newsgroups: comp.dcom.lans.ethernet,alt.internet.wireless
+Subject: Re: Wireless Versus Ethernet
+Date: Wed, 19 Jul 2006 15:02:16 -0700
+
+> > "Jeff Liebermann" <jeffl@comix.santa-cruz.ca.us> wrote in message
+> > news:8nnqb2tgq3qrobvta7k6ejt1jedhi4i03e@4ax.com...
+>> > >
+>> > > If lightning is really an issue, methinks prevention is a more
+>> > > appropriate prophylactic.  Consulting a minister or rabbi for the
+>> > > necessary prayers or incantation to prevent or redirect the lightning
+>> > > might be more effective.
+> > 
+
+A friend and long-time colleague of mine is the Dean of Engineering at 
+Santa Clara University (a Jesuit institution here in Silly-con Valley). 
+We were discussing new, innovative class offerings in networking; I 
+suggested a joint seminar between the Engineering and Theology 
+departments, titled "The Use of Prayer as a Network Management tool." It 
+got a good chuckle.
+
+-----------------------------------------------------------------------------
+
+
+
+Gilt auch fuer MPA-Vergleiche. (Ronda, 22. Jul 2006, 17:10:37):
+Subject: Re: [Nonsens] #%#%#%
+From: Marius Fraenzel <marius.fraenzel@web.de>
+Date: Fri, 14 Jul 2006 19:20:25 +0200
+Message-ID: <44b7d258$0$26267$9b4e6d93@newsread2.arcor-online.net>
+Newsgroups: de.etc.sprache.deutsch
+
+Oliver Cromm schrieb:
+> > * Peter Bruells wrote:
+> > 
+>> > > Marius Fraenzel <marius.fraenzel@web.de> writes:
+>> > >
+>>> > >> Oliver Cromm schrieb:
+>>> > >>
+>>>> > >>> Wer gar keinen Alkohol trinkt, ist Alkoholiker, er verhaelt sich ja
+dem
+>>>> > >>> Alkohol gegenueber nicht neutral. Hoppla, schon wieder im falschen
+>>>> > >>> Faden!
+>>> > >> Ne, aber ein trockener Alkoholiker ist immer noch ein Alkoholiker. So
+>>> > >> wird ein Schuh draus!
+> > 
+> > Aha - ein zum Atheismus bekehrter <WH>gelernter</WH> Christ ist immer
+> > noch Christ?
+
+Achtung! Wechseln Sie bitte waehrend der Anwendung eines Vergleichs 
+nicht das Bezugssystem! Achten Sie auch darauf, nur wirklich 
+kontradiktorische Gegensaetze in das System einzuspeisen! Es kann sonst 
+zu schwerwiegenden Missverstaendnissen kommen!
+
+Auch bei Einhaltung dieser Vorschriften kann der Hersteller nicht 
+dafuer garantieren, dass der Vergleich bei der Anwendung nicht hinkt. 
+Hinken ist kein Mangel eines Vergleichs, sondern sollte als 
+wesentliche Eigenschaft von Vergleichen angesehen werden.
+
+Gruss, Marius
+
+-----------------------------------------------------------------------------
+
+
+
+Schweizer sind NICHT langsam! (Ronda, 22. Jul 2006, 18:14:16):
+From: Klaus Straubinger <KSNetz@UseNet.ArcorNews.DE>
+Subject: Re: Helmpflicht in der Schweiz - Update
+Newsgroups: de.rec.fahrrad
+Message-ID: <e9q519$hni$1@news.sap-ag.de>
+
+Frank Kuester <frank@kuesterei.ch> schrieb:
+
+> > Heute kam im Radio, dass der Chef der Radarkontrollenabteilig der Berner
+> > Polizei mit 217 geblitzt wurde...
+
+Es war der Chef fuer die Radarueberwachung im Kanton Waadt.
+(siehe "http://www.espace.ch/artikel_237898.html").
+
+Besonders schoen finde ich seine Begruendung fuer dieses Verhalten:
+
+| Der Polizist habe eine Radaranlage testen wollen und sei mit einem
+| unauffaelligen Dienstwagen an dieser vorbeigerast.
+
+-----------------------------------------------------------------------------
+
+
+
+Manche Signatur ist einfach nicht zu toppen. (Ronda, 25. Jul 2006, 00:17:00):
+Subject: Re: Haltbarkeit von Entwickler
+From: "E.-R. Bruecklmeier" <a82374237x@radio-eriwan.de>
+Newsgroups: de.rec.fotografie
+Date: Sun, 23 Jul 2006 15:41:03 +0000
+Message-ID: <4ihjlbF3qg8sU1@individual.net>
+
+[SN: Man beachte die Signatur!]
+
+Andreas Gugau schrieb:
+
+> > Es gibt Versandhaendler, die liefern auch ans Ende der Welt ;-) 
+
+So? Wer liefert mir ein paar Flaschen LP Brom 4 - bis Ende August bitte ;-)
+
+Gruesse
+
+Eric
+
+-- Dr. Eric-Roger Bruecklmeier Electronics Engineer / Communications Officer
+Neumayer Station Antarctica 7039'S 0815'W
+
+-----------------------------------------------------------------------------
+
+
+
+Salat ist nichts fuer kleine Kinder! (Ronda,  6. Aug 2006, 22:15:30):
+... und mal wieder: Fragt mich bitte nicht, was der Text der Nachricht mit dem
+Subject zu tun hat...
+
+Ronda *Mudpartybedingt de.at.netdigest abarbeitend - geniale Party wars
+uebrigens! Danke nochmal ans Orga-Team!*
+
+
+From: Wolfram Heinrich <theodor.rieh@yahoo.de>
+Subject: Re: Zwiebelspanisch
+Newsgroups: de.etc.sprache.deutsch
+Date:Thu, 3 Aug 2006 10:24:07 +0200
+Message-ID: <1gf1rr1gfkwkc.dlg@www.theodor-rieh.de>
+
+>> >>Fazit: Rohkost schreckt, egal unter welchem Namen.
+ 
+> > Was ist an Sashimi so schrecklich? Ein gut angemachter Salat?
+> > Und rohe Moehren fand ich immer so lecker wie rohes Obst.
+ 
+Nichts, ueberhaupt nichts ist dran schrecklich. Sashimi klingt aber auch
+viel besser als "Rohkost"
+
+> > Ich glaube, die Nutella-Generation hat sich in frueher Jugend einen
+> > Geschmacksdefekt eingefangen ...
+ 
+Nein, nein. Das hat man uns als Kinder auch schon gesagt, dass wir nicht
+wuessten, was gut ist. Man sollte bei Kindern kein Geschiss mit dem Essen
+machen, die holen sich schon, was sie brauchen. Meine hatten Phasen, wo ich
+mich fragte, wovon sie eigentlich leben und dann wieder Zeiten, in denen
+sie gespachtelt haben wie die Scheunendrescher.
+
+> > Bei uns gab's Ende der 50er/Anfang der 60er noch Ruebenkraut als
+> > Brotaufstrich, Mrkensbezeichnung "Grafschafter Goldsaft":
+ 
+Hmnja Grafschafter Goldsaft - still going strong. Wenn du Kinder sagst, das
+ist Ruebenkraut auf ihrem Brot, werden sie das Brot dem Hund geben. Sagst
+du, das ist Kunsthonig - weg ist das Brot.
+
+Eigentlich sollte man Kindern ueberhaupt keinen Salat hinstellen, mit der
+frechen Behauptung, das sei noch nichts fuer kleine Kinder. Dann fressen sie
+dir heimlich die Moehren aus der Einkaufstasche.
+
+-----------------------------------------------------------------------------
+
+
+
+Elektriker... (Ronda,  6. Aug 2006, 22:20:46):
+... haben auch nicht immer alle Tassen... aeh... Elektrorohre im Schrank...
+
+From: Lutz Schulze <lschulze@netzwerkseite.de>
+Subject: Re: Elektrorohre [war: Installation von Fernseh/Internet/Telefon in
+JEDEM Zimmer moeglich?]
+Newsgroups: de.rec.heimwerken
+Date:Wed, 02 Aug 2006 14:42:54 +0200
+Message-ID: <6071d21k9vlkv9p4r54bmg9trk9oa19bip@4ax.com>
+
+>>>> >>>> Also nochmal: Es heisst Elektrorohr, das Ding mit den Draehten oder
+>>>> >>>> Kabeln drin [und nicht etwa "Leerrohr"]
+
+>> >>Ein Grund dafuer, das richtig zu stellen, nicht ein Argument dagegen.
+
+> >Rohre verlegt man allerdings und stellt sie nicht, weder richtig noch
+> >falsch.
+
+Als ich noch Rohre verlegte, habe ich die manchmal voruebergehend auch
+an eine Wand oder ein Gelaender gestellt. Dabei war wichtig, dass sie
+richtig standen (falsch stehende Rohe verlegen sich manchmal selbst,
+aber meist an unpassender Stelle).
+
+BTW: wusstet ihr, dass das Wichtigste am Rohr das gleichmaessige Nichts
+darin ist?
+
+-----------------------------------------------------------------------------
+
+
+
+Ich bin NICHT suechtig! (Ronda,  6. Aug 2006, 23:01:26):
+From: Wolfgang Mederle <walthervondervogelweide@gmx.de>
+Newsgroups: de.etc.fahrzeug.auto
+Subject: Re: Innenstadtfahrverbot in Muenchen
+Message-ID: <yj9slkjlwns.fsf@elvis.mederle.de>
+
+Es schrieb Jan Heichler:
+
+> > "Rauchen ist keine Sucht, weil ich nicht suechtig war". Gewagt. Ich
+> > kenne genug Leute die sagen sie wuerden gern aufhoeren, koennen aber
+> > nicht, weil es "Entzugserscheinungen" gibt. Sowohl psychisch als auch
+> > physisch.
+
+Sie wollen nicht. Die gesellschaftliche Aechtung des Rauchens ist nicht
+mehr weit, und wenn man behauptet, man wuerde ja gern aufhoeren, bekommt
+man Mitleid von den gesunden Nichtrauchern anstatt bloeder, immergleicher
+Appelle, wie gefaehrlich es doch ist.
+
+Ich stecke fast jeden Tag bis zu eine Stunde in ein Medium, in dem es
+von Dummkoepfen nur so wimmelt. Wenn ich das grade gern tun wuerde und
+mein Internetanschluss spinnt, werde ich hippelig. Nach einiger Zeit laesst
+das nach, zum Beispiel im Urlaub oder bei einem Hardwareschaden. Es geht
+ganz schnell weg, wenn meine Frau was Nettes auszieht. Ich fange aber
+regelmaessig wieder damit an. 
+
+Hoert doch mal vier Wochen mit dem Usenet auf, Ihr Junkies, und tut was
+Vernuenftiges in der Zeit, zum Beispiel eine Sprache lernen! Oder koennt
+Ihr nicht, oder wollt Ihr nicht?
+
+-----------------------------------------------------------------------------
+
+
+
+Etwas fuer Segler. Oder auch nicht. (Ronda, 10. Aug 2006, 22:00:38):
+Message-ID: <1155193425.979785.202820@m79g2000cwm.googlegroups.com>
+From: "Lothar Frings" <da_lodda@gmx.de>
+Newsgroups: de.rec.sport.segeln
+Subject: Re: Skipper hat an Bord Sex mit Crew-Mitglied. Ist das okay?
+Date: 10 Aug 2006 00:03:46 -0700
+
+Dieter Rohlfing tat kund:
+
+> > Die Crew bestand aus 2 Frauen, 4 Maennern und dem Skipper.
+
+Ok, der Skipper _ist_ ein gottaehnliches Wesen, aber so
+deutlich ausgedrueckt hoert man es selten.
+
+-----------------------------------------------------------------------------
+
+
+
+Man beachte bitte die Newsgroup. (Ronda, 10. Aug 2006, 22:12:55):
+From: Thorsten Guenther <guenther@dilgar.de>
+Subject: Re: Tokio Hotel Fan Forum
+Newsgroups: de.rec.musik.rock+pop
+Date:Mon, 07 Aug 2006 22:10:11 +0200
+Message-ID: <4jpl13F8loq3U2@uni-berlin.de>
+
+Rainer R. Friedrich wrote:
+> > Stephan Heinemann schrieb:
+> > 
+>> >> Was hat der Magdeburger Kindergarten mit Musik zu tun?
+>> >>
+>> >> ergo: falsche Gruppe
+> > 
+> > Das neue 'Lied' laesst hoffen: "Ich schliess mich ein".
+
+Nur, wenn die Lyrics mit "...und schmeiss den Schluessel weg."
+weitergehen.
+
+
+Thorsten
+
+-----------------------------------------------------------------------------
+
+
+
+Nach der Mudparty... (Ronda, 10. Aug 2006, 22:16:35):
+... kleine News in Richtung Chinese in Falkensee (war lecker und sehr
+ausreichend!)
+
+From: Oliver Cromm <lispamateur@internet.uqam.ca>
+Subject: Re: S: Alternative zu OE
+Newsgroup: de.comm.software.40tude-dialog
+Datum: 5.08.2006 18:32:12
+Message-Id: <r6erlhv7cem5.dlg@ocromm.my-fqdn.de>
+
+Heiko Rompel meinte:
+
+> > "Wolfgang Bauer" schrieb:
+> > 
+>> >> Nur so wie Du da rangehst ist es der
+>> >> falsche Weg.
+> > 
+> > Was ist falsch daran, zu fragen wie man etwas einstellen muss?
+
+Falsch ist die Erwartung, dass es genau so gehen muesste wie bei OE. Besser
+klappt es meistens, wenn man sich klar macht, was man erreichen will.
+Beim Chinesen fragt man besser nicht "Wo ist der Tabasco?"; "geht das
+etwas schaerfer" fuehrt eher zum Erfolg.
+
+-----------------------------------------------------------------------------
+
+
+
+Deutschland sucht schon wieder einen Superstar (Ronda, 10. Aug 2006, 22:17:29):
+From: Henning Paul <henningpaul@gmx.de>
+Subject: Re: DSDS
+Newsgroups: de.rec.musik.recherche
+Date:Fri, 04 Aug 2006 16:47:42 +0200
+Message-ID: <e93cq3-cbg.ln1@fump.de.vu>
+
+Markus schrieb:
+
+> > Ich will spasseshalber dieses Jahr wieder
+> > bei DSDS mitmachen. Da wird in einer Runde
+> > ja immer was gesungen, wo einer Klavier zu spielt.
+
+Sachma, Du bist ja wohl ueberall anzutreffen, was?
+
+> > Ich suche irgendein Lied mit hohem Bekanntheitsgrad,
+> > was sich dafuer eignet.
+
+"Do You Really Want To Hurt Me?"
+
+SCNR
+Henning
+
+-----------------------------------------------------------------------------
+
+
+
+Islaendische Seekuehe (Ronda, 14. Aug 2006, 21:46:14):
+Warum auch immer das Subject "Spinne im Kopf" heisst...
+
+Ronda
+
+Subject: Re: spinne im kopf
+From: lutz feustel <usenetmail@nurfuerspam.de>
+Date: Thu, 10 Aug 2006 21:03:10 +0200
+Newsgroups: de.alt.folklore.urban-legends
+
+ r.kussack1@snafu.de (Renata Kussack) wrote:
+
+> >PS: Wir waren eines Tages mal im Tierpark Friedrichsfelde, um uns die
+> >hiesigen Seekuehe anzusehen. Stattdessen sind wir irgendwie ewig an einem
+> >leeren Becken stehengeblieben, in dem ein Abwasserrohr die traurigsten,
+> >walartigen Gesaenge fabriziert hat... 8) 
+
+Die spielen da Musik von Bjoerk?
+
+Lutz
+
+-----------------------------------------------------------------------------
+
+
+
+0190er Nummern. Ehrliche. (Ronda, 14. Aug 2006, 21:46:56):
+From: Robert Gruener <rgruener@online.de>
+Subject: Re: 0190-Nummer ohne Leistung
+Newsgroups: de.soc.recht.misc
+Date: Wed, 09 Aug 2006 18:53:06 +0200
+Message-ID: <4jui7jF9r32aU1@individual.net>
+
+Haiko Johann wrote:
+> > Hallo,
+> > 
+> > ich habe mal eine theoretische Frage. Angenommen, ich habe eine
+> > 0190-Nummer, drucke sie ohne weiteren Kommentar auf eine Karte und
+> > verteile die an Passanten.
+> > 
+> > Wenn jetzt welche da anrufen, kann es dann rechtlichen Aerger geben?
+> > 
+> > Es wurde ja keine Leistung versprochen oder vereinbart. Er bekommt
+> > nichts weiter, als dass ich ans Telefon gehe und mich melde. Der
+> > Anrufer wird am AB natuerlich vorher ordnungsgemaess ueber die
+> > anfallenden Kosten aufgeklaert.
+> > 
+> > Mit welchen Recht koennte ich als "Kunde" die Zahlung verweigern oder
+> > zurueckfordern? Meiner Meinung nach mit gar keinem. 
+> > 
+> > Gruesse,
+> > Haiko
+> > 
+Wahrscheinlich nicht. ich wuerde in dem Fall aber sicherheitshalber auf 
+die Karte einen Spruch wie "Rufen Sie an. Ich biete keinerlei Service, 
+Information oder Leistung. Sie werden lediglich Ihr Geld los." drucken.
+Das duerfte die Neugier sogar noch erhoehen.
+
+
+Gruss
+
+Robert
+
+-----------------------------------------------------------------------------
+
+
+
+Ich liebe die GEZ... (Ronda, 15. Aug 2006, 20:59:46):
+From: Andre Bryx <news0306@bryx.de>
+Subject: Weissgluehende Gebuehrenbeauftragte
+Newsgroups: de.soc.medien.rundfunkfinanzierung
+Date: Thu, 10 Aug 2006 21:59:15 +0200
+Message-ID: <ebg3ba$obc$1@newsreader2.netcologne.de>
+
+War wieder eine lustige Woche:
+
+Kaum hatte ich meine Videothek eroeffnet kam der lustige GEZ-Maen
+und meinte forsch, das ich gefaelligst den Fernseher, der als
+Vorfuehrgeraet im Laden steht anzumelden haette.
+Dumm nur, dass ich aus einer der der Schubladen den ausgeloeteten
+Tuner nebst Bestaetigung des Fernseh-Fachbetriebens kramen konnte.
+"Grr.." Na, dann sollte ich den VHS-Recorder, der in der Ecke
+steht anmelden. Hab ich ihm in die Hand gedrueckt. Ist naemlich
+defekt
+und kann wegen der Elektroschrottverordnung nicht einfach so in
+die
+Tonne geworfen werden.
+Da wurde er fuchsig und meinte, dass er im Januar wiederkommt,
+weil
+dann die Internetgebuehr faelig wird. Ich wuenschte ihm einen
+schoenen
+Tag, teilte ihm mit, dass ich am 1.1.07 ein Radio kaufen und
+SELBST
+anmelden werde - Soll er sich seine Provi doch woanders
+verdienen. 
+Zwingt mich ja keiner ueber den Gebuehrenfuzzi an die GEZ zu gehen
+:-)
+
+Lustig auch, dass die Rechte Hand nicht weis, was die Linke tut.
+Nachdem vor einigen Wochen schon mal ein Gebuehrenheini vor meiner
+Privattuere stand, kam heute der Naechste (haben die momentan
+Auslauf?)
+Da fiel mir das lustiges Spiel ein, welches ich irgendwo mal
+gelesen hatte. Unglaublich, aber es funktionierte:
+Ja - ob ich denn einen Fernseher haette?
+"Natuerlich!" meinte ich. Schon seit 10 jahren und noch immer
+nicht
+angemeldet. Genauso wie das Autoradio in meinem gemischt
+genutzten PKW.
+Ich glaube, er bekam so was wie einen Orgasmus als ihm die
+Provision
+fuer die Nachzahlung einer solchen Zeit im Geiste erschien.
+Als er dann den Zettel zueckte und schon mal rumkritzelte meinte
+ich nur:
+"Ja aber den Namen und die Adresse muessen Sie schon selbst
+rauskriegen,
+ich bin naemlich nur zu Besuch hier..."
+Und zu war die Tuer.
+
+-----------------------------------------------------------------------------
+
+
+
+Realnamen in Newsgroups. (Ronda, 16. Aug 2006, 22:05:59):
+Betreff: Re: Neue Erkenntnisse zu Abmahnung ueber Waldorf Anwaelte
+Absender: Christian Wielandt <m27berlin@gmx.de>
+Datum: Tue, 15 Aug 2006 09:44:59 +0200
+Message-ID: <1155627899.585004.52750@h48g2000cwc.googlegroups.com>
+
+Bagger wrote:
+> > Hallo ich habe vor einiger Zeit die Bekanntschaft mit den Waldorf
+Anwaelten
+> > gemacht.
+
+Ist doch prima. Auf einer Party kennengelernt? Eine Cola mit denen
+getrunken? Sind sicher nette Leute. Wundert mich nur, dass die sich mit
+einer Baumaschine unterhalten.
+
+> > Ich suche Leute die ebenfalls betroffen sind.
+
+Betroffen wovon? Karies? Genitalwarzen? Oder laeuft an Deinem Bagger
+Hydraulikoel aus?
+
+> > Vielleicht kann man sich mal austauschen.
+
+Austauschen? Koerperfluessigkeiten? Nie im Leben. Und mit Baggern will
+ich sowieso keinen Sex haben.
+
+Christian
+
+-----------------------------------------------------------------------------
+
+
+
+Unternehmen... (Ronda, 26. Aug 2006, 20:38:16):
+... bei denen man vermutlich nicht anfangen will...
+
+From: Maria Winter <usenet-replies@fahr-zur-hoelle.org>
+Subject: Re: Bewerbung per E-Mail oder Post?
+Newsgroups: de.alt.soc.knigge
+Date: Sun, 20 Aug 2006 17:49:11 +0200
+Message-ID: <s11he2dhjp477e1fidrvab8107nlij1vlb@4ax.com>
+
+Heinz D. Trost schrub:
+
+> >Gerhard,
+> >
+>> >> "Was ist besser?"  Und wie schicke ich die Bewerbung ueber E-Mail?
+> >
+> >wenn jemand schon Emailbewerbungen erlaubt, dann sollte man das auch 
+> >nutzen,- es spart nicht nur Dir 1,45EUR Porto, dem Ruecksender auch.
+
+Letzteres nicht unbedingt. Ich habe auch schon Online-Bewerbungen mit
+einem fiesen Tintenstrahl-Ausdruck (so Groessenordnung unterste
+Lexmark-Klasse) in einem Billighefter "zu unserer Entlastung" zurueck
+bekommen... ;o)
+
+     Maria
+
+-----------------------------------------------------------------------------
+
+
+
+Bitte fortsetzen... (Ronda, 27. Aug 2006, 00:16:21):
+Note: Es ging um die Regisseure fuer den naechsten Harry Potter Film und
+deren Umsetzung des Buches...
+
+From: "Thorsten Schaan" <spam@schaani.de>
+Newsgroups: de.alt.fan.harry-potter
+Subject: Re: noch 11 Monate warten
+Date: Thu, 17 Aug 2006 14:55:57 +0200
+Organization: T-Online
+
+
+> > NACK, ich finde ihn genial. Ich kenne aber auch viele Leute denen er
+> > zu verspult ist.
+
+
+also ich waer ja fuer David Lynch
+
+ich stell mir das ungefaehr so vor  - harry potter reitet 120 minuten
+lang durch einen ewig langen Gang im Ministerium und nichts weiter
+passiert...
+
+oder Quentin Tarrantino
+
+... Harry verwandelt seinen Zauberstab in ein Samuraischwert und er
+metzelt alle DE's damit nieder bevor die sich auch nur wehren
+koennen(natuerlich in Schwarz Weiss) danach
+tanzt Hermine mit Voldi den 7Schritte Gehirnexplosionstanz und voldi
+stirbt aber an der Ueberdosis die er sich vorher mit Ron reingezogen
+hat...der ueberkiffte Ron fragt dauernd nach Big Kahuna Burgern redet
+ueber Fussmassagen und redet auch sonst nur daemliches Zeug...
+
+Vielleicht koennte auch Jerry Bruckheimer den produzieren
+
+... Harry fliegt auf seinem Thunderbolt (made in USA) Richtung
+Ministerium - im Hintergrund weht das Sternebanner(typische
+Bruckheimer
+Musik) - Harry sprintet nachdem er Hermine und ron heroisch
+niedergeschlagen hat am Sternebanner vorbei ins Ministerium wo er dann
+eine atombombe von Hand zuendet weil der funkzuender kaputt ist bei
+seiner beerdigung weht das Sternebanner ...
+
+faellt euch auch so was schoenes ein ?
+
+
+gruss Thorsten
+
+-----------------------------------------------------------------------------
+
+
+
+Star Trek wird 40 (Ronda, 27. Aug 2006, 00:20:35):
+[Zitat ergaenzt]
+
+Newsgroups: de.rec.sf.startrek.misc
+Subject: Re: wie feiert ihr den 40sten Geburtstag?
+From: Michael Rudolph <MiG29_Fulcrum_ger@yahoo.com>
+Date: Wed, 16 Aug 2006 23:29:32 +0200
+Message-ID: <081606drssm194.navy@mr201.informatik.uni-rostock.de>
+
+Martin Vigerske schrieb:
+> >Hi,
+> >
+> >ich bin am Ueberlegen, ob ich mir am achten neunten nen Beamer besorge und
+> >mir alle meine Lieblingsepisoden reinziehe oder ob es nicht vielleicht
+> >doch ne interessantere Moeglichkeit gibt Star Treks vierzigsten zu 
+> >zelebrieren.
+> >Komme uebrigens aus Berlin. Vielleicht ein Kinoevent?
+> >
+> >Was macht ihr so an dem Tag?
+
+Aufstehen, arbeiten, nach Hause duesen, die Freundin fragen ob man die Sar 
+Trek VI
+DVD einlegen darf, Schultern senken und "Shakespeare in Love" ansehen,
+Schlafen.
+
+-----------------------------------------------------------------------------
+
+
+
+Atomstromfilter (Ronda, 11. Sep 2006, 00:13:30):
+Newsgroups: de.sci.electronics
+From: Volker Gringmuth <einklich@gmx.net>
+Subject: Re: Bild-Zeitung vs. Physik.
+Date: Tue, 5 Sep 2006 08:36:48 +0000 (UTC)
+Message-ID: <Xns98356BF4BD11Dbx@vg.einklich.net>
+
+HaJo Hachtkemper wrote:
+
+>>>> >>>> "Weshalb wird bei der Uebertragung von Strom durch
+>>>> >>>> Ueberlandleitungen eine hohe Spannung verwendet?
+>>> >>> das heisst jetzt "Stromspannung".
+>> >>
+>> >> Und betraegt in Europa 50 Hz.
+> >
+> > Ist das pro Stunde oder im Jahr?
+
+Pro Kraftwerk latuernich. 
+
+Bei Atomstrom koennte das etwas anders sein, da 50 Hz kein ganzzahliges 
+Vielfaches der Resonanzfrequenz des Uran-Kristallgitters ist. 
+
+Aber dagegen hilft bekanntlich ein Atomstromfilter, das dank 
+Tachyonendiskriminator die Atomelektronen aus dem Hausnetz fernhaelt.
+
+<http://www.nucleostop.de/Technik/technik.html> ist sicherlich bekannt?
+
+Am besten gefaellt mir ja der Satz: "Wir garantieren, dass nach Anschluss 
+des Geraets an Ihren Steckdosen auch mit feinster Analysetechnik kein 
+Atomstrom messbar ist." - das glaub ich sofort, allerdings war das auch 
+vorher schon nicht der Fall :)
+
+
+vG
+
+-----------------------------------------------------------------------------
+
+
+
+Wertsackbeutelbehaelterpaket (Ronda, 11. Sep 2006, 00:15:55):
+Schon etwas aelteres Zitat. Trotzdem ganz schoen gegen Kollegen einsetzbar,
+die sich ein bisschen "verkuensteln"...
+
+Ronda
+
+From: Emil 'nobs' Obermayr <nobs@tigress.com>
+Newsgroups: de.sci.electronics
+Subject: Re: Bild-Zeitung vs. Physik.
+Date: Tue, 05 Sep 2006 18:49:47 +0200
+Message-ID: <edk9rb$en6$02$1@news.t-online.com>
+
+Bjoern Schliessmann wrote:
+
+> > | Bei Zuegen, die ohne Zugbegleiter verkehren oder deren Zugbegleiter
+> > | nicht zum Zugfuehrer befugt sind, muessen Sie als
+> > | Triebfahrzeugfuehrer die Aufgaben des Zugfuehrers uebernehmen.
+
+Die Post kann sowas noch viel schoener:
+
+"Der Wertsack ist ein Beutel, der auf Grund seiner besonderen Verwendung im
+Postbefoerderungsdienst nicht Wertbeutel, sondern Wertsack genannt wird,
+weil sein Inhalt aus mehreren Wertbeuteln besteht, die in den Wertsack
+nicht verbeutelt, sondern versackt werden.
+ Das aendert aber nichts an der Tatsache, dass die zur Bezeichnung des
+Wertsackes verwendete Wertbeutelfahne auch bei einem Wertsack als
+Wertbeutelfahne bezeichnet wird und nicht als Wertsackfahne,
+Wertsackbeutelfahne oder Wertbeutelsackfahne.
+ Sollte es sich bei der Inhaltsfeststellung eines Wertsackes herausstellen,
+dass ein in einem Wertsack versackter Wertbeutel statt im Wertsack, in einem
+der im Wertsack versackten Wertbeutel haette versackt werden muessen, so ist
+die in Frage kommende Versackstelle unverzueglich zu benachrichtigen.
+ Nach seiner Entleerung wird der Wertsack wieder zu einem Beutel und ist
+auch bei der Beutelzaehlung nicht als Sack, sondern als Beutel zu zaehlen.
+Verwechslungen sind im Uebrigen ausgeschlossen, weil jeder Postangehoerige
+weiss, dass ein mit Wertsack bezeichneter Beutel kein Wertsack ist, sondern
+ein Wertsackpaket." 
+
+-----------------------------------------------------------------------------
+
+
+
+"Guten Appetit" in Great Britain (Ronda, 11. Sep 2006, 00:41:32):
+On 2006-09-09 Stefan Ram wrote:
+
+> > Klaas <klaas46@aol.com> writes:
+>>> >>>wer weiss, wie man in England einen guten Appetit wuenscht?
+>> >>Gar nicht. 
+> >
+> >   Das mag sein. Es gibt allerdings Versuche, guten Appetit
+> >   sinngemaess zu uebersetzen.
+> >
+> >       "Guten Appetit!"
+> >
+> >       "Enjoy your meal!", "Have a nice meal!"
+> >
+> >       This phrase sometimes is uttered routinely directly before
+> >       eating by every person at a table. It also might be
+> >       uttered by a single person without a dish (yet) to
+> >       indicate that the person hearing it, should feel free to
+> >       start eating, even if the speaker is not eating or is
+> >       still waiting for his plate.
+> >
+> > http://purl.net/stefan_ram/pub/woerterbuch_deutsch-englisch_de
+
+"On the continent there is good food. In Great Britain there are good table
+manners." ;-)
+
+-----------------------------------------------------------------------------
+
+
+
+GPS und der Papst (Ronda, 17. Sep 2006, 01:16:28):
+From: Ralph Haspel <No_Spam@web.de>
+Subject: Re: GPS am Wochenende
+Newsgroups: ger.ct
+Date: Tue, 12 Sep 2006 01:37:28 +0200
+Message-ID: <ee4rvc$cl8$1@newsreader2.netcologne.de>
+
+Gerd schrieb:
+> > wir waren am Wochenende zum Papstbesuch in Muenchen gewesen, dabei ist
+> > mir aufgefallen, dass mein Navigationssystem keine verwertbaren
+> > GPS-Signale erhalten hat.
+> > 
+Vielleicht stoeren die vielen Gebete das GPS. SCNR
+
+Mfg Ralph
+
+-----------------------------------------------------------------------------
+
+
+
+Schwanger am Kap der guten Hoffnung? (Ronda, 21. Sep 2006, 00:58:01):
+From: Philipp Reichmuth <reichmuth@web.de.invalid>
+Subject: Re: Menschen mit Behinderungen
+Newsgroups: de.etc.sprache.deutsch
+Date: Mon, 18 Sep 2006 14:09:08 +0200
+Message-ID: <4n7gj4F935okU2@individual.net>
+
+>> >> ("cape" = Umhang, oder auch Kap, wie in "Kap der guten 
+>> >> Hoffnung").
+ 
+> > Unter einem "Cape der guten Hoffnung" koennte ich mir wenigstens was
+> > vorstellen... ;)
+
+Ist das p.c. fuer "Umstandsmode"?
+
+-----------------------------------------------------------------------------
+
+
+
+Fussball-WM (Ronda, 21. Sep 2006, 01:03:14):
+... fuer Fussball-Fans nicht geeignet.
+
+Ronda
+
+(... nein, ich hab nicht gesagt, dass die das nicht verstehen wuerden... hab
+ich nicht!)
+
+From: "G.O.Tuhls" <gotuhls@aol.com>
+Subject: Re: Menschen mit Behinderungen
+Newsgroups: de.etc.sprache.deutsch
+Message-ID: <1158182663.319974.198170@m73g2000cwd.googlegroups.com>
+Date: 13 Sep 2006 14:24:23 -0700
+
+Andreas Prilop schrieb:
+> > So? Die Fussball-Weltmeisterschaft, die gerade stattfindet, ist aber
+> > die der "Menschen mit Behinderung".
+> >  http://www.inas-fid-wm2006.de/
+
+Zitat aus der zitierten URL:
+> > Bei der 4. Fussball-WM fuer Menschen mit Behinderung duerfen
+> > lediglich Sportler mit Lernschwaeche und einem Intelligenzquotienten
+> > von maximal 75 teilnehmen.
+
+Bitte, wodurch unterscheidet sich die Veranstaltung dann von dem Zirkus
+im Juni/Juli?
+
+Gruss
+G.O.
+
+-----------------------------------------------------------------------------
+
+
+
+Motorraeder. Betriebssysteme. (Ronda, 24. Sep 2006, 21:43:08):
+... eine Vespa wuerde ich mal mit einem Palm oder so vergleichen...
+
+Ronda
+
+Subject: Re: BMW: Das Microsoft unter den Motorraedern
+From: Volker Bartheld <dr_versaeg@freenet.de>
+Date: Fri, 22 Sep 2006 17:11:43 +0200
+Newsgroup: de.rec.motorrad
+
+Hi!
+
+> >Microsofts Virenanfaelligkeit ist das ABS der BMWs
+> >Fragt sich nur, wer hier die Rolle des Apple/Linux Lagers uebernimmt?
+
+Interessante Frage - man sollte das aber auch auf die Hardware erweitern
+um nicht Aepfel und Birnen zu vergleichen!
+
+Da fiele mir spontan eine Analogie zwischen Harley und einem IBM
+Mainframesystem mit OS/370 ein, laut, alt, ueberkommen,
+leistungsschwach, utopisch teuer in der Anschaffung, kompatibel zu nix
+und nur fuer einige graumelierte Poser der heilige Gral.
+
+Ducati hingegen koennte die hoffnungslos uebertaktete Daddelkiste eines
+PC-Gamers sein, mit Wasserkuehlung und fetten (Heat)Pipes versteht sich,
+der Laerm- und Hitzeentwicklung eines startenden Jets und schon im
+Leerlauf scheppert es munter vor sich hin - wenn nicht gerade
+kostspielige Reparaturen des fragilen Gesamtkunstwerks notwendig sind.
+
+Eine CBF900 oder andere seelenlose japonesische Reihenvierer muss man
+zwangslaeufig mit einem embedded Computer vergleichen, sagen wir einem,
+der in einem DVD-Spieler oder einer Waschmaschine werkelt. Alle Features
+funktionieren gnadenlos zuverlaessig und leidlich performant, die
+Anschaffung geraet zur geldboersenschonenden Angelegenheit und in der
+Anmutung ist das Bild etwa so lustvoll wie eine mikroprozessorgesteuerte
+Gefrierkombination von Siemens oder eben besser Panasonic (falls die
+soetwas herstellen).
+
+Eine KTM oder Husaberg koennte ihn ihrem kruden Charakter der
+LINUX-Gemeinde nahekommen. Man moechte wenig zahlen, kriegt ebenso oder
+gar noch weniger dafuer - einen gutgemeinten Bausatz eben, bastelt sich
+die Funktionalitaet mit allerlei Hilfsmitteln zurecht, stets am Rande
+der (DECSS) Illegalitaet, manchmal gibt es einen kapitalen Motorschaden,
+man muss den Kernel neu compilieren und der "Hersteller" (aka. die
+"Community") weiss natuerlich von nichts. Natuerlich traut man sich nie,
+offen ueber diese kleinen Problemerle zu sprechen, denn man hat sich ja
+schliesslich in vollem Wissen ueber die Konsequenzen fuer das beste
+Produkt der Welt entschieden und hier Schwaechen einzuraeumen, hiesse
+auch eigene Schwaechen zu gestehen. Die "Uptime" von mittlererweile fast
+10 Jahren wird groesstenteils in der (Schraub)garage verbracht.
+
+Natuerlich gaebe es da noch die Softieecke, die SuSes mit ihren
+Supermotokraedern, z. B. von M(u)Z, die sich den Anstrich eines fiesen
+Streetfighter-Outlaws geben - jedoch diesen nur im Stand vermitteln
+koennen, weil sie in Fahrt staendig von Mofas hergebrannt werden. Dafuer
+greifen sie gerne auch ein bisschen in die Tasche, bekommen aber
+schliesslich nur Dutzendware fuer die mit ein bisschen Muehe anderswo
+weit weniger zu bezahlen gewesen waere.
+
+Blieben noch die Aepfel unter den Motorraedern, da koennte ich mir
+zwanglos jedweden Custom-Chopper vorstellen. Als
+midlifecrisisgebeutelter Webdesigner mit verwoehntem Hintern laesst man
+schliesslich nicht jedes Mopped in die Garage und auch nicht jeden Muell
+von der Stange auf seinen Schreibtisch. Function follows form, man
+weidet sich in einer gewissen Distinguiertheit am durchdesignten
+Chromtand der perfekt mit bauchigen Formen und Pastelltoenen harmoniert
+und kommt bei der geringsten Spur eines Problems sofort beim Haendler
+des geringsten Misstrauens angeweint - wenn z. B. der Tank leer oder das
+Zuendschloss nicht intuitiv zu bedienen ist.
+
+Die grosse Windowsgemeinde sehe ich i.d. T. sehr gut bei BMW aufgehoben,
+man ist liquide, User, zahlt gerne gutes Geld fuer grossen Schrott -
+Hauptsache es ist alles aus einem Guss und kommt brav alle naslang zum
+"Patchday" angedackelt, wo alte Bugs gegen neue ausgetauscht werden.
+Irgendwie steht irgendwo irgendwann auch alles in der Doku, man muss
+sich nur die Muehe machen und sie sich aus dem Internet, zahlreichen
+Foren oder der Hilfeseite des Hersteller destillieren. Fehler gibt es
+natuerlich nie, hoechstens Features, und die naechste Release ist
+freilich so ungleich viel besser als die alte, dass man am besten gleich
+updatet und natuerlich jeglichen Support verliert, so man es nicht tut.
+Aber klar: Man ist frei, hat die Wahl.
+
+
+Gruesse,
+Volker
+
+-----------------------------------------------------------------------------
+
+
+
+Aldi, Al Kaida und das Flaschenpfand (Ronda,  3. Okt 2006, 20:37:33):
+Betreff: Re: Guenstige Produkte in Plastikflaschen
+Datum: Mon, 25 Sep 2006 16:08:36 +0200
+Von: Heiko Kradewitch <heikokrad@arcor.de>
+Newsgruppen: de.alt.fan.aldi
+Message-ID: <ef8nt4$2eu$02$2@news.t-online.com>
+
+Mang, Egon schrieb:
+> > Bitte, bitte, beachten: Dieser Barcode sagt dem Automaten: "Befpfandete
+> > Plastikflasche" und sie wird sofort zerschreddert.
+> > Dies bitte auf KEINEN FALL mit einer Glasflasche probieren!
+
+Was passiert dann eigentlich? Schafft es die Presse, das Glas zu
+zermalmen oder steigt Qualm auf? Irgendwie lustiger Gedanke.
+
+Man stelle sich vor, Al Kaida beauftragt seine Juenger in ganz
+Deutschland an einem Stichtag punkt 9 Uhr in Deutschlands Automaten
+zeitgleich eine preparierte Glasflasche zu stecken. Das
+Einwegpfandsystem wuerde zusammenbrechen... :-)
+
+Gruesse,
+Heiko
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Aldi, Al Kaida und das Flaschenpfand (Vanir,  3. Okt 2006, 22:39:29):
+~#! rn=Ronda rt=1159900653 rg=schmarrn.netdigest
+~#! tid=1159900653
+Das bringt mich auf boese Ideen.
+
+Vanir ap Nial.
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Aldi, Al Kaida und das Flaschenpfand (Vanion,  4. Okt 2006, 09:46:14):
+~#! rn=Vanir rt=1159907969 rg=schmarrn.netdigest
+~#! tid=1159900653
+Warjaklar.
+
+V*, grinst.
+
+-----------------------------------------------------------------------------
+
+
+
+Und wieder mal: GEZ (Ronda,  4. Okt 2006, 21:04:01):
+From: Jens Arne Maennig <maennig0608@cricetus.com>
+Subject: Re: mal wieder: nicht GEZahlt!
+Newsgroups: de.etc.beruf.selbstaendig
+Date: Fri, 29 Sep 2006 16:33:21 +0200
+Message-ID: <qdxowg8nh4an.dlg@news.cricetus.com>
+
+Harald Friis schrieb:
+
+> > Ich bekam nun eine "Letzte Erinnerung" mit Androhung eines Bussgeldes 
+> > bis 1.000 Fragezeichen, wenn ich nicht endlich antworte, ob ich einen 
+> > PC zu Hause habe.
+
+Falls du sowas sammelst, bitte: http://jam.uttx.net/letzte.pdf :-)
+
+> > Derzeit bin ich "privat" mit meinem TV gemeldet, aber 
+> > natuerlich nicht geschaeftlich, auch kein Radio.
+
+Status bei mir: Ich lebe gemeinsam mit meiner Freundin in einem Haus,
+in dem auch die GmbH ihren Sitz und ihr Buero hat. Meine Liebste zahlt
+Rundfunkgebuehren, voller Satz fuer TV und Radio. Ich bin als
+Privatperson Halter eines Pkw, fuer den ich Radiogebuehren zahle. Diesen
+Pkw benutze ich hin und wieder auch in meiner Eigenschaft als
+Geschaeftsfuehrer der GmbH.
+
+Seit Ende letzten Jahre hat die GEZ rumgequengelt (auch per Telefon),
+dass sie *wenigestens irgendwelche* Kohle von der GmbH will.
+Schliesslich meinte die Sachbearbeiterin, dass die GmbH fuer das
+Autoradio meines Pkw auch zahlen muesse, weil der ja bisweilen fuer die
+GmbH eingesetzt werde. Ich konterte mit dem Passus des
+Rundfunkgebuehrenstaatsvertrags, nach dem fuer ein Empfangsgeraet immer
+nur einmal eine Gebuehr entrichtet werden muss, was ich als
+Privatperson ja bereits tat.
+
+Nach einiger Beratung befand die GEZ dann schliesslich, dass es so
+natuerlich ueberhaupt nicht gehe, sondern dass dann nicht die
+Privatperson Jens Arne Maennig die Rundfunkgebuehr zahlen muesse, sondern
+die GmbH. Ich zitierte daraufhin den Passus des
+Rundfunkgebuehrenstaatsvertrags, nach dem bei Autoradios immer der
+Fahrzeughalter gebuehrenpflichtig ist, nicht irgendwelche Dritten.
+
+Nach weiteren Beratungen bei der GEZ rief man mich wieder an und
+teilte mir mit, dass ich als Privatperson dann wenigstens als
+gewerblicher Nutzer bei der GEZ gefuehrt werden muesse. Meinen Einwand,
+dass ich nun mal kein Gewerbetreibender bin (das Einzelgewerbe ist
+schon laenger abgemeldet), mochte man so nicht gelten lassen.
+
+Ich erhielt also von der GEZ eine schriftliche Bestaetigung meiner
+Kuendigung, ein freundliches Begruessungsschreiben als neuer
+Gebuehrenzahler und eine neue Kundennummer. Alles, wie gesagt, als
+Privatperson. Da der Betrag der Gebuehren der gleich war, hat es mich
+nicht weiter interessiert und ich war froh, endlich Ruhe vor dem
+Haufen zu haben.
+
+Dass die ganze Aktion wegen der GmbH stattgefunden hatte, hatten die
+erhabenen GEZ-Mitarbeiter schaeinbar aber schon nach wenigen Wochen
+wieder vergessen, denn da kam schon wieder das naechste
+Standardschreiben an die GmbH. Und ich werde abermals nicht antworten,
+bis sie mich anrufen, denn die GmbH ist auch weiterhin nicht
+rundfunkgebuehrenpflichtig im Sinne des Rundfunkgebuehrenstaatsvertrags.
+Waer ja auch komisch, denn sie hat ja als juristische Person nicht mal
+Augen zum Fernsehen oder Ohren zum Radio hoeren. Warum sollte Sie dann
+ein Rundfunkempfangsgeraet besitzen?
+
+Dass die GEZ als "self supporting system" immer gluecklich ist, wenn
+ihre Mitarbeiter etwas zu tun haben, kann ich gut nachvollziehen.
+Leider muss ich aber meinem Broterwerb anderweitig nachgehen und werde
+mich daher nicht mehr als noetig in die Uebungsfirma-Therapien der GEZ
+eingliedern lassen.
+
+Den naechsten Schock werden sie uebrigens ab Januar 2007 bekommen: Dann
+werden sie naemlich feststellen muessen, dass die GmbH noch nicht einmal
+einen Computer besitzt, geschweige denn einen Internetanschluss. Das
+wird vermutlich sehr, sehr hart fuer die armen GEZ-Mitarbeiter werden.
+
+Aechz,
+
+Jens
+
+-----------------------------------------------------------------------------
+
+
+
+Kaiserschnitt (Ronda,  5. Okt 2006, 18:56:33):
+Subject: Re: Freude in Japans Kaiserhaus ueber Jungen
+From: Florian Diesch <diesch@spamfence.net>
+Message-ID: <20060906113921.7287.1.NOFFLE@dieschf.news.arcor.de>
+Date: Wed, 06 Sep 2006 13:39:21 +0200
+Newsgroups: arcor.misc
+
+Arcor Newsticker <dpa@arcor-online.net> wrote:
+
+> > 06.09.2006, 01:57 Uhr
+
+> >     Tokio (dpa) - Freude und Erleichterung in Japans Kaiserhaus:
+> >   Prinzessin Kiko hat nach japanischen Fernsehberichten einen
+> >   Jungen zur Welt gebracht. Damit haben sich die Hoffnungen der
+> >   Traditionalisten erfuellt, denn der aeltesten Monarchie der Welt
+> >   drohte in der uebernaechsten Generation das Aus. Es ist das erste
+> >   Mal seit ueber 40 Jahren, dass wieder ein Junge in die Familie
+> >   des Kaisers geboren wurde. Die Geburt des dritten Kindes von
+> >   Prinzessin Kiko und Prinz Akishino erfolgte durch
+> >   Kaiserschnitt.
+
+Standesgemaess.
+
+
+   Florian
+
+-----------------------------------------------------------------------------
+
+
+
+Idomeneo-Trubel zusammengefasst (Ronda,  6. Okt 2006, 23:14:11):
+Subject: Idomeneo abgesetzt
+From: "Jakob Achterndiek" <achterndiek@buzemann.net>
+Date: Wed, 27 Sep 2006 09:23:58 +0200
+Message-ID: <op.tgiz58f05adrpp@0000000000-0000.dialin.t-online.de>
+Newsgroups: de.rec.musik.klassik
+
+Am 26.09.2006, 18:00 Uhr, schrieb Martin Gerdes <martin.gerdes@gmx.de>:
+
+> > Hat denn die Enthauptung der "Glaubensautoritaeten" in dieser Inszenierung
+> > eine so tragende Bedeutung, dass sie unbedingt dargestellt werden muss?
+> > http://www.welt.de/data/2006/09/25/1050327.html?prx=1
+
+
+Die "Idomeneo"-Fabel ist weichgespuelte griechische Tragoedie: Ein Kessel
+Buntes aus dem grossen homerischen Vorrat, im Schonwaschgang delikat
+vermischt, aber dann huebsch ordentlich zum Trocknen in die milde Sonne
+der Humanitaet gehaengt. Die Moral von der Geschicht: Wenn die Menschen
+nur recht brav sind und lieb zueinander, dann muessen sogar Goetter und
+andere Ungeheuer nachgeben: Weichgespuelte Tragoedie, aber als Opern-
+libretto goldrichtig, weil die Handlung kaum von der Musik ablenkt.
+
+Jetzt aber Neuenfels: Der sorgt sich halt um sein Publikum; denn das
+mit der Humanitaet und so, das kriegen die Leute womoeglich vor lauter
+Musik gar nicht richtig mit! Da hilft er nach! Da genuegt nicht EIN
+See-Ungeheuer und EIN Poseidon - es muss schon der ganze grosse weite
+Goetterhimmel sein, der am Ende der Groesse des Menschen weicht. Und
+weil die Goetter eh nur eine Erfindung sind, muss das Exempel an den
+Erfindern der Goetter, den Propheten, statuiert werden. Das ist
+logisch. Das ist begreifbar. Das ist Neuenfels.
+
+Bloss dem Publikum hat das schon bei der Premiere vor drei Jahren nicht
+gefallen: So viel Blut erschien den Leuten wohl irgendwie inhuman.
+Da haben sie gebuht. Hat aber damals nichts genuetzt.
+
+Damals.
+
+Aber jetzt haben ein paar wohlmeinende Buerger den Polizeipraesidenten
+gewarnt: Es moechten womoeglich nicht nur die kunstsinnigen Liebhaber des
+Guten, Wahren, Schoenen Anstoss nehmen, sondern auch boese, gewaltbereite
+Muselmaenner. Die machten dann womoeglich nicht nur buuhh!, sondern 
+Bumm!
+
+-----------------------------------------------------------------------------
+
+
+
+Mathe rulez? (Ronda,  7. Okt 2006, 19:07:19):
+Zustimmung zur Einreichung liegt vor.
+
+From: bernd_usenet@gmx.de (Bernd Sluka)
+Newsgroups: de.rec.fahrrad
+Subject: Re: "Fahrradhelm rettete Schuelerin das
+Leben"  (Schundartikel in der MoPo)
+Date: Fri, 29 Sep 2006 15:36:31 +0000 (UTC)
+Message-ID: <efjehv$53t$4@paulchen.sluka.de>
+
+Am Fri, 29 Sep 2006 02:33:56 +0200 schrieb Bodo Eggert:
+> > Falk Duebbert <removethis.falk@zeitgleiter.de> wrote:
+> > 
+>> > > - Fahrlehrer sollten verstaerkt aus anderen Berufen gewonnen und das
+>> > > Qualifikationsniveau gehoben werden. Hauptschulabschluss und
+>> > > Handelsfachpackerlehre duerfen nicht mehr als Zugangsvoraussetzung
+>> > > genuegen.
+> > 
+> > Um es ueberspitzt zu formulieren: Physikstudium, Nebenfach Psychologie?
+
+Nein, Mathematik genuegt.
+
+Denn:
+Psychologie ist ja nur ein Teilgebiet der Medizin.
+Medizin ist eigentlich auf Menschen angewandte Biologie.
+Biologie beruht auf chemischen Vorgaengen im Koerper, ist also nichts
+anderes als Chemie (Biochemie).
+Chemie ist die Umsetzung der Physik auf die Umwandlung von Stoffen.
+Physik ist auf die Natur angewandte Mathematik.
+Es genuegt also ein solides Mathematikdiplom.
+
+-----------------------------------------------------------------------------
+
+
+
+Bekennerschreiben in der ZEIT (Ronda, 10. Okt 2006, 20:16:57):
+From: Thomas Schade <toscha@rrr.de>
+Subject: Re: dass mit ss?
+Newsgroups: de.etc.sprache.deutsch
+Date:Sat, 07 Oct 2006 15:13:01 +0200
+Message-ID: <4527A7DD.6050307@news.toscha.de>
+
+>> >> Rechtschreibregeln vom Ort des Schreibenden abhaengig zu machen, halte
+>> >> ich fuer wenig sinnvoll.
+> > 
+> > Wo es nur auf Inhalt ankommt, ist das nicht so wichtig. Wo es auch 
+> > auf Form ankommt (Zeitung, Behoerdenbriefe, Anschlaege) aber schon.
+
+Zweifellos. Gerade Bekennerschreiben zu einem Terroranschlag werden sehr
+viel ernster genommen wenn sie formal und orthografisch korrekt 
+daherkommen. Insbesondere wenn sie in Hamburg bei der ZEIT eingereicht
+werden und nicht bei Aljazeera in Doha.
+
+-----------------------------------------------------------------------------
+
+
+
+Artgerecht. (Ronda, 17. Okt 2006, 01:34:04):
+Passend dazu auch die Signatur in einem Grill-Forum: PETA: People Eating Tasty
+Animals. Aber nun der Artikel (nicht Vegetariertauglich):
+
+Message-ID: <egtiim$e7p$5@usenet.steering-group.net>
+Subject: Re: 2. RfD: de.(etc|sci).landwirtschaft (Einrichtung)
+Date: Sun, 15 Oct 2006 15:02:46 +0000 (UTC)
+From: Nils Ketelsen <nils@steering-group.net>
+Newsgroups: de.admin.news.groups
+
+Johannes Bretscher wrote:
+> > Kathinka Wenz wrote:
+>> > > Weil sie artgerechte Schlachtung verlangt?
+> >
+> > Was ist denn "artgerechte Schlachtung"?
+
+Wenn man die Kuh ueberredet Selbstmord zu begehen.
+
+Nils
+
+-----------------------------------------------------------------------------
+
+
+
+IG Nobel Price (Ronda, 17. Okt 2006, 22:18:14):
+Der "Ig Nobel Prize" wird alljaehrlich u.a. an Menschen vergeben , 
+die amuesante wissenschaftliche Studien durchgefuehrt haben.
+
+In diesem Jahr gehoeren zu den Gewinnern die Herren Svenson & Barnes,
+welche die Anzahl Fotografien berechneten, die notwendig sind, um
+(fast) sicher zu gehen, dass auf einem Gruppenfoto niemand die Augen
+geschlossen hat.
+
+http://improbable.com/ig/ig-pastwinners.html#ig2006
+MATHEMATICS: Nic Svenson and Piers Barnes of the Australian
+Commonwealth Scientific and Research Organization, for calculating the
+number of photographs you must take to (almost) ensure that nobody in
+a group photo will have their eyes closed
+REFERENCE: "Blink-Free Photos, Guaranteed," Velocity, June 2006,
+
+-----------------------------------------------------------------------------
+
+
+
+Da moechte man sich ueber Recycling keine weiteren Gedanken machen. (Ronda, 24. Okt 2006, 23:29:08):
+From: Juergen Klein <Nospam@web.de>
+Subject: Re: Drainage an Kanal anschliessen...
+Newsgroups: de.rec.heimwerken
+Date:Sat, 21 Oct 2006 21:51:45 +0200
+Message-ID: <453a7a4e$0$18851$9b4e6d93@newsspool4.arcor-online.net>
+
+> > Ich weiss eh nicht, was diese Muellphobie soll. Gemeinhin
+> > hat man mal weniger, mal mehr Muell. Insbesondere will
+> > man mal richtig ausmisten, hat man hier in Deutschland
+> > ein echtes Logistikproblem, naemlich wohin mit dem Mist.
+ 
+> > In .fr, jedenfalls bei uns im Dorf, gibt es gar keine
+> > Muelleimer. Man verpackt ihn in einem muellgerecht
+> > erscheinende Behaeltnisse, was immer man findet, und
+> > stellt soviele davon an die Strasse, wie man eben loswerden
+> > will.
+
+In dem Fall wuerde ich befuerchte, dass die Muellabfuhr mein Automobil
+irrtuemlich mitentsorgen koennte.
+
+Von meiner Nachbarin in ihrer Nylonschuerze mal ganz zu schweigen...
+
+-----------------------------------------------------------------------------
+
+
+
+Germanische Fussball-WM? (Ronda, 24. Okt 2006, 23:30:31):
+From: Andreas Pohlke <newsrd1@baby-boomer.de>
+Subject: Re: Der Freistaat
+Newsgroups: de.etc.sprache.deutsch
+Date: Mon, 16 Oct 2006 11:42:07 +0200
+Message-ID: <egvk5f$61q$1@daniel-new.mch.sbs.de>
+
+>>> >>>Und warum diese Umschreibungen? Wem nuetzen sie?
+ 
+>> >> Den Journalisten, die Wortwiederholungen vermeiden wollen. Es ist ein
+>> >> deutschlandweites Phaenomen, das mir besonders in der
+>> >> Sportberichterstattung begegnet.
+
+> > Das findest du schon in der Ilias bei Homer - Achilles, der Pelide, der
+> > Vielgeruehmte etc. pp. Grauenvoll!
+
+> > Aber die Ilias ist natuerlich auch eine Art Sportberichterstattung.
+
+Analog zu den germanischen Goettersagen?
+Valhalla:Joetunheim 4:0
+Tore durch Herfoer, Gangrr, Fimbululr und Angan Friggjar.
+Rote Karte fuer Loki in der 2. Halbzeit.
+
+-----------------------------------------------------------------------------
+
+
+
+Firmen-Newsgroups als Knowledge-Goldgrube (Ronda, 27. Okt 2006, 21:36:59):
+[firmeninternes Fundstueck, wie ueblich anonymisiert]
+
+Newsgroups: xxxxxx.infoboerse
+Subject: Re: Apfelrest ?
+From: $NAME <$NAME@$DOMAIN>
+Date: Wed, 18 Oct 2006 10:28:04 +0200
+Message-ID: <eh4oik$i8e$1@news.xxxxxx.de>
+
+> > Wer kennt noch andere Woerter fuer den Rest eines Apfels ?
+> > NRW: Apfelkitsche (wirklich)
+> > BW: Apfelbuzzen
+Hessen (zumindest meine Gegend): Apfelkrotzen
+Ist wirklich ein bloedes Wort und geschrieben siehts noch schlimmer aus
+als gesprochen, muss ich gerade feststellen.
+
+Es gibt uebrigens genug Leute, die das, was vom Apfel uebrigbleibt, wenn
+sie ihn gegessen haben einfach 'Stiel' nennen. Das liegt dann aber nicht
+am Dialekt sondern an der Essensweise. 
+
+-----------------------------------------------------------------------------
+
+
+
+Irgendwie klingt das plausibel... (Ronda, 27. Okt 2006, 21:43:13):
+... wobei... auch bei AMERIKANISCHEN Flugzeugtraegern...?
+
+Ronda *arbeitet fuer eine Amerikanische Firma und hat manchmal Amerikanische
+Kunden...*
+
+From: Markus Nordhausen <irgendwas_lustiges@web.de>
+Newsgroups: de.alt.folklore.urban-legends
+Subject: Re: Flugzeugtraeger vs. Leuchtturm
+Date: Tue, 24 Oct 2006 09:40:49 +0200
+Message-ID: <ehkg22$6i5$1@storm.tf.uni-kiel.de>
+
+Hallo 
+
+Entschuldigung, wenn ich mich als normalerweise nur Mitlesender einmische.
+
+Das ganze ist reichlich unwahrscheinlich.
+Eigentlich gibt es nur zwei Moeglichgkeiten. Entweder Sichtkontakt oder
+Radarsichtung.
+
+Bei beiden laesst sich durch Kontrolle, ob die "Peilung steht" schnell
+feststellen, ob ueberhaupt Kollisiongefahr besteht. Dazu muss die Peilung
+gleich bleiben und der Abstand geringer werden. Das ist, wenn ein Objekt
+steht, was bei Leuchttuermen im allgemeinen als sicher anzunehmen ist
+(Kontinentalverschiebung kann vernachlaessigt werden), nur der Fall, wenn
+die Objekte direkt auf einander zu fahren. Bei Sichtkontakt kann man die
+Beleuchtung eines Leuchtturm auch ohne Blick in die Karte sehr leicht, von
+der Beleuchtung eines Schiffes, das unter Maschine faehrt unterscheiden.
+Erstrecht bei direktem Gegenkurs. 
+Bei Radarsichtung gilt aehnliches. Ein Schiff, das so gross ist, dass es
+eine Radaranlage an Bord hat, weiss wo es sich befindet. Punkt, aus,
+Schluss.  Sonst haette es nicht Schiff werden duerfen. Wenn es das nicht
+genau weiss, so doch wenigstens ungefaehr. Und das hiesse zum Beispiel, das
+in die Karte geschaut wuerde. Dann wuerde hoechstwahrscheinlich sogar
+dieser Leuchturm als Peilobjekt genommen, um die Position festzustellen.
+(Peilung und Radarabstand).
+
+Nicht zu wissen, wo man ist passiert eigentlich nur Hobbyseglern. Aber dazu
+gibt es dann die Broetchennavigation. Einfach solange fahren, bis man einen
+Hafen findet. Zum Baecker gehen. Broetchen kaufen. Und dann auf der Tuete
+nachlesen, wo man ist. 
+
+Gruss aus Kiel, 
+Markus (bin jetzt wieder still)
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Firmen-Newsgroups als Knowledge-Goldgrube (Darklor, 27. Okt 2006, 22:03:03):
+~#! rn=Ronda rt=1161977819 rg=schmarrn.netdigest
+~#! tid=1161977819
+Apfel-Griepsch?
+
+Darklor
+
+-----------------------------------------------------------------------------
+
+
+
+Kein Titel (Ronda, 27. Okt 2006, 22:35:45):
+Nein, dazu faellt mir echt kein Titel ein.
+
+Ronda
+
+From: Otto Doenneweg <fpiesepampel.2.spamorkus@spamgourmet.com>
+Newsgroups: de.soc.weltanschauung.christentum
+Subject: Angriff der Gottlosen auf unsere kleinen Jungs: Sitzpinkeln wider die
+Schoepfungsordnung ;-)
+Date: Thu, 12 Oct 2006 21:33:53 +0200
+Organization: 1&1 Internet AG
+Lines: 27
+Message-ID: <4f1ti2tedkeqd76ao4a21jkm4eoe9ld1rd@4ax.com>
+
+Nun greifen die gottlosen Atheisten, Kommunisten und Marxisten sogar
+kleine Jungs an: Man darf nicht mehr Mann sein:
+
+http://www.spiegel.de/schulspiegel/ausland/0,1518,441799,00.html
+
+Man merkt es allenthalben: Das Ende ist in wenigen Monaten da.
+Kleine Jungs muessen Sitzpinkeln. Ein wahrer Christ wettert:  "Wenn Jungs
+nicht auf die natuerliche Weise pinkeln duerfen, wie sie es seit
+Generationen getan haben, ist das ein Eingriff in Gottes Schoepfung".
+
+Befund der Bibel: "Maenner stehen" (Gen 18,2), "Bleibt stehen" (Ex 14,13;
+1. Sam 14,9), "Priester und Leviten stehen" (1 Chr 28,1), "bleibt aber
+stehen" (2.Chr 20,17), "Ich will ... stehen" (Hab 2,1), "dort blieb er
+stehen" (Mt 2,9), "er liess sie stehen" (Mt 21,17), u.v.a.m.
+Der evangelikale Bibelkenner kann daraus eindeutig eruieren, dass
+Sitzpinkeln wider die Bibel, wider die Schoepfungsordnung ist.
+
+Auch die Botschaften aus Medjugorje sprechen eine eindeutige Sprache:
+"die Seher stehen an einer Eiche" (1981), "wir stehen" (1984).
+
+Bibeltreue Maenner, kleine wie grosse, wissen, dass Sitzpinkeln suendhaft
+ist. Dass Evas sie dazu zwingen wollen, weckt Erinnerungen an Gen 3.
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Firmen-Newsgroups als Knowledge-Goldgrube (Gnome, 28. Okt 2006, 21:26:49):
+~#! rn=Darklor rt=1161979383 rg=schmarrn.netdigest
+~#! tid=1161977819
+Allerhoechstens "Apfelgriepsch".
+
+Macht-ja-nix.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Firmen-Newsgroups als Knowledge-Goldgrube (Kessa, 29. Okt 2006, 09:37:58):
+~#! rn=Gnome rt=1162063609 rg=schmarrn.netdigest
+~#! tid=1161977819
+Nee. Also wenn, dann Apfel Griepsch. So geht gutes altes Cuury Wurst Buden
+Deutsch, und das nicht erst seit der Recht Schreib Reform.
+[B
+Kessa, mit Telnet, daher fuer anderere Fehler als die beabsichtigten um
+Entschuldigung bittend
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: Firmen-Newsgroups als Knowledge-Goldgrube (Muadib, 29. Okt 2006, 10:01:04):
+~#! rn=Kessa rt=1162111078 rg=schmarrn.netdigest
+~#! tid=1161977819
+was ist apfelgriepsch?
+
+-----------------------------------------------------------------------------
+
+
+
+Re^5: Firmen-Newsgroups als Knowledge-Goldgrube (Kessa, 29. Okt 2006, 10:11:02):
+~#! rn=Muadib rt=1162112464 rg=schmarrn.netdigest
+~#! tid=1161977819
+Laut meinen Vorrednern das, was vom Apfel nach dem Essen ueberbleibt. Bei uns
+heisst das Appelkripsch.
+*
+
+-----------------------------------------------------------------------------
+
+
+
+Re^6: Firmen-Newsgroups als Knowledge-Goldgrube (Muadib, 29. Okt 2006, 10:14:17):
+~#! rn=Kessa rt=1162113062 rg=schmarrn.netdigest
+~#! tid=1161977819
+ah ein apfelgrotze
+oder apfelbutze
+
+-----------------------------------------------------------------------------
+
+
+
+Re^6: Firmen-Newsgroups als Knowledge-Goldgrube (Muadib, 29. Okt 2006, 10:14:33):
+~#! rn=Kessa rt=1162113062 rg=schmarrn.netdigest
+~#! tid=1161977819
+wobei, bei mir bleibt eigentlich nur der stiel ueber
+
+-----------------------------------------------------------------------------
+
+
+
+Re^7: Firmen-Newsgroups als Knowledge-Goldgrube (Gloinson, 29. Okt 2006, 11:44:46):
+~#! rn=Muadib rt=1162113273 rg=schmarrn.netdigest
+~#! tid=1161977819
+Dito. Aber andere Leute lassen hier Apfelgriebsche zurueck. Hat einer mal
+einen Duden? :D
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^8: Firmen-Newsgroups als Knowledge-Goldgrube (Muadib, 29. Okt 2006, 11:50:17):
+~#! rn=Gloinson rt=1162118686 rg=schmarrn.netdigest
+~#! tid=1161977819
+fruchtfleischumanteltes kerngehaeuse mit bissspuren?
+
+-----------------------------------------------------------------------------
+
+
+
+Re^9: Firmen-Newsgroups als Knowledge-Goldgrube (Marcus, 29. Okt 2006, 12:00:43):
+~#! rn=Muadib rt=1162119017 rg=schmarrn.netdigest
+~#! tid=1161977819
+Das Wort hab ich immer nur ausgesprochen gehoert in meiner Jugend,
+aber nie geschrieben ;)
+
+Ciao, Marcus
+
+-----------------------------------------------------------------------------
+
+
+
+Re^10: Firmen-Newsgroups als Knowledge-Goldgrube (Muadib, 29. Okt 2006, 12:01:17):
+~#! rn=Marcus rt=1162119643 rg=schmarrn.netdigest
+~#! tid=1161977819
+kerngehaeuse?
+
+-----------------------------------------------------------------------------
+
+
+
+Re^11: Firmen-Newsgroups als Knowledge-Goldgrube (Vanion, 29. Okt 2006, 15:34:06):
+~#! rn=Muadib rt=1162119677 rg=schmarrn.netdigest
+~#! tid=1161977819
+Na wenn das ein Wettbewerb ist: Apfel-Knust.
+
+V*
+
+-----------------------------------------------------------------------------
+
+
+
+Das haette auch in der MPA stehen koennen, oder? (Ronda,  3. Nov 2006, 20:13:41):
+From: Nico Hoffmann <oxensepp@gmx.de>
+Subject: Re: Buch von Daniel Coyle ?ber Lance Armstrong
+Newsgroups: de.alt.arnooo
+Date: 2 Nov 2006 09:59:49 GMT
+Message-ID: <slrnekjg77.a5q.oxensepp@haydn.lewonze.de>
+
+Matthias Gerber schuf ein Stueck Prosa:
+
+> > Wie heisst es so schoen? Jeder ist sich selbst der naechste, also wieso 
+> > tretet ihr euch nicht sowieso alle in den eigenen Arxxx. Meiner ist mir 
+> > fuer euch zu schade.
+> >
+> > Habt ihr ganzen Newsgroups-Supervisor, -Richter und Moralapostel mal 
+> > zusammengerechnet, wieviel Zeit eures langweiligen Lebens die 
+> > Massregelung anderer gekostet hat. Ist es euch wirklich nicht moeglich, 
+> > eine Nachricht unkommentiert zu lassen oder basiert ist euer Verhalten 
+> > auf 'ner Sucht???
+> >
+> > Dann empfehle ich euch. Holt mal wieder den Ball raus und geht draussen 
+> > spielen, fahrt mit dem Fahrrad (ja mit Stuetzraedern) oder sammelt 
+> > Maikaefer. Kinder glaubt mir das ist viel wichtiger als bescheuerte 
+> > Benimmregeln im Drahteselforum.
+> >
+> > Und eure Drohungen sind so durchdringend wie die eures Idols: HuiBuh
+
+
+Es gibt also doch noch Hoffnung, der Pisa-Generation und dem
+160-Zeichen-Limit zum Trotz. Wie man sieht wird eben gerade im Usenet
+die klassische deutsche Sprache in ihrer schlichten Erhabenheit nicht
+nur erhalten, sondern auch angewandt.
+
+Trotzdem wirkt der Text nicht gekuenstelt, die Worte sind durchaus auch
+Mittel zum Zweck. Mehr noch, das ist nicht nur toenendes Erz und
+klingende Schelle, hier wird ein dringendes Anliegen
+niedergeschrieben.
+
+
+Also kurz gesagt: Einen so klar geschrieben und dicht formulierten
+Antrag auf die Aufnahme ins Killfile habe ich schon lange nicht mehr
+gelesen.
+
+F'up,
+
+N.
+
+-----------------------------------------------------------------------------
+
+
+
+Noe, das geht nicht ums MG (Ronda, 16. Nov 2006, 01:22:38):
+From: Thomas Brandt <tb.usenet@online.de>
+Subject: Re: Dungeons
+Newsgroups: de.rec.spiele.rpg.misc
+Date: Fri, 10 Nov 2006 12:37:23 +0100
+Message-Id: <ej1o9h$p84$1@online.de>
+
+VeilOfOblivion schrieb:
+> > Hallo alle zusammen,
+> >
+> > jeder kennt ja die mit Monstern, Fallen und unglaublichen Schaetzen
+> > gespickten Hoehlen, Ruinen, Minen usw... die Dungeons eben...
+> > Wenn man an das Thema aber ein bischen logischer rangehen will, kommen
+> > doch einige Fragen auf:
+> >
+> > Monster :
+> > - Wer hat den 10m Drachen in die 12m Hoehle gepackt und wieso
+> > verhungert er da nicht?
+
+Er ist da drin, weil die Hoehle einen Hinterausgang hat, der gross genug
+ist, und weil Drachen darauf stehen im dunklen auf Gold zu liegen. Da
+Drachen auch nur eine Jungfrau, mit ein paar geroesteteten Helden als
+Nahrungsergaenzung, brauchen um Monate zu ueberleben, duerfte das kein
+Problem sein.
+
+> > - Wieso streifen da irgendwelche Orcs durch laengst vergessene
+> > Hoehlengaenge
+
+Das ist die Wandergruppe der Elementarschule Grunzheim Sued, die wollten
+die Hoehlenmalerien studieren, aber da kamen diese miesen Helden an und
+metzeln sie nieder.
+
+Ausser der Wandergruppe gibt es noch Guenther, den Altork, der mit Hilfe
+von zwei Zwergen, gegen eine kleine Pesnion die Fallen oelt, denn die
+haben Tradition.
+
+> > - Wieso loesen die dort "beheimateten" Monster eigentlich nie selbst
+> > die Fallen auf
+
+Weil sie wisse wo sie sind, schliesslich oelen und pflegen sie sie.
+
+> > Fallen :
+> > - Wer spannt die versteckte Bolzenfalle jedesmal wieder ?
+
+Guenther.
+
+> > - Warum sind die Fallen ueberhaupt dort ?
+
+Tradition. Weil es ein Dungeon und net die Marienglashoehle bei Tabarz
+ist, gehoert halt dazu.
+
+> > - Verrotten irgendwelche Fallen aus Holz eigentlich nicht nach 1000
+> > Jahren ?
+
+Guenther.
+
+> > Schaetze :
+> > - Wer hat die da hingelegt ?
+
+Der Drache hat sie beim Transport verloren, taucht in seiner Bilanz auf.
+
+> > - Wieso finden die dort "beheimateten" Monster diese nicht ?
+
+Weil sie wissen wo die liegen. Siehe die Erklaerung fuer Fallen, das
+gehoert dazu und Guenther bekommt ja eine Pension.
+
+> > - Wieso haben die Monster solche Dinge bei sich wenn man sie nach dem
+> > Kampf durchsucht und wieso benutzen sie diese nie?
+
+_Das_ ist einfach nur ein Fehler des SL. Wenn ein Monster was fallen
+laesst, dann hatte es das auch vorher.
+
+> > - Wieso hat noch keiner vorher gefunden?
+
+Es gibt da einen Fond, der das bezahlt und wenn man den Drachen besiegt
+hat, dreht sich ja die Wand in den Tauschbasar und tauscht den Loot
+gegen eine PS3 ein.
+
+> > naja, wenn man laenger darueber nachdenkt, dann fallen einem sicher
+> > noch mehr Sachen ein... :-)
+
+Alles total logisch.
+
+> > Wie erklaert ihr das den Spielern bzw. wie erklaetrt euch der
+> > Spielleiter das? Oder ignoriert ihr diese "Tatsachen" einfach weils ja
+> > Fantasy ist?
+
+Die meisten Sachen sind eigentlich Fehler in der Welterstellung, wenn da
+was rumliegt, dann liegt es da lange oder es liegt nix da. Wenn ein
+Monster stirbt, dann laesst es das fallen, was es hat. Die Auflistung
+klingt nach einem SL, der schlicht keine Lust auf Logik hatte.
+
+> > Wuerd mich doch mal interessieren wie andere das so machen :-)
+
+Ich wuerde Guenther einfuehren und den Rest so lassen.
+
+Gruss Thomas
+
+-----------------------------------------------------------------------------
+
+
+
+Ehrliche Internet-Kaeufer (Ronda, 24. Nov 2006, 00:03:28):
+From: Michael Block <MinkiNE1@web.de>
+Subject: Re: Paypal
+Newsgroups: de.etc.finanz.banken+broker
+Date: Tue, 21 Nov 2006 01:40:03 +0100
+Message-ID: <4sf06vFvg5ptU1@mid.individual.net>
+
+
+>> >> In DE dauert eine online Ueberweisung bis zu 3 Bankarbeitstage 
+ 
+> > Du bist definitiv bei der falschen Bank. Dass die Sparkasse
+> > Hintertupf ... ueber zig Zwischenstationen bucht, glaube ich gern.
+
+Och, da kann es auch andere Gruende geben. Ich hatte vor kurzem einen
+Kaeufer, der direkt nach Auktionsende schon schrieb "habe sofort online
+ueberwiesen. Sie koennen losschicken". Nach ca. 1 Woche kam dann die Mail
+"Sorry, ich hatte sofort ueberwiesen, aber meine TAN war falsch und
+deswegen ist die Ueberweisung zurueckgekommen. Geht gleich wieder
+automatisch raus."
+
+Die boese Bank aber auch... :-)
+
+Achso: Das Ende war dann uebrigens "Sorry, ich noch mal. Jetzt habe ich
+keine TANs mehr. Koennen Sie bitte noch eine Woche warten?"
+
+-----------------------------------------------------------------------------
+
+
+
+Segler. (Ronda, 24. Nov 2006, 00:04:24):
+From:Edgar Warnecke <ewarnecke@gmx.net>
+Subject: Re: Uebersetzungsliste Deutsch - Englisch fuer Segelbegriffe
+Newsgroups: de.rec.sport.segeln
+Date: Wed, 15 Nov 2006 16:51:07 -0400
+Message-ID: <4s19l6Ft742rU10@mid.individual.net>
+
+Am Mon, 13 Nov 2006 10:01:39 +0100 schrieb Wolfgang Broeker:
+
+> > Ignatios Souvatzis schrub[tm]:
+>> >> Hol dicht die Grossschot! Rund achtern! Grossschot fieren!
+> > 
+> > Die Inkonsistenz dieser Kommandos sollte Dir eigentlich schon beim
+> > Schreiben aufgefallen sein: Waehrend die Nutzerschnittstellen bei 
+> > der heutigen Software auf einer durchgehenden Ablaufreihenfolge
+> > Objektauswahl - Aktionsauswahl beruhen[1], ist es in der Seefahrt
+> > bei den Kommandos in der Regel umgekehrt. Es heisst also mitnichten 
+> > "Grossschot fieren!" sondern "Fier auf die Grossschot!".
+
+Entweder ich bin schon total Paraguay versaut oder Ihr sabbelt zuviel.
+
+Eine gute Crew weiss was ansteht, wenn der Skipper "Halse" knurrt.
+
+Eine Bewegung mit der Faust zur Brust: "Hol dicht"
+Kopfnicken: "rund achtern"
+Flache Hand von der Brust weg:" Fier weg".
+
+Ein Manoever, ein Wort. Was'n noch?
+
+  Edg@r
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Ehrliche Internet-Kaeufer (Muadib, 24. Nov 2006, 19:19:26):
+~#! rn=Ronda rt=1164323008 rg=schmarrn.netdigest
+~#! tid=1164323008
+immer diese verunglimpfungen gegenueber kaeffern wie hintertupfingen
+
+-----------------------------------------------------------------------------
+
+
+
+Die Signatur ist auch nicht ganz schlecht. (Ronda, 25. Nov 2006, 00:03:12):
+Gruppen: de.soc.recht.misc
+Datum:Di 23 Dez. 2003 15:22
+
+Hallo!
+
+"Matthias G." schrieb:
+
+> einmal war in einem aachener kaeseblatt eine aktion, bei der man anrufen
+sollte
+> um gratis zirkuskarten abzusahnen. dummerweise hatten die meine durchwahl in
+der
+> fa. angegeben. den ersten 3 anrufern habe ich noch brav erklaert, dass es
+eine
+> falsche nummer ist und die dann erst immer unglaeubig nachgehakt haben
+(unter 5
+> min wurde das nichts). danach habe ich nur noch gefragt, wieviel karten der
+> anrufer haben will und dass diese an der kasse hinterlegt werden.....
+
+Da muss man wohl einfach durch. Mein Vater hatte im Buero frueher mal eine
+sehr aehnliche Telefonnummer wie der Friseur unten im Hause. Irgendwann
+hatte er auch keine Lust mehr auf Erklaerungen und hat fleissig
+Dauerwellentermine angenommen.
+
+Nicht ganz so gut hatte es ein Bekannter getroffen. Seine Telefonnummer
+war identisch mit dem Anfang der Nummer des groessten Taxiunternehmens der
+Nachbarstadt. Leider hat so mancher Besucher unserer Dorfkneipe nach
+diversen Alkoholika die Sache mit der Vorwahl nicht mehr so auf die
+Reihe bekommen und ihn staendig aus dem Bett geklingelt. Da hilft wohl
+nur noch eine neue Nummer.
+
+Gruss
+Bastian
+-- 
+Arbeitnehmer, die vier Stunden nach Beendigung eines Lehrgangstages
+in der Hotelbar vom Hocker fallen, haben keine Ansprueche aus der
+gesetzlichen Unfallversicherung. Es handelt sich nicht um einen
+Arbeitsunfall. - SG Hildesheim - S 11 U 172/96 
+
+-----------------------------------------------------------------------------
+
+
+
+Vermutlich ein Repost auf Bitte eines Blondchens (Ronda, 25. Nov 2006, 01:53:04):
+Subject: Re: Rechtliche Fragen im Mud
+From: Patrick Borer <pa.bo...@bluewin.ch>
+Date: Tue, 25 May 2004 03:10:07 +0200
+Newsgroups: de.alt.mud
+Message-ID: <GED40B28814@510039220786-0001.dialin.t-online.de>
+
+[SN: Manuela fragte in die Runde, wer fuer rechliche Fragen beim Betrieb
+eines MUD verantwortlich sei.]
+
+Manuela Mex <m...@gmx.de> schrieb:
+
+(...)
+
+>- Was darf ein Anbieter absolut NICHT?
+
+Wenn man die Gesetze *aller* Laender beruecksichtigt, sieht das MUD dann
+etwa so aus:
+
+=== LEGALES MUD ===
+
+Herzlich willkommen im Legalen MUD!
+
+Das erste MUD, das gegen kein Gesetz aller 194 Staaten unseres
+schoenen Planeten verstoesst! Ausserdem achten wir sehr darauf,
+niemanden zu veraergern. Viel Spass!
+
+===================
+
+Waehle einen Namen...
+
+>superman
+
+Dieser Name ist ein registriertes Warenzeichen. Bitte waehle einen
+anderen Namen.
+
+>gandalf
+
+Dieser Name ist ein registriertes Warenzeichen. Bitte waehle einen
+anderen Namen.
+
+>claude
+
+Aus Ruecksicht auf die Gefuehle der USA akzeptieren wir keine
+franzoesischen Namen mehr. Bitte waehle einen anderen Namen.
+
+>william
+
+Aus Fairness gegenueber Frankreich akzeptieren wir auch keine
+englischen Namen mehr. Bitte waehle einen anderen Namen.
+
+>max
+
+Kaiser Maximilian I. hat 1499 gegen die Schweizer Krieg gefuehrt. Aus
+Ruecksicht auf Schweizer Mudder akzeptieren wir diesen Namen nicht.
+Bitte waehle einen anderen Namen.
+
+>godzilla
+
+Dieser Name ist ein registriertes Warenzeichen. Bitte waehle einen
+anderen Namen.
+
+>qrvtzjkhkl
+
+Willkommen, Qrvtzjkhkl!
+
+Du stehst in einem Raum. Ausgaenge: Norden und Suedosten.
+
+>betrachte boden
+
+Ein Boden.
+
+>betrachte wand
+
+Es gibt hier eine Wand.
+
+>rufe hallo
+
+Leider gibt es im LEGALEN MUD keine Kommunikationskanaele. Man koennte
+ja etwas Illegales aeussern.
+
+>sage mistmud
+
+Leider gibt es im LEGALEN MUD keine Kommunikationskanaele, dazu
+gehoert auch "sage".
+
+>so
+
+Du stehst in einem Raum. Ausgaenge: Westen und Nordwesten.
+
+>w
+
+Du stehst in einem Raum. Ausgaenge: Sueden und Osten.
+
+>s
+
+Du stehst in einem Raum.
+Hier steht ein Monster.
+Ausgaenge: Westen und Norden.
+
+>betrachte monster
+
+Das ist ein Monster. Es ist geschlechtslos, da ein weibliches Monster
+gegen saudi-arabische Gesetze verstossen koennte, wir aber deswegen
+nicht das maennliche Geschlecht bevorzugen moechten. Egal welches
+Aussehen wir ihm geben wuerden, es koennte irgendwo Anstoss erregen.
+Daher hat es kein Aussehen. Wir bitten um Verstaendnis. Du kannst dem
+Monster zunicken.
+
+>nicke monster
+
+Das Monster reicht dir einen Zettel.
+
+>betrachte Zettel
+
+Du kannst ihn lesen.
+
+>lies zettel
+
+Auf dem Zettel steht:
+Entschuldigung, liebe Spieler - urspruenglich hatten die Raeume des
+LEGALEN MUDS umfangreichere Beschreibungen. Da wir nicht alle Gesetze
+aller 194 Staaten kennen, haben wir sie vorsichtshalber weitgehend
+entfernt. Man weiss ja nie!
+
+>grummel
+
+Du grummelst.
+
+>toete monster
+
+Im LEGALEN MUD kann niemand getoetet werden. Wir wollen ja nicht, dass
+es in Deutschland als gewaltverherrlichend verboten wird.
+
+>ende
+
+Auf Wiedersehen im LEGALEN MUD!
+
+Patrick Borer 
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Vermutlich ein Repost auf Bitte eines Blondchens (Kellybundy, 25. Nov 2006, 11:52:53):
+~#! rn=Ronda rt=1164415984 rg=schmarrn.netdigest
+~#! tid=1164415984
+Jepp das hab ich gesucht, THX, Ronda!
+
+-----------------------------------------------------------------------------
+
+
+
+Nur fuer Emacs-Geeks. (Ronda,  4. Dez 2006, 22:08:08):
+From: David Kastrup <dak@gnu.org>
+Subject: Re: Pretty-Printer fuer LaTeX-CODE
+Newsgroups: de.comp.text.tex
+Message-ID: <85fyc4osms.fsf@lola.goethe.zz>
+Date: Tue, 28 Nov 2006 09:57:47 +0100
+
+Uwe Bieling <a.1.psychi0913@spamgourmet.com> writes:
+
+> > Ralf Angeli schrieb:
+>> >> * Bastian Ebeling (2006-11-27) writes:
+> >
+> > Hi,
+> >
+>>> >>> Ich hatte an ein Kommandozeilen-Tool gedacht, welches (wie z. B.
+>>> >>> HTML-Tidy oder sowas) den Code aufraeumt und gleich wieder speichert.
+>> >> 
+>> >> emacs -batch -Q -eval '(load "auctex.el" nil t t)' datei.tex -eval
+'(progn (LaTeX-fill-buffer nil) (save-buffer))'
+> >
+> > Ich trau mich gar nicht zu fragen, aber gibt es sowas auch fuer VIM?
+
+Klar.
+
+:w
+:!emacs -batch -Q -eval '(load "auctex.el" nil t t)' % -eval '(progn
+(LaTeX-fill-buffer nil) (save-buffer))'
+:r
+
+-----------------------------------------------------------------------------
+
+
+
+Ist das echt Schmarrn? Oder Realitaet? (Ronda,  4. Dez 2006, 22:24:21):
+From: "R. Tschirley" <pooh@cs.tu-berlin.de>
+Subject: Re:
+Newsgroups: de.etc.sprache.deutsch
+Date:Thu, 30 Nov 2006 16:02:03 +0100
+Message-ID: <ekmrpd$ja$1@news.albasani.net>
+
+> > Wir naehern uns der Grunzsprache? Gesprochene SMS...
+
+Am Computer haben wir uns doch schon auf das Niveau eines Saeuglings
+begeben. Wir geben eine hoch spezialisierte Methode, unsere Wuensche zu
+formulieren (Sprache) auf, um wieder mit dem Finger (Mauszeiger) auf das
+zu zeigen, was unsere Aufmerksamkeit gewonnen hat und rufen "Ga!"
+(Doppel-/Klick), um damit zu interagieren.
+
+SCNR,
+Rene
+
+-----------------------------------------------------------------------------
+
+
+
+Grenzdebil und Muenchener Touristen klingt gar nicht so ganz flasch, oder? (Ronda,  4. Dez 2006, 22:25:42):
+Newsgroups: rec.travel.europe
+Subject: Re: Munich apartments?
+From: Jens Arne Maennig <maennig0612@cricetus.com>
+Date: Thu, 30 Nov 2006 17:59:30 +0100
+Message-ID: <5n7iyy0q828p$.dlg@news.cricetus.com>
+
+Martin wrote:
+
+> > Now answer my question.
+
+Please submit your question on form TQ-3419-A-9021 together with your
+CV and criminal record (certified copy) and 16 international reply
+coupons to
+
+Landeshauptstadt Muenchen
+Tourismusamt
+Abteilung fuer grenzdebile Touristenfragen
+Sendlinger Strasse 1
+80331 Muenchen
+GERMANY
+
+Allow 4-6 month for a non-binding answer.
+
+Jens
+
+-----------------------------------------------------------------------------
+
+
+
+Platt aber gut. Man beachte bitte auch das Subject... (Ronda,  4. Dez 2006, 22:38:34):
+... und warum ist dabei kein Bezug auf FRAUEN?
+
+Ronda *gruebelnd*
+
+
+From: Sebastian Gottschalk <seppi@seppig.de>
+Subject: Re: IE 7 sinvoll?
+Newsgroups: de.comp.security.misc
+Date: Mon, 27 Nov 2006 01:19:44 +0100
+Message-Id: <4supakF11fb92U1@mid.dfncis.de>
+
+Bjoern Schliessmann wrote:
+
+> > Rudolf Goebel wrote:
+> >
+>> >> Ich hatte einen Lehrer, der mir die beste Software der Welt naeher
+>> >> gebracht hat: Brain V 1.0
+> >
+> > Der Support ist aber unter aller Sau (ich hab den Hersteller kein
+> > einziges Mal erreichen koennen), und Open Source ist das Ding auch
+> > nicht. Warum ist es trotzdem so beliebt?
+
+Gleiche Antwort wie bei Windows: Weil es standardmaessig mitgeliefert wird.
+,
+
+-----------------------------------------------------------------------------
+
+
+
+Verschwendung! (Ronda,  6. Dez 2006, 01:20:04):
+Spucktueten kann man naemlich super dazu verwenden, Eiswuerfel von ner Bar zu
+ner Party zu bringen. Die sind naemlich prima wasserfest. Und es kommt auch
+keiner auf den Gedanken, einen mit ner vollen Tuete auf dem Gang anzusprechen
+und sich selbst zur Party einzuladen.
+
+Ronda *will wieder da hin, wo man solche Parties feiert!*
+
+From: "Dr. Oliver Brock" <obrock@gmx.net>
+Date: Sun, 03 Dec 2006 08:53:17 +0100
+Message-ID: <4tfe3hF13qu7fU1@mid.uni-berlin.de>
+
+Bjoern Schliessmann schrieb:
+> > Thomas Roessing wrote:
+> >
+>> >> "Ich bitte um Verstaendnis, falls jemand von Ihnen kein Deutsch
+>> >> spricht."
+>> >> [...]
+>> >> Nun macht man ja Durchsagen nicht zum Spass und vielleicht hat die
+>> >> Bitte um Verstaendnis einen besonderen Zweck. Weiss hier zufaellig
+>> >> jemand, was das sein koennte?
+> >
+> > Naja. Das beste wovon ich bisher weiss ist die Ansage bei einer
+> > lokalen Fluggesellschaft in den USA, song heissen die glaub ich,
+> > sinngemaess: "Wenn Sie Beschwerden haben, schreiben Sie sie auf einen
+> > 100 Dollar-Schein und geben Sie ihn unserem Personal".
+
+...oder eben die beruehmten Kotztueten von Hapag, auf denen steht: "Vielen
+Dank fuer Ihren Kommentar"....
+
+Oliver
+
+-----------------------------------------------------------------------------
+
+
+
+Nix fuer Polizisten. (Ronda,  7. Dez 2006, 01:27:10):
+Subject: Re: Stalkingopfer werden besser geschuetzt
+From: Florian Diesch <diesch@spamfence.net>
+Date: Fri, 01 Dec 2006 01:22:59 +0100
+Message-ID: <20061201002259.6089.2.NOFFLE@dieschf.news.arcor.de>
+Newsgroups: arcor.misc
+
+Arcor Newsticker <dpa@arcor-online.net> wrote:
+
+> > 30.11.2006, 16:00 Uhr
+> >
+> >     Berlin (dpa) - Wer anderen Menschen beharrlich nachstellt, sie
+> >   belaestigt und ihr Leben beeintraechtigt, muss kuenftig mit
+> >   schweren Strafen rechnen. 
+
+Das wird der Kripo aber gar nicht gefallen...
+
+
+
+
+   Florian
+
+-----------------------------------------------------------------------------
+
+
+
+Kardinal Meissner und Parallelgesellschaften (Alboin,  7. Dez 2006, 17:29:15):
+Gerade in einem Internetforum gefunden. 
+
+Sehr geehrte Frau Dueker,
+
+voller Freude habe ich gelesen, dass Sie im Zusammenhang mit der Anweisung des
+Koelner Kardinal Joachim Meisner,
+in katholischen Kindergaerten katholische Weihnachtsfeiern durchzufuehren,
+vehement gegen den Aufbau katholischer Parallegesellschaften sind.
+
+Das ist loeblich, denn wie Sie ja wissen, laufen Parallen nebeneinander und
+beruehren sich erst im Unendlichen.
+Nun ist mir schon lange ein Dorn im Auge, dass deutsche Katholiken beginnen,
+unsere Sprache zu verlernen, unsere Gesetze zu missachten,
+sich in Stadtteilen in Ghettos, sogenannten Gemeinden, zusammenschliessen und
+sich in Kirchen versammeln, wo kein Mensch versteht, was da gepredigt wird.
+
+Mir, als Atheist, werden die Katholiken immer unheimlicher. Wollen sie, die
+Katholiken, die Inquisition wieder einfuehren, zu neuen Kreuzzuegen aufrufen,
+alleinstehende alte Damen mit Katze als Hexen verbrennen?
+Wenn wir den Aufbau dieser Parallelgesellschaften noch laenger dulden, wie
+diese sogenannte Weihnachtsfeier, wer weiss, wer das naechste Mal
+Ferienflieger gegen Buerotuerme lenkt?
+Kardinaele, Bischhoefe, verblendete Messdiener?
+
+Frau Dueker, ich stehe in Ihrem Kampf gegen Parallelgesellschaften voellig auf
+Ihrer Seite. Parallelgesellschaften sollten wir hier nicht dulden. Hier gibt
+es nur ein Grundgesetz und eine Landesverfassung, sie zu verteidigen ist Ihre
+und meine Aufgabe. Tun wir es, mit allen Mitteln. Und fangen wir mit den
+bestehenden Parallelgesellschaften an. Sie sind doch dabei, oder?
+
+Hochachtungsvoll
+
+Joshua L. Chamberlaine
+
+-----------------------------------------------------------------------------
+
+
+
+Langsam lesen. Geht um die Bahn. (Ronda,  8. Dez 2006, 21:48:12):
+Newsgroups: de.etc.bahn.stadtverkehr
+Subject: Re: U-Bahnen durch Auslassen von Halten beschleunigen
+From: Matthias Warkus <Warkus@students.uni-marburg.de>
+Date: Mon, 04 Dec 2006 23:07:47 -0500
+Message-ID: <el2rar$5sk$1@news.nnrp.de>
+
+Christoph Schmitz wrote:
+> > Matthias Warkus wrote:
+>> >> Karsten Loeft wrote:
+>> >>
+>>> >>> Da anscheinend bisher noch niemand meinen Vorschlag verstanden hat, 
+>>> >>> versuche
+>>> >>> ich ihn noch einmal anhand eines Beispielfahrplans zu erklaeren:
+>> >>
+>> >> Ich will es mal so sagen: Gesetzt sei, die Leute, die hinter den 
+>> >> Grundsaetzen moderner europaeischer Taktfahrplansysteme stehen und die 
+>> >> Leute, die die konkreten Plankonstruktionen verantworten, seien nicht 
+>> >> alle flaechendeckend bloed. Es wird beobachtet, dass es einen Fahrplan, 
+>> >> wie du ihn vorschlaegst, nirgendwo gibt. Das scheint mir den Schluss 
+>> >> zuzulassen, dass deine Idee schlicht nicht gut ist.
+> > 
+> > Gesetzt sei, dass die Leute, die um siebzehnhundertpief
+> > Verkehrssysteme entwarfen, nicht flaechendeckend bloed
+> > waren. Es wurde damals beobachtet, dass es ein System,
+> > um Personen und Waren mit Dampftraktion ueber Eisen-
+> > schienen zu befoerdern, nirgendwo gab. Das scheint mir
+> > den Schluss zuzulassen, dass so eine Idee schlicht
+> > nicht gut ist.
+
+Ich habe eben mehrere Minuten lang vergeblich versucht, den von dir 
+angestellten Vergleich irgendwie zu qualifizieren, aber ausser 
+"hirnrissig" ist mir nichts eingefallen.
+
+Ein Fahrplan ist ein mathematisches Gebilde von definierter Komplexitaet,
+bestehend aus Linien in dem Gebilde, das durch die Zeitachse und einen 
+Graphen des Streckennetzes aufgespannt wird (wie nennt man sowas?), und 
+wird ausserdem zentral entworfen. Die geschichtliche Realitaet des 
+europaeischen Verkehrssystems ist, nun ja, Teil der bekanntlich 
+hyperkomplexen realen Welt und ausserdem nicht zentral entworfen.
+
+Will sagen, fuer einfachere Gemueter:
+Ein Fahrplan besteht immer aus einer Menge von Anfahrts- und 
+Abfahrtszeitpunkten bestimmter Zuege an bestimmten Stellen eines 
+bestimmten Streckennetzes. Es kann nicht ploetzlich zwischen all den 
+Zahlen ein kleiner gruener Zwerg auftauchen, der kleine bunte 
+Tintenfische aussetzt, die die Zahlen auffressen, so dass ein Zug auf 
+einmal irgendwo viel schneller ankommen kann, und das alles auch noch, 
+ohne dass es die zustaendige Abteilung von DB Netz merkt.
+In der hyperkomplexen geschichtlichen Realitaet des europaeischen 
+Verkehrssystems ist es allerdings durchaus moeglich, dass ohne zentrale 
+Einwirkung irgendwo jemand die Eisenbahn erfindet und dadurch binnen 
+weniger Jahre manche Entfernungen doppelt so schnell zurueckzulegen sind.
+
+mawa
+
+-----------------------------------------------------------------------------
+
+
+
+Meine neue Kamera ist da... (Ronda, 12. Dez 2006, 22:18:27):
+... da passt das grad so schoen.
+
+From: "Thomas Poeschmann" <der_thomas3@freenet.de>
+Newsgroups: de.rec.fotografie
+Subject: Re: Erinnerung II
+Date: 10 Dec 2006 06:21:03 -0800
+Message-ID: <1165760463.598314.321280@16g2000cwy.googlegroups.com>
+
+Hendrik Brixius schrieb:
+
+> > Eine Freundin, die bis zu 1 Stunde 59 Minuten Bock auf "Schirm
+> > halten" hat, um mir beim Fotografieren im Regen zu helfen, haette
+> > ich auch gerne. Kannst Du mir vielleicht einen Tipp geben, wie
+> > man so jemanden finden kann? ;-)
+
+Statt nach einer neuen Freundin auszuschauen empfehle ich dringend
+ein wenig mehr Feingefuehl!
+
+1) Es wird nicht fotografieren gegangen sondern spazieren. Nachts
+um zehn ist die Luft ja auch besonders klar, und Regen ist gut fuer
+die Haut.
+
+2) Der Fotorucksack und das Stativ muessen schon bereit stehen. Du
+kannst dann wie zufaellig danach greifen und sagen "vielleicht
+ergibt sich ja was!".
+
+3) Wenn Du meinst irgendwann fotografieren zu muessen ist es an Dir
+moeglichst glaubhaft zu versichern das es sich hier um ein einmaliges
+Licht und eine unwiederbringliche Gelegenheit handelt. Deine Freundin
+ist dann sicher vestaendnisvoll und wird geduldig auf Dich Warten.
+
+4) Lege Dir eine Strategie bereit damit Deine Freundin von selber
+erkennt das es einen Schirmhalter braucht. Du solltest deutlich
+kenntlich machen das die Ausruestung nicht sinnvoll mit nur einer
+Hand benutzt werden kann.
+
+5) Wenn die ersten 10 Minuten "Schirmhalten" ueberstanden sind ist
+das Eis gebrochen. Sollte sich dennoch beim Halter ein gewisser
+Frustfaktor einstellen ist es an Dir zu jammern. Schimpfe auf das
+Objektiv, den viel zu kleinen Sucher, das es so nass ist und Du
+ne Erkaeltung bekommst, das Du eigentlich gar keine Lust hast aber
+die Menschheit es Dir dankt diesen unwiederbringlichen Augenblick
+in dem einmaligen Licht festzuhalten.
+
+Du solltest solche Aktionen nicht allzuoft wiederholen - es wird
+sich ein gewisser Abnutzungsfaktor einstellen der zusammen mit
+einem Lerneffekt eine Unlust erzeugt.
+
+Viel Glueck!
+
+Thomas
+
+-----------------------------------------------------------------------------
+
+
+
+BSD (Amaryllis, 13. Dez 2006, 19:46:56):
+From: naddy@mips.inka.de (Christian Weisgerber)
+Subject: Re: Kann FreeBSD heute (2006) automatisch CDs mounten?
+Newsgroups: de.comp.os.unix.bsd
+Date:Fri, 8 Dec 2006 17:39:03 +0000 (UTC)
+Message-ID: <elc7vn$19e2$2@kemoauc.mips.inka.de>
+
+Thomas Schneider <ts687@photo.net> wrote:
+
+> Ist da was an den Geruechten dran, dass eine Menge BSD-Entwickler zum
+> BSD-basierten und sehr erfolgreichen Apple gegangen sind und das
+> negative Auswirkungen auf die freie BSD-Entwicklung hat?
+
+Seit Erfindung des grafischen Webbrowsers sind die BSD-Entwickler
+nur noch mit dem Genuss von Pornografie beschaeftigt, so dass die
+Entwicklung mit 4.4BSD 1993 zum Stilstand kam.
+
+
+-----------------------------------------------------------------------------
+
+
+
+Informatiker... (Amaryllis, 13. Dez 2006, 19:47:40):
+Ok, bin ja selbst einer, aber mit Humor ;)
+
+From: Christian Piehl <piehli@web.de>
+Subject: Re: Router gesucht
+Newsgroups: ger.ct
+Date:Sun, 10 Dec 2006 12:03:00 +0100
+Message-ID: <s1qnn2l9u9c1sa9cuu1dvmskf3bllceqpe@4ax.com>
+
+Moin,
+
+Carsten Krueger <use.net.cakruege@neverbox.com> wrote:
+>Ich hab ueberhaupt kein waf-Problem, meine Freundin ist Informatikerin. :-)
+
+doch hast du, aber anders herum. Wenn etwas zu technisch aussieht
+kommen bei ihr so Fragen auf wie: "Was ist das denn?" "Was kann man
+denn da noch alles anschliessen?" "Wie mag es sich wohl verhalten,
+wenn ich das damit mache?" Oder ganz uebel: "Kann man da nicht auch
+Linux drauf installieren?" Informatiker haben immer den Hang dazu die
+Luecke in einem System zu suchen. Wenn du aber einfach nur ein
+funktionierendes Gerat haben willst, dann such dir was, was sie nicht
+magisch anzieht, wie das Licht die Motte.
+
+;-)
+Christian
+
+-----------------------------------------------------------------------------
+
+
+
+Microsoft und die Musik (Ronda, 15. Dez 2006, 21:20:34):
+From: Lothar Frings <da_lodda@gmx.de>
+Subject: Re: Wer kennt dieses Lied?
+Newsgroups: de.rec.musik.recherche
+
+Keeper tat kund:
+
+> > Hallo,
+> > kennt hier vielleicht jemand den Titel und den Interpreten dieses
+> > Titels?
+> >
+> > http://freenet-homepage.de/keepsch/Track01.zip
+
+Das ist "Die Seite kann nicht angezeigt werden"
+von Billy G. & The Explorers.
+
+-----------------------------------------------------------------------------
+
+
+
+Oh ja... (Ronda, 15. Dez 2006, 21:22:52):
+... den Vorschlag koennte man echt verstehen... besonders wenn grade mal
+wieder aus unerfindlichen Gruenden die Word-Formatvorlage beschlossen hat, bei
+allen Kapiteln im Angebot die Nummerierung durcheinander zu bringen...
+
+Ronda *DARF Angebote leider nicht mit LaTex machen :-( *
+
+From: Dr Engelbert Buxbaum <engelbert_buxbaum@hotmail.com>
+Newsgroups: de.comp.lang.pascal
+Subject: Re: Programmierumgebung: WDSibyl
+Date: Wed, 13 Dec 2006 16:11:11 +0100
+Message-ID: <elp56m$bdc$03$1@news.t-online.com>
+
+Sieghard Schicktanz wrote:
+
+> > Schliesslich hat die Bundesregierung (oder irgendeine Bundesbehoerde)
+> > vor kurzem doch auch wieder eigene Vorschriften fuer die Erstellung von
+> > Software erlassen. (Ich muesste aber erst suchen, welche das war(en).)
+
+Da gibt es eine DIN-Norm ueber die Benutzbarkeit von Software. Die ist
+aber schon einige Jahre alt. Sie besagt zum Beispiel dass im Fehlerfall
+eine Meldung produziert werden muss, die es auch einem durchschnittlichen
+Anwender erlaubt den Fehler zu finden und zu beheben.
+
+Demnach waere M$-Windozze/Office nicht den Regeln von Wissenschaft und
+Technik gemaess und jeder Arbeitgeber riskiert einen Schadenersatz-Prozess
+wenn seine Angestellten auf Grund dieser Software einen Schaden
+(Nervenzusammenbruch, Stress-bedingter Burn-out) erleiden. Eigentlich
+muessten also die Typen von der Berufsgenossenschaft bei Begehungen die
+Verwendung von M$-Produkten monieren...
+
+
+-----------------------------------------------------------------------------
+
+
+
+de.alt.netdigest sucht neuen Moderator (Ronda, 19. Dez 2006, 00:11:20):
+Wie waere es, wenn wir Grimmborn vorschlagen? Grimmborn, was haeltst Du davon?
+
+Ronda
+
+Hallo,
+
+nach doch inzwischen etwas ueber acht Jahren Moderationstaetigkeit dieser
+Newsgruppe
+(Beginn am 27. September 1998) moechte ich mich auch anderen Sachen widmen und
+suche
+daher nach einem Nachfolger.
+
+Potentielle Kandidaten moegen sich bitte einfach bei mir per Mail melden.
+
+Vielen Dank,
+
+Hanno
+
+-----------------------------------------------------------------------------
+
+
+
+Re: de.alt.netdigest sucht neuen Moderator (Jimdigriz, 19. Dez 2006, 09:17:00):
+~#! rn=Ronda rt=1166483480 rg=schmarrn.netdigest
+~#! tid=1166483480
+Oh Rince hoert auf, gleich mal nachfragen....
+JdG
+
+-----------------------------------------------------------------------------
+
+
+
+Laengliches aus dem Rettungsdienst (Ronda, 21. Dez 2006, 00:48:49):
+From: Bernhard Nowotny <bnow@gmx.de>
+Newsgroups: de.etc.notfallrettung
+Subject: Re: Bundespolizei bringt Patienten in die Klinik zurueck -
+Rechtslage?
+Date: Sat, 16 Dec 2006 11:34:46 +0100
+
+Frank Adam wrote:
+> > "FRANKFURT: Einen 53 Jahre alten Krankenhauspatienten hat die
+Bundespolizei 
+> > am Hauptbahnhof aufgegriffen und in die Klinik zurueckgebracht. Der Mann,
+der 
+> > sich eigenmaechtig aus dem Krankenhaus
+> > entfernt hatte, war Sicherheitskraeften aufgefallen, weil er noch
+> > einen Katheter im Arm stecken hatte."
+> > Diese Nachricht hat mich jetzt doch ein wenig erschreckt. Polizei bringt 
+> > Patienten in die Klinik zurueck?
+
+Normal werden die aber auch den RD dazu bemuehen. Ob das nun nur nicht
+aus dem Bericht hervorgeht oder der Patient tatsaechlich im Streifenwagen
+transportiert wurde, ist aber letztendlich auch egal. Die Polizei laesst
+sich m.E. nur nicht gerne ihre Sitzpolster vollbluten, deshalb wuerde
+mich der direkte Transport durch die Polizei wundern. Aber vielleicht
+waren das auch nur engagierte junge Polizisten - und das naechstemal
+holen die auch den RD.   :)
+
+> > Moment mal, kann denn nicht jeder Mensch 
+> > selbst entscheiden, ob und wann er eine Klinik betritt oder verlaesst?
+
+Im Prinzip ja. Der Rest siehe unten.
+
+> > Zugegeben, die Nachricht gibt keine Einzelheiten her. War es vielleicht
+ein 
+> > psychiatrischer Patient mit Einweisung nach PsychG? Oder hat der Mann sich
+> > ueberzeugen und freiwillig in die Klinik zurueckbringen lassen? Man weiss
+es 
+> > nicht.
+
+Meistens sind es verwirrte aeltere Leute, die sich mit ein bisschen
+Zureden gerne wieder "heimfuehren" lassen ("Sie sind aber so ein netter
+junger Herr, da gehe ich doch gerne mit Ihnen mit!" :).
+
+> > Meine Frage hierzu: unter welchen Bedingungen haben Polizeibehoerden das 
+> > Recht, einen abgaengigen Patienten gegen seinen Willen in eine Klinik 
+> > zurueckzubringen? Und unter welchen Voraussetzungen kann ueberhaupt ein 
+> > muendiger Buerger dazu gezwungen werden, sich in eine Klinik zu begeben
+oder 
+> > sich einer aerztlichen Behandlung zu unterziehen?
+
+Bei Fremd- oder Selbstgefaehrdung bzw. offensichtlicher bzw. bereits
+aerztlich festgestellter und richterlich verfuegter Betreuung (und
+natuerlich der Notwendigkeit zur aerztlichen Behandlung) oder aber
+im Rahmen von Blutproben/Drogenuntersuchungen bei entsprechendem
+Verdacht. Ist aber immer eine Einzelfallentscheidung - und die
+Polizisten und Richter, die ich da kenne, machen sich das nicht
+einfach.
+
+<story>
+KTW-Einsatz, Auftrag: "Z.n. Suizidversuch, Patient vom RTW versorgt
+und in Klinik gebracht, dort nach Erstversorgung der Schnittwunden
+nun Einweisung in Psychiatrie".
+
+Wir kommen in die Ambulanz, dort ueberzeugt ein Arzt den etwas
+renitenten Patienten (der jetzt angibt, sich die Schnittwunden
+an beiden Handgelenk-Innenseiten beim Geschirrspuelen zugezogen
+zu haben) gerade nochmal, dass er nun mitfahren soll, oder die
+Polizei wuerde das mit Zwang uebernehmen.
+
+Wir hatten die Trage dabei, der Patient will aber zu Fuss gehen.
+Mein Kollege (erfahrener Hauptamtlicher) begleitet ihn zum KTW
+waehrend ich die Papiere klar mache und nach ein paar Minuten
+auch rausgehe.
+
+Beim KTW ist aber niemand. Naja, nochmal aufs Klo gegangen? Ich
+und nach verwunderten Blicken auch Arzt und Schwester suchen den
+Ambulanzbereich nach Patient und Kollege ab (nein, Handys gabs
+damals noch nicht).
+
+Schliesslich schaue ich auf der Strasse vor dem Krankenhaus nach
+und entdecke ein Knaeuel: der baerenstarke Patient liegt am Boden,
+obenauf der zum Glueck ebenfalls recht kraeftige Kollege. Auf dem
+Gehweg liegt die zerbrochene Brille des Kollegen...
+
+Der Patient ging am KTW vorbei, der Kollege ging ihm nach und
+redete ueberzeugend auf ihn ein. Da drehte sich der Patient um,
+sprang auf den Kollegen zu und wollte ihm einen Faustschlag
+versetzen. Dem konnte der Kollege zwar ausweichen, die Armschiene
+(genaehte Handgelenkswunde) hat ihm aber gerade noch die Brille
+von der Nase gefegt. Der Patient stuerzte sich dann auf den Kollegen,
+der aber gerade noch geschickt genug war, den Patienten am Boden
+fixieren zu koennen - mit zunehmender Muehe.
+
+Ab zum KTW, ueber Funk die Polizei nachgefordert und sofort dem
+Kollegen zu Hilfe geeilt. Da lagen wir dann zu zweit auf dem
+Patienten, der gegen uns wueste Morddrohungen ausstoesst und versucht,
+uns zu schlagen - was wir mit Muehe und Not verhindern koennen.
+
+Das ganze zur besten Besuchszeit und direkt vor dem Haupteingang
+des Krankenhauses: zwei Sanitaeter knien/liegen auf einem Patienten,
+dessen Armverbaende langsam wieder durchzubluten beginnen...
+
+Eine Schar aelterer Damen (Krankenhausbesucher) sammelt sich um uns
+und sieht zu. Der Patient bemerkt das und ruft laut um Hilfe, man
+wolle ihn umbringen. Gleichzeitig nimmt er jede Gelegenheit wahr,
+uns Handgelenke umdrehen zu wollen oder die Armschienen ins Gesicht
+stossen zu wollen, begleitet von gezischten Morddrohungen.
+
+Die "Meute" wird zudringlicher und droht uns mit Spazierstoecken:
+"Lassts den armen Mann los! Der blutet ja!".
+
+Nach gefuehlten 5 Stunden (es waren ca. 15 Minuten, immerhin, wenn
+man bedenkt, dass die Polizeiinspektion nur ca. 5 Gehminuten vom
+Krankenhaus entfernt ist) kommt endlich ein Streifenwagen, die
+herausspringenden 4 (!) Polizisten machen die Sache klar, indem
+Sie den Patient mit Handschellen verpacken und nicht uns.  :)
+
+Wir konnten den Transport dann nicht durchfuehren, weil der
+Kollege bei starker Kurzsichtigkeit ja keine Brille mehr hatte
+und durften den verpackten Patient an die Kollegen vom RTW
+abgeben, die dann den Transport mit Polizeibegleitung durchfuehrten.
+</story>
+
+Und das naechstemal erzaehle ich von dem Typ, der beim Begehen einer
+strafbaren Handlung rueckwaerts in den Misthaufen fiel (aber das war hier
+schon mal, glaube ich). Oder von dem Senior, der bei der richterlichen
+Begutachtung so zuckersuess war, dass der die Betreuung beantragende Arzt
+einen sehr schiefen Blick kassierte bis der Richter unverrichteter
+(sic!) Dinge gehen wollte, vom "lieben" Patienten - unter
+unschuldigem Blick des Arztes - mit der Kruecke hinterruecks eins
+uebergebraten bekam und die Sache abschliessend doch klar machte.  :)
+
+:)
+
+Servus,
+
+
+Bernhard
+
+-----------------------------------------------------------------------------
+
+
+
+Fuer Kafka-Liebende Kradisten (Ronda,  5. Jan 2007, 00:19:18):
+Newsgroups: de.rec.motorrad
+Subject: Re: Ratlosigkeit und Regen...
+From: Werner Schmidt <werner1@foni.net>
+Date: Sat, 30 Dec 2006 23:06:25 +0100
+Message-ID: <en6nss$2o5$00$1@news.t-online.com>
+
+Hi Tobias,
+
+> > Und das ist ja nun wirklich Kradistesk. Kradleresk? Kradesk?
+
+Kafkradesk.
+
+Gruss
+
+Werner
+
+-----------------------------------------------------------------------------
+
+
+
+Backups. Nice-to-have-had triffts. (Ronda,  5. Jan 2007, 00:23:35):
+From: Sebastian 'lunar' Wiesner <basti.wiesner@gmx.net>
+Newsgroups: de.comp.os.unix.linux.misc
+Subject: Re: Kann Linux ntfs?
+Date: Fri, 29 Dec 2006 15:36:08 +0100
+Message-ID: <en394o$bub$03$3@news.t-online.com>
+
+Manfred Ginger <mango@sofortsurf.de> typed
+
+> > Juergen Ilse wrote:
+> > 
+>> >> Von wichtigen Daten sollte man ohnehin ein Backup haben. Wenn man
+>> >> keins hat, sind die Daten entweder nicht wichtig oder der Eigentuemer
+>> >> agiert furchtbar leichtisinnig ...
+> > 
+> > Ich habe die Daten neu bewertet, als nice-to-have-had.
+
+Eine kreative Art, Probleme mit Backups zu vermeiden...
+
+-----------------------------------------------------------------------------
+
+
+
+Sorry. (Ronda,  5. Jan 2007, 00:26:11):
+An alle Leidtragenden. Von den Buzzwords im Artikel. Und allen, die ich grad
+mit meiner de.alt.netdigest-Nacharbeit Scroll verursache.
+
+Ronda *drei Tage Urlaub sind nicht genug!*
+
+Newsgroups: de.etc.bahn.tarif+service
+Subject: Re: Prozentrechnung a la DB
+From: Marc Haber <mh+usenetspam0339@zugschl.us>
+Date: Sat, 30 Dec 2006 17:39:30 +0100
+Message-ID: <en64o2$kbv$1@news1.tnib.de>
+
+Andr Joost <Andre+Joost@nurfuerspam.de> wrote:
+> >Marc Haber schrieb:
+>> >> Kai- Uwe Thiessenhusen <kuth+delete+spam@vollbio.de> wrote:
+>>> >>>Marc Haber schrieb:
+>>>> >>>> Jein. Wenn die outgesourcte Aufgabe hohes Fachknowhow erfordert, 
+>>> >>>
+>>>> >>>> Bei Grunt Work wie Support und Customer Care rechnet sich das eher
+>>>> >>>> nicht, wenn man einen vertretbaren Service Level einhalten will. 
+>>> >>>
+>>> >>>Du weisst, dass wir hier in de.* sind?
+>> >> 
+>> >> Aehm, doch, wieso?
+>> >> 
+> >
+> >Kai bemaengelte den Ueberhang englischer Fachworte, die nicht jedem hier
+> >mitlesenden Bahninteressierten gelaeufig sein duerften.
+
+Hm. Ich hab wohl zu lange Powerpointkaraoke gespielt.
+
+> >Mir uebrigens auch nicht.
+
+Grunt Work = Grunzarbeit = langweiliges Standardzeug
+Support = Hotline = "Es druckt net!!!"
+Customer Care = dem Kunden ein warmes Gefuehl im Magen verschaffen, ihm
+aber keinesfalls in irgend einer Form weiterhelfen.
+
+Gruesse
+Marc
+
+-----------------------------------------------------------------------------
+
+
+
+Tempel=Aldi-Filiale. (Ronda,  5. Jan 2007, 00:59:04):
+Und dazu noch drei leckere Weizenbiere. Und man versteht diesen Artikel in
+seiner ganzen Schoenheit.
+
+Ronda *hicks*
+
+From: Sebastian Holzmann <SHolzmann@gmx.de>
+Newsgroups: de.alt.fan.aldi
+Subject: Re: Aldi Sued,Nord - Steuer2007
+Date: Sun, 24 Dec 2006 22:25:18 +0000 (UTC)
+Message-ID: <emmuoe$24p$1@news.BelWue.DE>
+
+
+Alexandra Baur <mail8857@nospam.arcornews.de> wrote:
+> > warum ist es Norden 20 Ct billiger?
+
+Die Bundesautobahn 46, die im mittleren Nordrhein-Westfalen die
+Bundeslaender Aldi Nord (Wuppertal) und Aldi Sued (Duesseldorf) verbindet,
+ist im Berufsverkehr chronisch ueberlastet. Dabei laeuft der
+Hauptverkehrsstrom morgens Richtung Duesseldorf. Durch das leichte
+Preisgefaelle in umgekehrter Richtung wird nun versucht, kurz vor Oeffnung
+der Tempel eine gegenlaeufige Stroemung zu erzeugen und die Autobahn auf
+diese Weise gleichmaessiger auszulasten.
+
+SCNR
+Sebastian
+,
+
+-----------------------------------------------------------------------------
+
+
+
+Fuer die Juristen (Ronda,  5. Jan 2007, 01:08:18):
+From: Matthias Kryn <usenet.kryn@planet-interkom.de>
+Newsgroups: de.soc.recht.misc
+Subject: Re: Frohe Weihnacht ueberall!
+Date: Fri, 22 Dec 2006 20:36:37 +0100
+Message-ID: <458c3375$0$5727$9b4e6d93@newsspool3.arcor-online.net>
+
+
+Holger Pollmann schrieb:
+
+> > Lasst mir den Traffic nicht zu sehr einbrechen ;-)
+
+Ich kuendige dann schonmal die drei nachweihnachtlichen Threads
+mit dem meisten Traffic an:
+
+a) An Silvester Kuendigung abgeschossen
+
+An Silvester habe ich die Kuendigung mit einer Rakete meinem
+Vermieter ins Wohnzimmer geschossen. Ich gehe davon aus, dass
+sie rechtzeitig zugegangen ist. Eine Meinung bitte. Dass die
+Scheibe geborsten ist, tut nichts zur Sache. Danke.
+
+mit xp de.sci.chemie, de.rec.tiere.katzen, de.org.mensa und
+de.alt.test.
+
+
+b) Weihnchtsbuam abgebrant - wer ttaegt den SCchadn?
+
+Am sweiten feieirtag bin ich foellihg besoffen um den
+Wiehnhactbaum umgekippt. MEin ganze OWhnung ist ausvrgbrannt,
+muss mir mein Vermieter neue Moeble jaufen?
+
+mit xp dsr.wohnen, spaeter auch de.alt.rec.getraenke und
+de.talk.jokes.
+
+
+c) Will Socken zurueckgeben, weil sie stinken!!!
+
+Meine Eltern haben mir Socken geschenkt, die nach einmal Tragen
+schon stinken!! Kann ich meine Eltern zurueckgeben, und brauche
+ich fuer die Socken einen Waffenschein???
+
+mit xp de.etc.handel.versandhaeuser, recht zuegig
+de.soc.familie.misc und spaeter de.rec.heimwerken. Ganz spaet
+folgt ein xp nach dsr.familie+erben.
+
+
+> > Ich wuensche allen frohe, besinnliche Feiertage und einen
+> > guten Rutsch ins neue Jahr!
+
+Hah, besinnlich! ... ...
+
+Aber ja, herzlichen Dank, und ebenso.
+
+Gruesse
+Matthias
+
+-----------------------------------------------------------------------------
+
+
+
+Vermutlich alt. Und wahr? (Ronda,  8. Jan 2007, 19:43:42):
+From: Dietmar Langenohl <dietmar.langenohl@nurfuerspam.de >
+Newsgroups: de.rec.fotografie
+Subject: Re: Kaufberatung
+Date: Fri, 05 Jan 2007 21:23:03 +0100
+Message-ID: <8kctp29onnnvt3tdash1ho1sb56nr3jmg9@4ax.com>
+
+Maria Win ter <Maria.Winter.Usenet@gmx.net> schrieb:
+
+
+> >Wenn Frauen immer viel Wert auf Aeusserlichkeiten legten, dann faenden
+> >die meisten Maenner nie eine Abnehmerin. 
+
+Ok, ist ja jetzt ohnehin OT:
+
+In Wiesbaden, Mainz und Limburg haben kuerzlich Fachgeschaefte fuer
+Ehemaenner eroeffnet, in denen sich Frauen neue Ehemaenner aussuchen
+koennen.
+Am Eingang haengt eine Anleitung, welche die Regeln erklaert, nach denen
+man hier einkaufen kann:
+"Das Geschaeft darf nur einmal aufgesucht werden. Es gibt 6 Stockwerke
+mit Maennern, deren Eigenschaften von Stock zu Stock besser werden. 
+Sie koennen sich entweder einen Mann aus dem Stockwerk aussuchen, auf
+dem Sie sich befinden, oder sie koennen ein Stockwerk weiter hoch
+gehen, und sich dort umsehen. 
+Sie koennen aber nicht zurueck auf ein niedrigeres Stockwerk gehen,
+welches Sie bereits verlassen haben. "
+
+Eine Frau geht in ein Geschaeft, um sich einen Mann zu suchen. 
+
+Im 1. Stock haengt ein Schild: Diese Maenner haben Arbeit.
+Im 2. Stock haengt ein Schild: Diese Maenner haben Arbeit und moegen
+Kinder.
+Im 3. Stock steht auf dem Schild: Diese Maenner haben Arbeit, moegen
+Kinder und sehen gut aus.
+Wow, denkt die Frau, fuehlt sich aber gezwungen, weiterzugehen. Sie
+geht in den 4.Stock und liest:
+Diese Maenner haben Arbeit, moegen Kinder, sehen verdammt gut aus und
+helfen im Haushalt.
+"Oh Gott, ich kann kaum widerstehen," denkt sie sich , geht aber
+dennoch weiter. 
+Im 5.Stock ist zu lesen: Diese Maenner haben Arbeit, moegen Kinder,
+sehen verdammt gut aus, helfen im Haushalt und haben eine romantische
+Ader.
+Sie ist nahe dran, stehen zu bleiben, geht aber dennoch zum 6. Stock
+weiter. Auf dem Schild steht: Sie sind Besucherin Nummer 31.456.012.
+Hier gibt es keine Maenner.
+Dieses Stockwerk existiert nur, um zu zeigen, dass es unmoeglich ist,
+Frauen zufrieden zu stellen.
+Vielen Dank fuer ihren Einkauf im Fachgeschaeft fuer Ehemaenner.
+Auf Wiedersehen.
+
+
+Gegenueber hat ein Fachgeschaeft fuer Ehefrauen eroeffnet. Es hat
+ebenfalls 6 Stockwerke. 
+Im ersten gibt es Frauen, die Sex lieben. 
+Im 2. Stock gibt es Frauen, die Sex lieben und gut aussehen.
+Stockwerke 3 bis 6 wurden noch nie von einem Mann besucht.
+
+Dietmar
+
+-----------------------------------------------------------------------------
+
+
+
+Flach. Oder haarig. Hm. (Ronda,  8. Jan 2007, 19:44:34):
+Message-ID: <1166706084.896379.34330@73g2000cwn.googlegroups.com>
+Betreff: Re: Preisentwicklung von Rasiergel
+Datum: 21 Dec 2006 05:01:24 -0800
+Von: Lothar Frings <da_lodda@gmx.de>
+Newsgruppen: de.alt.etc.koerperpflege,de.alt.fan.konsumterror
+
+Nikolaus Bernhardt tat kund:
+
+> > Hallo liebe Koerpergepflegte und Konsumterrorisierte,
+> >
+> > (Marken-)Rasiergel wird immer teurer und erreicht so langsam die
+> > Grenze von 5 Euro.
+> >
+> > Was macht ihr dagegen?
+
+Mit deinem Namen kann man eigentlich
+nicht baertig genug sein.
+
+-----------------------------------------------------------------------------
+
+
+
+Nicht flach. (Ronda,  8. Jan 2007, 19:48:17):
+From: Stefan Werner <009wcqf02@sneakemail.com>
+Subject: Re: Passwort encrypted speichern
+Newsgroups: de.comp.lang.java
+Date: Fri, 22 Dec 2006 18:30:55 +0100
+Message-ID: <4v2j2fF18ehp0U2@mid.individual.net>
+
+Alexander Reifinger schrieb  am 22.12.2006 17:28:
+> > Marian Aldenhoevel schrieb:
+> >
+>> >> Ich biete den Service an, beliebige Geheimnisse zu verschluesseln:
+>> >>
+>> >> Man schicke mir eine EMail mit dem gewuenschten Algorithmus und
+>> >> Schluessel im
+>> >> Betreff und dem Klartext im Body. Ich antworte mit dem Ciphertext.
+> >
+> > Wenn Du eine Emailadresse einrichtest und die hier postest, dann werden
+> > sicher bald die ersten Mails eintreffen. Die Verschluesselungsmethode
+> > wird dann aber oft Viagra oder Cialis sein...
+> >
+
+Und damit verschluesselt steht die Mail wie eine Eins!
+
+-stef, sich kruemmend
+
+-----------------------------------------------------------------------------
+
+
+
+Ich mag die GEZ. UND WIE. (Ronda, 10. Jan 2007, 20:17:28):
+From: Michael Holzt <spam@fqdn.org>
+Date: Thu, 4 Jan 2007 20:59:43 +0000 (UTC)
+Message-ID: <slrnepqqlv.9kn.spam@stfu.fqdn.org>
+
+Lutz Schulze wrote:
+> > Am Thu, 4 Jan 2007 02:59:07 +0100 schrieb Konni Scheller:
+>> >> Das ist leicht. Ich habe ja ein Gasthaus.
+>> >>
+>> >> Wenn also einer der GEZ-Fuzzies bei mir auftaucht, frage ich ihn
+>> >> freundlich, ob er einen Kaffee moechte. Die Fragen beantworte ich nicht,
+>> >> und dann berechne ich 3,-- Euro fuer den Kaffee.
+> >
+> > Er muss ihn auch nicht trinken. Allein dass er die Moeglichkeit haette
+muesste
+> > ihm eigentlich reichen.
+
+Ne, beides verkehrt. Konni stellt ihm eine leere Tasse hin. Wenn er
+nichts weiter sagt und nichts trinkt, berechnet er ihm dennoch 3 EUR
+fuer den Kaffee. Grund: Er hatte ein empfangsbereites Getraenkegeraet
+und haette daher jederzeit Kaffee oder Tee empfangen koennen, wenn er
+das gewollt haette. Am besten auch den PKW der Person pruefen, nicht
+dass dort auch noch ein Kaffeebecher vorhanden ist. Dieser waere zwar
+eigentlich ein kostenfreies Zweitgetraenkegeraet, da der PKW aber ja
+offensichtlich nicht ausschliesslich privat sondern auch gewerblich
+(im Auftrag der GEZ) genutzt wird, ist der dortige Kaffeebecher
+selbst anmelde- und gebuehrenpflichtig.
+
+Oder noch besser: Konni schenkt ihm den Kaffeebecher und berechnet
+fortan jeden Tag einen Kaffee, selbst wenn der GEZ-Vertreter gar
+nicht bei ihm ist. Grund: Wie bereits der BGH entschieden hat,
+entbindet eine tatsaechliche Nichtempfangsmoeglichkeit ja nicht von
+der Gebuehrenpflicht. Es waere also das Problem des GEZ-Vertreters,
+wenn dieser ein Empfangsgeraet fuer Konnis Kaffeesender mit sich
+fuehrt und gar keinen Kaffee bekommen kann.
+
+-----------------------------------------------------------------------------
+
+
+
+Flach. Und kalt. (Ronda, 14. Jan 2007, 22:13:39):
+[Anmerkung der Einreicherin: 
+Man diskutiert die Frage, ob man richtig "frischgebruehter Kaffee" oder
+"frisch gebruehter Kaffee schreibt. Aus Verstaendnisgruenden habe ich die
+Frage des Vorposters noch hineinkopiert.]
+
+From: Andreas Kabel <andreas.kabel@gmail.com>
+Subject: Re: Zusammen oder getrennt?
+Newsgroups: de.etc.sprache.deutsch
+Message-ID: <eo41rk$qvp$1@news.Stanford.EDU> 
+Date: Wed, 10 Jan 2007 16:54:12 -0800
+ 
+Stefan Ram wrote:
+
+>> > >Es gibt nach Deiner Ansicht also frischgebruehten Kaffee, der
+>> > >nicht gerade frisch gebrueht worden ist?
+
+> >   Man koennte auch Kaffee um 1800 frisch gebrueht haben und dann
+> >   mit Fast-Lichtgeschwindigkeit in das Jahr 2007 schicken.  
+> >   Fuer den Kaffee waeren dann erst wenige Sekunden vergangen, so
+> >   dass er seit dem Bruehen kaum gealtert ist
+
+Ja, aber der Fahrwind kuehlt wie bloed.
+
+-----------------------------------------------------------------------------
+
+
+
+Um die Ecke gedacht. (Ronda, 14. Jan 2007, 22:14:57):
+From:Matthias Dingeldein <matthias.dingeldein@eckert.rwth-aachen.de>
+Subject: Re: Seltsame Zeichen auf dem Zugzielanzeiger
+Newsgroups: de.etc.bahn.eisenbahntechnik
+Date: Wed, 10 Jan 2007 12:06:52 +0100
+Message-ID: <50jvmcF1g4lm2U1@mid.dfncis.de>
+
+Christoph Schmitz schrieb:
+
+> > Olaf Kuba wrote:
+
+>> >> seit kurzem ist auf den LCD-Zielanzeigern am Bahnsteig in Erlangen und 
+>> >> Fuerth (woanders vielleicht auch) zusaetzlich zu den gewohnten 
+>> >> Informationen noch einen Linie mit zwei Hoeckern (aehnlich
+Verkehrszeichen 
+>> >> 112 Bodenwelle) zu sehen. Was will uns dieses Zeichen sagen?
+
+> > Wo befindet sich das Zeichen denn? Im Zuglauf
+> > koennte es analog wie das kleine Flugzeug fuer
+> > "Flughafen" auf etwas hinweisen, von dem ich
+> > jetzt aber nicht wuesste, was gemeint sein
+> > koennte.
+
+"Oeffentlicher Verkehr", siehe nebenan ;-)
+
+> > Oder steht es woanders? Taucht es bei 
+> > allen Zuegen und immer auf oder nur bei bestimm-
+> > ten oder zufaellig?
+
+Bei Zuegen mit Liegewagen und bei Triebzuegen, schaetze ich. Und bei
+Zuegen, die ueber das Stumpfgleis am Bahnhofsende umgesetzt werden.
+
+Gruss & SCNR, Matthias Dingeldein
+
+-----------------------------------------------------------------------------
+
+
+
+Reservierung. Anders. (Ronda, 18. Jan 2007, 18:27:30):
+Newsgroups: de.etc.bahn.tarif+service
+Subject: Re: Reservierungskosten bei Buchung ohne Ticket
+From: "Julia Backhausen" <sturenhagen@gmail.com>
+Date: 17 Jan 2007 08:47:51 -0800
+Message-ID: <1169052471.756179.251850@s34g2000cwa.googlegroups.com>
+
+
+
+Warum nicht einfach den kompletten Zug anzeigen, belegte Sitzplaetze in
+Rot, Raucherplaetze in Gelb, Nichtraucherplaetze in weiss und dann kann
+man seinen Sitzplatz anklicken. Wo auch immer im Zug man sitzen
+moechte. Das geht bei jeder dummen Busgesellschaft in Suedamerika,
+warum also nicht auch bei der deutschen Bahn.
+
+Und dann noch diese schoenen gelben Sprechblasen anzeigen, wenn man
+drueberfaehrt mit der Maus, wo dann drinsteht: Entfernung zum Klo 17m,
+Entfernung zum Speisewagen 100m, Entfernung zum naechsten Raucherabteil
+1m, Sitzabstand zum Vordermann 56cm, Tischtiefe 30cm, Entfernung zur
+naechsten Steckdose 4m.
+
+Und innerhalb von 2 Jahren kommt die Bahn auf die Idee die Plaetze auch
+noch alle unterschiedlich zu bepreisen, je nach Auslastung des
+einzelnen Sitzplatzes.
+
+Dann kann man noch fuer die Plaetze um sich herum zahlen, wenn man
+will. Je nach Praeferenz, dass man lieber andere Reservierende um sich
+herum sitzen haben moechte oder lieber ohne Reservierung Reisende kann
+man durch Zahlung von 1 bis 5 Euro den Preis fuer den Sitzplatz anheben
+oder senken, 50% davon gehen an die Bahn, das kann man dann noch
+differenzieren nach Geschlecht, Beruf und Alter. Also konkret: Wenn ein
+huebscher 25jaehriger im Anzug den Platz neben mir buchen will, dann
+bekommt er ihn fuer 1 Euro, weil ich fuer diesen Fall gezahlt habe.
+Will aber ein Mann oberhalb 50 dort sitzen, dann muss er 2,50 mehr
+bezahlen, in diesem Fall habe ich auch gezahlt an die Bahn damit die
+etwaige Einnahmeverluste dadurch das jemand nicht bucht abgegolten
+werden.... Und dann kann man noch nach Name das machen: Sollte
+"Benedikt von Heusen" neben mir sitzen wollen, dann darf meine
+Kreditkarte um weitere 5 Euro belastet werden und er soll dann fuer die
+Reservierung dieses Sitzplatzes einen Euro bekommen.....
+
+-----------------------------------------------------------------------------
+
+
+
+Der S.-Lufthaken ist doch keine Erfindung! (Ronda, 18. Jan 2007, 18:30:26):
+[Moderator's Note: Es geht um Siem^W...hach, werdet ihr schon merken.]
+
+From: Christoph Schmitz <christoph.schmitz2@post.rwth-aachen.de>
+Newsgroups: de.etc.bahn.misc
+Subject: Re: debx-Treffen
+Date: Wed, 17 Jan 2007 13:46:23 +0100
+Message-ID: <516k4tF1i863qU2@mid.dfncis.de>
+
+Martin Bienwald wrote:
+> > Christoph Zimmermann schrieb:
+> > 
+>> >>Marc Haber schrieb:
+>> >>
+>>> >>>Christoph Zimmermann <1753@ch-zimmermann.de> wrote:
+>> >>
+>>>> >>>>Saubloede
+>>>> >>>>Inginieure
+>>>> >>>>Entwickeln
+>>>> >>>>Mit
+>>>> >>>>Elan
+>>>> >>>>Nutzlose
+>>>> >>>>Signalanlagen
+>>> >>>
+>>> >>>Schlechter In Elektrik Macht Es Niemand Sonst.
+>> >>
+>> >>Sicher ist eins, man erhaelt nur Schrott.
+> > 
+> > So ist es meistens eigentlich nicht sinnvoll.
+
+Sehr intelligent erscheinende Menschen entwickeln
+nichttaugliche Stellwerke.
+
+Christoph
+
+-----------------------------------------------------------------------------
+
+
+
+LaTex und Emacs und der durchschnittliche Anwender (Ronda, 18. Jan 2007, 18:31:27):
+[SN: gekuerzt]
+
+Newsgroups: de.comp.text.tex
+Subject: Re: Warum LaTeX immer Aussenseiterprodukt bleiben wird...
+From: David Kastrup <dak@gnu.org>
+Date: Wed, 17 Jan 2007 13:29:45 +0100
+Message-ID: <86vej5rg3q.fsf@lola.quinscape.zz>
+
+Marcus Woletz <mwoletz.info@gmx.de> writes:
+
+> > Weiter: mir gefaellt LaTeX, sonst wuerde ich es nicht einsetzen.
+> > Dennoch hatte ich von Anfang irgend wie das Gefuehl, dass mich das
+> > System auf die eine oder andere Art ueberfordert.
+
+Steige um auf Emacs als Editor.  Dann wird es nicht mehr primaer LaTeX
+sein, das Dir das Gefuehl vermittelt, unter den Moeglichkeiten Deiner
+Werkzeuge zu bleiben.
+
+-----------------------------------------------------------------------------
+
+
+
+Frauen, Hochzeiten und Computer (Ronda, 21. Jan 2007, 22:05:10):
+From: Lukas Barth <tinloaf_usenet@klo.goerresonline.de>
+Newsgroups: de.alt.sysadmin.recovery
+Subject: Re: Programmierer und Admins (geklaut)
+
+Arnim Sommer wrote:
+> > Markus Brueckner schrieb: 
+>> >> Fuer die Beantwortung dieser Frage sitzt grad zu dicht neben mir *duck*
+>> >> Ausserdem hat sie mir grad vorgehalten, dass ich sie schliesslich
+heiraten
+>> >> will und ob ich meine Tastatur mit auf's Standesamt bringen will
+>> >> .oO(Hm....)
+>> >> 
+> > Schlagende Argumente richtung Standesbeamter?
+
+Nein, er muss ja irgendwie seine TAN unter den Ehevetrag tippen koennen...
+
+Lukas
+
+-----------------------------------------------------------------------------
+
+
+
+Hm. (Ronda, 21. Jan 2007, 22:08:13):
+Ist nun der Text dran schuld, dass das auf de.alt.netdigest geraten ist - oder
+dass man in Deutschland selbst unter so einen Artikel einen Disclaimer
+schreibt...?
+
+Ronda
+
+From: Jan-Christoph Langner <spam@hardwareonlineshop.de>
+Subject: Re: Flensburger Punkte Verkaufen
+Newsgroups: de.etc.fahrzeug.auto
+Date: Sat, 13 Jan 2007 19:39:23 +0100
+Message-ID: <45a9275a$0$5720$9b4e6d93@newsspool3.arcor-online.net>
+
+
+Tassilo S. Schweiger schrieb:
+> >"Jan-Christoph Langner" schrieb
+>> >>Nein, das Verkaufsmonopol auf Flens-Punkte liegt weiterhin bei der 
+>> >>Polizei.
+> >
+> >Echt? Die kann man kaufen? Da muss ich unbedingt auch einen haben... Was 
+> >koscht?
+
+
+Die haben einen ganz tollen Staffeltarif fuer Vielverbraucher
+Ein Flenspunkt ist ab 40 Euro zu haben, 3 Flenspunkte gibt es bereits 
+fuer senationelle 50 Euro im Schlussverkauf, Sie muessen sich nur dumm 
+genug anstellen und vor allem auch eine der zuvorkommenden Bedienung der
+Polizei erwischen.
+
+Flenspunkte koennen Sie auch in der praktischen Familienpackung mit mehr 
+als 3 Punkten erwerben, hier ist jedoch zu beruecksichtigen das es keine 
+Rabatte mehr gibt, sondern der Punktesteuerfreibetrag ueberschritten wird
+und die Flenspunkte so ueberproportional teuer werden; ausserdem koennte 
+die Polizei bei solchen punktesuechtigen Kandidaten uebermuetig werden, die
+Punktesucht schamlos ausnutzen und weitere Goodies beim Punkteverkauf zu
+verlangen (Fuehrerschein und solche Sachen).
+
+Die oekonomisch sinnvollste Loesung fuer den Flenspunktjunkie ist also 
+einfach mit ungesicherter Ladung umherzufahren und 3 Punkte fuer nur 50 
+Euro zu erwerben.
+
+Weiterhin bietet die Polizei als besonderen Service ein flaechendeckendes
+Netz an Punkteautomaten an, hier kann der Punktejunkie selbst bestimmen 
+wie viele Punkte er haben moechte. Dabei sollte beachtet werden, dass die
+Hoechstabgabemenge 4 Punkte ist.
+Die Bezahlung der Punkte erfolgt hier bequem auf Rechnung, jedoch sind 
+Automaten-Punkte idR etwas teurer als welche die man sich mit 
+ungesicherter Ladung verdienen kann. Aber dafuer entfaellt halt das 
+nervige Warten auf Bedienung sondern man kann sich selbst bedienen.
+
+Eine staendig aktualisierte Liste der Punkteautomaten finden sie auf 
+www.radarfalle.de
+
+
+Jan-Christoph, heut einen clown gefruehstueckt...
+
+
+Anmerkung: Nein, ich rate davon ab mit ungesicherter Ladung durch die 
+Gegend zu fahren :-)
+
+-----------------------------------------------------------------------------
+
+
+
+Nee, den find ich GAR nicht witzig. (Ronda, 21. Jan 2007, 22:11:50):
+Ronda *hat die Mail auch bekommen...*
+
+From: "E. Braun" <qs206710n5sqn8r56s6pr3s980940ss3@minet.uni-jena.de>
+Newsgroups: thur.jena
+Subject: Re: Schulen, Kindergaerten, Sturm
+Date: Thu, 18 Jan 2007 13:46:26 +0000 (UTC)
+Message-ID:
+<slrn4equuhi.dqfd.qs206710n5sqn8r56s6pr3s980940ss3@pax07e3.mipool.uni-jena.de>
+
+Lutz Donnerhacke <lutz@iks-jena.de> wrote:
+
+> > * Rainer Sokoll wrote:
+>> >> angeblich haben alle Jenaer Schulen ihre Schueler nach Hause geschickt,
+>> >> und wohl ebenso die Kindergaerten.
+>> >> Eltern sollten also sich um ihre Kinder kuemmern.
+> > 
+> > HP Deutschland hat alle Mitarbeiter nach Hause geschickt.
+
+BenQ Mobile war schneller!
+
+-----------------------------------------------------------------------------
+
+
+
+Word ist kompliziert? (Ronda, 24. Jan 2007, 00:35:28):
+From: "Daniel Rock" <v200704@deadcafe.de>
+Newsgroups: de.comp.os.unix.misc
+Subject: Re: Solaris - Test gescheitert :-(
+Date: Mon, 22 Jan 2007 16:18:22 +0000 (UTC)
+Message-ID: <ep2o4e$5k9$1@deadcafe.de>
+
+Heike C. Zimmerer <nospam06q3@gmx.net> wrote:
+> > Vermutlich ein der ersten Uebersetzungen (von A. Schreiner (IIRC)).
+> > Ich hatte die ganz schnell durch das Original ersetzt und erinnere
+> > mich mit Grausen.  Sie war ziemlich unertraeglich, schon wegen ihrer
+> > Getrennt Schreibung und Zeichen Setzung (genauer: Nicht Zeichen
+> > Setzung).
+
+Das erinnert mich an die Uebersetzung des Buches
+The Design and Implementation of the 4.3 BSD UNIX Operating System
+
+Im Vorwort stand in einem Absatz (sinngemaess):
+
+This book was produced with pic, tbl, eqn and groff. The index
+was generated by awk scripts. Most of the art was created with
+xfig. Figure placement was handled by groff macros.
+
+
+Und in der Uebersetzung:
+
+Anmerkung der Uebersetzerin: Die Uebersetzung wurde in Microsoft
+Word fuer DOS 5.0 geschrieben.
+
+-----------------------------------------------------------------------------
+
+
+
+Logisch. (Ronda, 24. Jan 2007, 00:36:55):
+[SN: die Diskussion dreht sich um einen Bewegungsmelder fuer den
+Hauseingangsbereich, der nicht ausgeht, wenn man im Erfassungsbereich mal
+stehen bleibt]
+
+From: Heiko Kradewitch <heikokrad@arcor.de>
+Subject: Re: Bewegungsmelder
+Newsgroups: de.rec.heimwerken
+Date: Mon, 22 Jan 2007 13:12:00 +0100
+Message-Id: <ep29mg$td0$00$1@news.t-online.com>
+
+Jochen Kriegerowski schrieb:
+> > Wie entscheiden die, ob die das Licht einschalten oder nicht? Da
+> > sitzt ein Mensch seit 3 Stunden unbeweglich herum und moechte
+> > lesen: Licht an. Da steht seit 3 Stunden die Muelltonne und kann gar
+> > nicht lesen: Licht aus. Falls das mit Infrarot- und sonstigen Sensoren
+> > gekoppelt ist eine Zusatzinformation: Die Muelltonne ist hellbraun, vom
+> > Sonnenschein tagsueber in Verbindung mit Gaerungsprozessen im
+> > Muell noch ca. 37C warm, und wiegt 80 kg <g>
+
+Wenn die Sonne scheint, braucht die Muelltonne kein Licht zum Lesen! ;-)
+
+Gruesse,
+Heiko
+
+-----------------------------------------------------------------------------
+
+
+
+Handzeichen (Ronda, 24. Jan 2007, 00:43:02):
+From: Marc Olschok <nobody@nowhere.invalid>
+Subject: Re: Gaensefuesschen per Handzeichen
+Newsgroups: de.etc.sprache.deutsch
+Date:Fri, 19 Jan 2007 23:21:55 +0100 (CET)
+Message-ID: <eorga2$psa$3@aioe.org>
+
+>> > > Seit wann gibt es eigentlich dieses seltsame Handzeichen, mit dem im
+>> > > Gespraech ein Wort in Anfuehrungszeichen dargestellt wird? Ich meine
+die
+>> > > beiden erhobenen Haende, bei denen Zeige- und Ringfinger die
+>> > > Gaensefuesschen in die Luft "malen".
+ 
+> > Ich verstehe dieses In-die-Luft-Malen als Teil eines Soziolektes,
+> > eine Geste die besagt: _wir sind doch beide Intellektuelle, wir
+> > verstehen uns, nicht wahr?_ Ich kann diese bloedsinnige Geste
+> > uebrigens auch nicht ausstehen :-)
+
+Warte ab, bis Dir das in die Luft gemalte Binnen-I begegnet ...
+
+-----------------------------------------------------------------------------
+
+
+
+Bahnfahren wird immer komplizierter (Ronda, 24. Jan 2007, 18:32:57):
+Newsgroups: de.etc.bahn.misc
+Subject: Re: [Sturm] Informationspolitik der DB AG
+From: "Clas Kristen" <Clas.Kristen@gmx.de>
+Date: Tue, 23 Jan 2007 18:26:12 +0100
+Message-ID: <45b64503$0$30323$9b4e6d93@newsspool1.arcor-online.net>
+
+Alexander Beyrer wrote:
+>> >>
+>> >> ... und die Wagen dadurch natuerlich auch leichter.
+> >
+> > <knoerks>
+> > Werte Fahrgaeste, wegen starken Seitenwindes
+> > von rechts bitten wie sie alle dringend, sich als
+> > Gegengewicht auf die in Fahrrichtung rechte
+> > Seite der Wagen zu begeben.
+> > <knoerks>
+
+Gewichtstrimm!
+Wenn beim segeln alle auf der "hohen Kante" sitzen oder im Trapez
+haengen, nennt man das "Gewichtstrimm".
+
+
+<knister knirsch>
+
+Werte Fahrgaeste!
+Wegen starken Seitenwind ist dieser Zug nur fuer Reisende mit
+Bodenseeschifferpatent A & D, SKS oder vergleichbarer Qualifikation
+freigegen.
+ Fahrgaeste die dieser Anforderung nicht entsprechen achten bitte auf
+weitere Lautsprecherdurchsagen.
+Die Direktion der Appenzeller Bahn dankt fuer Ihr Verstaendnis.
+
+<knister knirsch>
+
+
+Ahoi
+   Claus
+
+-----------------------------------------------------------------------------
+
+
+
+Frueh uebt sich, was ein Deutscher werden will (Ronda, 24. Jan 2007, 18:34:52):
+From: "Michael Khan" <mkk707@hotmail.com>
+Subject: Re: England plant eigene Mond Mission
+Newsgroups: de.sci.raumfahrt
+Date:23 Jan 2007 01:45:25 -0800
+Message-ID: <1169545524.964288.48610@l53g2000cwa.googlegroups.com>
+
+
+Uwe Hercksen wrote:
+
+> > worin liegt der spezielle Unterschied zwischen einer "deutschen Samen-
+> > oder Eizelle" zu einer aus dem restlichen Europa?
+
+Nicht mein Fachgebiet, aber ich vermute mal:
+
+Eine deutsche Samen- oder Eizelle wird von Selbstzweifel
+und Bedenken gequaelt. Sie wird sich ausmalen, was alles
+schief gehen kann und zu dem Schluss kommen, dass
+erfolgreiche Befruchtung ein Ding der Unmoeglichkeit
+ist, von der Entwicklung des Foetus oder gar der
+erfolgreichen Geburt ganz zu schweigen. Einwaende der
+Art, dass diese Bedenken doch erwiesenermassen
+uebetrieben sind, werden mit neuen Negativszenarien
+quittiert. Am Ende wird sie es vorziehen, in den Testikeln
+oder Ovarien zu verbleiben, als den Sprung zu wagen und
+dort weiter orakeln, unken,  schwarzmalen und sich in
+ironischem Negativismus ergehen, waehrend rings umher
+die Welt einfach weitergeht.
+
+-----------------------------------------------------------------------------
+
+
+
+Eigentlich... (Ronda, 24. Jan 2007, 18:42:51):
+... ist das Bild das beste am Artikel, oder?
+
+Ronda
+
+[SN: Aus der Diskussion, welcher der erste und welcher der letzte
+Einkaufswageneiner Reihe ist, wenn man
+http://accordionguy.blogware.com/Photos/2007/01/shopping-cart-circle.jpg
+basteln will]
+
+From: Rainer Koenig <Rainer.Koenig.Usenet@gmx.de>
+Subject: Re: Europaeer sind kriminell, sie klauen Einkaufswagen, deswegen
+muss man 1 Euro reinstecken
+Newsgroups: ger.ct
+Date:Sun, 21 Jan 2007 19:21:08 +0100
+Message-ID: <87ps98b5rf.fsf@Rainer.Koenig.Abg.dialin.t-online.de>
+
+"Ulrich F. Heidenreich" <use.reply-to@spamfence.net> writes:
+
+>> >>Nimm mal eine leere Wand mit Kette. 
+> >
+> > Wenn da kein Wagen mehr ist, ist eindeutig der letzte Wagen weg :-p 
+
+Ich glaube, dass das Problem hier einfach der "Abuse" des Modells "Stack"
+ist. Die Einkaufswagenaufbewahrungsbox ist ja wie ein Computer-Stack
+organisiert, Last In First Out. Und die angedachten Operationen sind
+eben "push" (Einkaufswagen zurueckgeben) oder "pull" (Einkaufswagen
+nach Einsatz der Muenze entnehmen).
+
+Und jetzt kommen so ein paar Hacker und wollen ploetzlich "random
+access" auf beliebige Elemente des Stacks implementieren. :-)
+Das ist klar, dass das Modell damit ueberfordert ist. :-)
+
+BTW: Gab es da nicht mal ein Lied "Alles hat ein Ende, nur die Wurst hat
+zwei"? Vielleicht koennen wir das auf Einkaufswagenwuermer umdichten. 
+
+Have fun!
+Rainer
+
+-----------------------------------------------------------------------------
+
+
+
+Alt. Sicher schon mal gelesen. (Ronda, 28. Jan 2007, 19:46:32):
+From: Lothar Cezanne <li_la_lothar_baer@gmx.de>
+Subject: [FYA] Auto-Foren
+Newsgroups: de.etc.fahrzeug.auto
+Date: Fri, 26 Jan 2007 23:41:25 +0100
+Message-ID: <51vecbF1kvs52U1@mid.individual.net>
+
+Stammt nicht von mir, ist aber dennoch gut <g>:
+
+--------------------------------------------------------------------
+In verschiedenen Auto-Foren werden die unterschiedlichsten Probleme
+diskutiert.
+Hier ein paar Beispiele:
+--------------------------------------------------------------------
+
+
+Lamborghini Forum:
+Windgeraeusche bei 305 km/h, ich weiss nicht weiter!
+
+
+Audi A8 Forum:
+Wo kann ich meine Rolex reparieren lassen?
+
+
+Fiat Forum:
+Hallo? Bin ich der einzige hier?
+
+
+Mercedes C-Klasse Forum:
+Mein Mercedes ist Sonntag beim Broetchenholen nass geworden - Was tun?
+
+
+MX-5 Forum:
+So ein Hinterwaeldler-Assi in einem VW Touareg ist mir uebers Auto
+gefahren!
+
+
+VW Touareg Forum:
+Mir klemmt ein MX-5 unterm Chassis. Wie kriege ich den wieder raus?
+
+
+Renault-Forum:
+Verkaufe Monatskarte - Auto frueher als erwartet aus Werkstatt zurueck.
+
+
+Porsche-Cayenne-Forum:
+Verbrauch unter 32l/100km. Einspritzung defekt?
+
+
+Smart Forum:
+Mofamotor eingebaut: Endlich mehr Leistung!
+
+
+Mustang Forum:
+So ein Schwachkopf im Civic hat heute versucht, mich zu ueberholen.
+
+
+Civic Forum:
+So ein Schwachkopf im Mustang hat heute versucht, mich zu ueberholen.
+
+
+Honda Accord Forum:
+Mama gibt mir ihr Auto. Suche billige 18 Zoll Felgen.
+
+
+VW Bora Forum:
+Ich bin sauer! Jeder haelt das fuer ein Golf mit Rucksack
+
+
+Opel Forum:
+Mein Corsa hat keinen Rost! EHRLICH! (Thema geloescht v. Admin)
+
+
+Lexus-Forum:
+Wo bekomme ich Rueckleuchten im VW-Style?
+
+
+Toyota Corolla E10 - Forum:
+Ich bin enttaeuscht von der Qualitaet meines E10, nach 270.000km ist die
+Tachoscheibe etwas zerkratzt!!!!
+
+
+Viper-Forum:
+Smart im Ansaugtrakt! Wie kriege ich den da wieder raus?
+
+
+Seat Marbella Forum:
+Konnte heute mit einem LKW mithalten!
+
+
+BMW 3er E36-Forum:
+Wo gibs beste fett krass Doener in Stadt
+
+
+Trabbi-Forum:
+War bei Mercedes Benz, haben nen neuen Motor reingefriemelt, jetzt laeuft
+er, laeuft nicht, laeuft, laeuft nicht => einmal editiert: Anruf von 
+Mercedes Benz:
+Sie haben einen Wischermotor eingebaut, schalten Sie bitte von Intervall
+auf Stufe eins um..
+
+
+Hummer Forum:
+Hab' mir heute die Stossstange verbogen. 14 Verletzte, 2 Tote.
+
+Muss ich den schwarzen Lack unbedingt beim Haendler kaufen??
+Er sitzt 25 Kilometer entfernt. Das macht 35 Euro Spritkosten!
+
+
+MB 190D Forum:
+Mein Kaeufer hat ne Rueckfrage - kann jemand Kisuaheli?
+
+
+Yugo Forum:
+Wann hat eurer das letzte Mal funktioniert?
+
+
+Honda Civic CRX-Forum:
+Der Hund meines Nachbarn schlaeft in meinem Auspuffrohr, kann ich 
+trotzdem starten??
+
+
+Toyota Forum:
+Hab jetzt 300.000 km runter, wann geht das Ding kaputt?
+
+
+Polo Forum:
+Endlich 6cm tiefer, aber komme nicht mehr ans Mikro bei McDrive!
+
+
+Ferrari Forum:
+Tipps fuer eine Geschaeftsreise nach Kolumbien gesucht. Will schnell rein
+und wieder raus
+
+
+Porsche Forum:
+Ich hab' einen Platten - kommt Inzahlungnahme guenstiger oder soll ich 
+den Wagen lieber selbst verkaufen?
+
+
+Lancia-Forum:
+Gibt es ein Leben ausserhalb der Werkstatt?
+
+
+BMW 7er-Forum:
+Hilfe ich hab mich verprogrammiert, wie ging der Aschenbecher noch mal
+zu....?
+
+
+Mercedes S-Klasse Forum: - suche adaequaten Zweitwagen fuer Nebelfahrten
+
+
+lc#
+
+-----------------------------------------------------------------------------
+
+
+
+Telekomtechniker (Ronda, 28. Jan 2007, 19:47:42):
+Subject: Re: Telekomtechniker
+From: Michael Eggert <m.eggert.nul@web.de>
+Date: Sat, 27 Jan 2007 02:32:19 +0100
+Message-ID: <npalr2havfgsgull6u4m4spcj2s99g372p@4ax.com>
+
+hbruns@gmx.de wrote:
+
+Moin!
+
+> >Ich habe
+> >eben den vierten Termin fuer einen Techniker vereinbart, der einfach
+> >nur seinen Zettel in den Briefkasten wirft, ohne zu klingeln.
+> >
+> >Ich bin jedenfalls voellig frustiert. Was kann ich tun? Hat jemand den
+> >passenden Tipp auf Lager?
+
+*----------------------*
+|  Dieser Hauseingang  |
+| wird kameraueberwacht |
+*----------------------*
+
+Gruss,
+Michael.
+
+-----------------------------------------------------------------------------
+
+
+
+Feudeln ist sexy! (Ronda, 28. Jan 2007, 19:58:51):
+From: Michael Baumgartner <michaelsusenet@hotmail.com>
+Subject: Re: Kontaminierte Feudel?
+Newsgroups: de.etc.sprache.deutsch
+Date: Wed, 24 Jan 2007 12:21:10 +0100
+Message-ID: <80j5m390dymj.ds2sgyuq4ud2$.dlg@40tude.net>
+
+>> >> Davon abgesehen, dass die Hamburger offenbar wieder mal einen
+>> >> Regionalismus (Feudel) fuer ueberregional verstaendlich halten und 
+>> >> sich daron moeglicherweise irren -
+ 
+> > Mir ist das Wort unbekannt und unverstaendlich.
+
+Ein Freund, der aus dem niederbayerischen Simbach/Inn stammt, hat von
+einem norddeutschen Kommilitonen an der Uni Passau berichtet. Der klagte
+eines Tages ueber Muedigkeit, weil er die ganze Nacht gefeudelt habe. Mein
+Freund antwortete nichts, dachte aber bei sich: "Was interessiert es
+mich, was der mit seiner Freundin anstellt."
+
+-----------------------------------------------------------------------------
+
+
+
+Barbara und der Conflict of Interest (Ronda, 28. Jan 2007, 20:02:01):
+Subject: Re: Die Strandhaubitze
+From: Andreas Kabel <andreas.kabel@gmail.com>
+Newsgroups: de.etc.sprache.deutsch
+
+Ergaenzung des Einsenders:
+Es handelt sich um Barbara, die Schutzheilige
+
+
+Reinhard Gonaus <reinhard@ibido.at> writes:
+
+> > Und sie ist: Patronin der Artillerie, der
+[...]
+> > Ausserdem hilft sie gegen jaehen Tod
+
+Ich wittere einen conflict of interest.
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Feudeln ist sexy! (Darklor,  5. Feb 2007, 04:39:20):
+~#! rn=Ronda rt=1170010731 rg=schmarrn.netdigest
+~#! tid=1170010731
+War das nich n Staubwedel?
+
+Darklor
+
+-----------------------------------------------------------------------------
+
+
+
+Irgendwie erinnert das an Labor-Kaffee (Ronda,  5. Feb 2007, 21:46:09):
+Betreff: Re: Kaffeemaschine
+Absender: Timm Thiemann <timms-news@gmx.net>
+Datum: Sun, 04 Feb 2007 01:22:23 +0100
+Newsgruppe: de.alt.sysadmin.recovery
+Message-ID: <vv83qe.gs5.ln@pommes.timmthiemann.de>
+
+
+Maximilian Gauger wrote:
+> > 
+> > Schwarztee vom Tuerken (das Zeug erinnert eher an Zweige als an Blaetter) 
+> > nehmen und ordentlich dosieren (drei gehaeufte Teeloeffel auf eine 
+> > Halblitertasse).
+> > 
+> > Wenn Du dann nicht wach bist, bist Du tot.
+
+oder vom Kasachen.
+
+"Andrej, da war kein Kaffee mehr, ich hab mir was von Deinem Tee geklaut."
+"Wie viel?"
+"Zwei Teeloeffel."
+"Oh. Ich nehme immer 1,5. Geht gut?"
+
+Die 1,5 nimmt er auf eine Literkanne. Ich hatte einen Becher. Und
+Schweissausbrueche. Und eine schlaflose Nacht.
+
+-----------------------------------------------------------------------------
+
+
+
+Kalauer: Beim Chef hats gefunkt. (Ronda,  5. Feb 2007, 21:48:01):
+From: Guenter Hackel <search_for_signature@invalid.xs>
+Newsgroups: de.etc.haushalt
+Subject: Re: Neue Matratze und statische Aufladung
+Date: Wed, 31 Jan 2007 18:10:46 +0100
+Message-ID: <52c0uhF1njrptU1@mid.individual.net>
+
+Gerhard Mayer schrieb:
+
+> > Bei der Matratze aber gibt es Funken, die sind so hell, das ich die 
+> > unbeleuchtete Anzeige meines Radiweckers ablesen kann. Ausserdem sind 
+> > diese recht schmerzhaft, mir haben die Muskeln des rechten Arms 2 Tage 
+> > lang weh getan nach diesen Entladungen. Sowas hab ich bisher noch nicht 
+> > erlebt.
+
+Auweia! Ich kann Dir nachfuehlen. Ich hatte waehrend meiner Lehrzeit so 
+ein Problem, ich versuchs kurz zu schildern.
+Ich lernte Fernmeldemonteur und war derzeit in der Abteilung 
+"Endkontrolle" beim Fernsprecherbau. Ich sass mit einer der Arbeiterinnen 
+zusammen in einem mit Glas und Metall abgeteilten Bereich einer 
+Werkshalle. Wir testen dort ganz normals Tischtelefone auf ihre 
+Funktion, wischten sie danach noch einmal ab, stopften sie in eine 
+Plastiktuete und stellten sie auf einen mehrstoeckigen Transportwagen der 
+auf Gummibereifung stand. Es war Winter, die Luft war 
+knochenpforztrocken, ich musste einen hellblauen Kittel (fast 
+vollstaendig Plastik) tragen und sass auf einem Drehstuhl mit lackiertem 
+Holz und Kunsstoffrollen. Wegen des Winters trug ich Schuhe mit 
+Gummisohlen. Mit jedem abputzen der Telefone erzeugten wir jede Menge 
+Ladung und wenn wie die Apparate dann auf den Transportwagen stellten, 
+streiften wir einen Grossteil davon auf den Wagen ab. Dieser lud sich, 
+dank der idealen Voraussetzungen wie ein Kondensator gewaltig auf, was 
+man aber erst mal nicht merkte. Heikel wurde es, wenn der Wagen voll 
+war, dann zog man ihn zur Tuer (Metall, wie gesagt) und diese musste man 
+ja oeffnen. Tja, und dann gabs regelmaessig ca 10 oder 15cm lange, richtig 
+knallende Entladungen und die haben weh getan. Ok, das allerschlimmste 
+kann man vermeiden indem man die Tuer nicht gleich mit der Hand anfasste 
+sondern die Entladung mit einem Schraubendreher provozierte. Heftig! 
+Experimente mit einem hochohmigen Widerstand zur langsamen Entladung 
+schlugen fehl weil der glatt vom Blitz uebersprungen wurde. Ich bat den 
+Abteilungsleiter darum, dass ich mir eine Metallspange entweder an den 
+Schuhen (zum ableiten an den Boden) oder aber ein Armband mit einer 
+Erdklemme und Widerstand besorgen duerfte. Er lehnte das aus 
+Sicherheitsgruenden ab (Stromschlaege angeblich). Also Selbsthilfe! Der 
+Typ kam jeden Morgen herum um die Leute zu begruessen. Am Folgetag nach 
+der Ablehnung meiner Ideen putzte ich wie bessesen die Telefone und ludt 
+den Wagen richtig schoen auf. Als dann der Abteilungsleiter kam, fasste 
+ich zuerst Mut, dann mit der linken Hand hinter dem Ruecken den Wagen und 
+  ergriff dann die dargebotene Hand des Abteilungsleiters. Keine 20 
+Minuten spaeter, kurz nachdem der Knabe wieder von der Lampe 
+runtergeklettert war, erhielt ich meine Erdungsspange ;)
+   Ich habe allerdings Monate gebraucht, bis ich mich nicht mehr 
+scheute, Tuerklingen anzufassen und wenn ich heute mal im Winter beim 
+schieben eines Einkaufswagens einen gewischt bekomme wenn ich an ein 
+Regal oder eine Kuehltruhe greife, kommt das alles wieder hoch. ;)
+gh
+> > 
+> > Wie dem auch sei: Die Matratze wird anstandslos zurueckgenommen und ich 
+> > krieg ein Modell, das komplett aus Baum- bzw. Schurwolle besteht. Damit 
+> > sollte es dann zumindest keine Ausladung mehr geben.
+> > 
+> > Und doch: Beide Matratzen (alt und neu) sind laut Ettikett 100% 
+> > Polyester (zumindest der aeussere Bezug, Drill ist glaub die korrekte 
+> > Bezeichnung).
+> > 
+> > CU und Danke
+> > 
+> > Gerhard Mayer
+
+-----------------------------------------------------------------------------
+
+
+
+Segler: Bitte das hier NICHT lesen! (Ronda,  5. Feb 2007, 21:48:51):
+Message-ID: <51ub0iF1mc56kU1@mid.dfncis.de>
+From: Christoph Schmitz <christoph.schmitz2@post.rwth-aachen.de>
+Newsgroups: de.rec.sport.segeln
+Subject: Re: Versicherungsschaden oder hoehere Gewalt?
+Date: Fri, 26 Jan 2007 13:37:43 +0100
+
+Ignatios Souvatzis wrote:
+> > Herbert Schneider wrote: 
+> > 
+>> >>Mein auf dem Clubgelaende abgestellter Topcat K3 wurde im Sturm
+beschaedigt. 
+>> >>Das Boot das  neben meinem Kat abgestellt war kam ins rollen (Trailer)
+und 
+>> >>die Haengerkupplung bohrte sich durch den Bb-Rumpf. Schaden - von der
+Firma 
+>> >>Topcat geschaetzt - ca. 5000 Euro. Der K3 ist 2 Jahre alt und wird auf 
+>> >>Regatten benutzt. Was tun sprach Zeus?
+> > 
+> > Wenn da kein Boot 'draufsteht, aber er am Zugfahrzeug angekuppelt ist,
+> > der des Zugfahrzeuges...
+
+Wenn an der Kupplung, die sich durch den Rumpf bohrte,
+ein Zugfahrzeug angekuppelt gewesen waere, waere das
+Loch groesser geworden...
+
+SCNR
+Christoph
+
+-----------------------------------------------------------------------------
+
+
+
+Fuer wen... (Ronda, 12. Feb 2007, 23:38:44):
+... ist das Mud lebenswichtig?
+
+Ronda
+
+[Notiz des Einreichers: firmeninternes Fundstueck, anonymisiert]
+
+Newsgroups: xxxxxx.infoboerse
+Subject: Re: Empfehlung Navigationssystem?
+From: $NAME <$ADRESSE@xxxxxxx>
+Date: Wed, 31 Jan 2007 14:24:38 +0100
+Message-ID: <epq5am$mpe$1@news.xxxxxx.de>
+
+$VORREDNER wrote:
+
+> > Mein Vater wuerde jetzt sagen: "als ich so alt war wie Ihr, hat's das
+alles 
+> > noch nicht gegeben..."
+
+Alles was vor deinem 20. Geburtstag erfunden wurde ist lebenswichtig.
+Alles was vor deinem 35 Geburtstag erfunden wurde ist sinnvolles oder 
+sinnloses Spielzeug.
+Alles was danach kam ist Teufelszeug.
+
+-----------------------------------------------------------------------------
+
+
+
+Gemein... (Ronda, 14. Feb 2007, 00:06:10):
+... so was armen unschuldigen Call-Center-Leuten anzutun, die doch auch nix
+dafuer koennen, dass sie illegal Leute anrufen sollen...
+
+Ronda *Ironie? Wasn das?*
+
+From: Achim Lesmeister <lesmeister@spamfence.net>
+Subject: Re: Anrufe von diversen Telefonanbietern
+Newsgroups: de.comm.provider.misc
+Date: Mon, 12 Feb 2007 19:58:51 +0100
+Message-ID: <53brndF1s733hU1@mid.dfncis.de>
+
+>> >> Ein serioeses Unternehmen wird auch einen schriftlichen 
+>> >> Vertragsschluss als Alternative akzeptieren.
+
+> > Wenn man auch keine Post will: 'Schicken Sie mir die Unterlagen mal
+> > zu, ich sehe sie mir dann mit meinem Betreuer mal an.'
+
+Eine sehr schone Methode Cold-Calls zu behandeln habe ich mal hier im 
+Usenet gefunden (dan-am iirc ). Inzwischen konnte ich das mehrfach 
+erfolgreich ausprobieren. Der Vorteil: Die Methode ist fuer den Anwender 
+sehr nervenschonend. Naja, ein klein wenig befriedigend ist es auch 
+noch. ;-)
+
+Telefon klingelt...
+
+Call-Center-Drohne: "Guten Tag Herr Lesmeister, ich rufe Sie wegen ... 
+an. Darf ich kurz..." (Text nahezu beliebig austauschbar)
+
+Ich: "Oh, klar gerne, ich muesste aber mal kurz in die Kueche." (o.ae.) 
+"Darf ich Sie mal kurz beiseite legen?"
+
+CCD: "Natuerlich" (o.ae. Die sagen _immer_ ja.)
+
+Dann lege ich den Hoerer neben das Telefon und gehe spuelen oder was mir 
+sonst so einfaellt. Jedenfalls warte ich _mindestens_ zwei, manchmal drei 
+Minuten ehe ich den Hoerer wieder in die Hand nehme. Das kommt einem zwar 
+zuerst sehr lange vor, aber bis jetzt war die Drohne dann immer noch 
+geduldig in der Leitung.
+
+Ich: "So, da bin ich wieder, sind Sie noch dran?"
+
+CCD: "Ja natuerlich, ich wuerde dann gerne..." Hier unterbreche ich.
+
+Ich: "Oh, dann muss ich Sie wohl tatsaechlich noch laenger weglegen."
+
+Dann lege ich den Hoerer wieder daneben. (Nicht auflegen!)
+
+Beim zweiten Nachsehen nach 1-2 Minuten hat bis jetzt noch jede Drohne 
+das Gespaech von sich aus beendet.
+
+Das Nette daran ist, dass man sich selbst nicht aufregt, keine 
+Diskussion fuehren muss etc. Zudem ist die Drohne insgesamt fuer etwa 4-5 
+Minuten auch nicht in der Lage jemanden anderen zu belaestigen (Wie etwa, 
+wenn man sofort auflegt.)
+
+Ich teste jetzt von mal zu mal mehr, wie lange man die Drohne im ersten 
+Anlauf in der Leitung halten kann. Allerdings sind die Anrufe inzwischen 
+bedeutend seltener geworden. Ob da ein ursaechlicher Zusammenhang 
+besteht, entzieht sich leider meiner Beurteilung.
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Gemein... (Zook, 14. Feb 2007, 09:57:14):
+~#! rn=Ronda rt=1171407970 rg=schmarrn.netdigest
+~#! tid=1171407970
+Da kann ich eine Geschichte beisteuern: Eine Bekannte von mir hat waehrend
+ihres Jura-Studiums in einer Grosskanzlei als Referandrin gearbeitet. Ihr 
+Chef hat ihr dann folgendes gesagt, fuer den Fall, dass Mandanten am 
+Telefon rumschreien:
+
+"1. Fuer das Anhoeren des Geschreis kannst Du keine Rechnung schreiben.
+2. Egal was Du sagst, wenn der andere schreit, bekommst Du das Gespraech
+ohnehin nicht mehr auf eine sachliche Ebene und unsachlich kannst Du nur
+verlieren.
+3. Du legst auf."
+
+Die Bekannte schaute ihren Chef unglaeubig und mit grossen Augen an. Er
+bestaetigte: "Ja, Du legst auf."
+
+Sie hat das dann tatsaechlich mal gemacht, nachdem ein heiss gelaufener
+Ami sie am Telefon angeschrien hat. Nach dreimal auflegen hatte er sich
+soweit beruhigt, dass er mal nachgefragt hatte, warum sie eigentlich immer
+auflegen wuerde, ein paar Saetze spaeter konnten sie sich dann auch der
+Sache widmen und dann auch eine Rechnung schreiben.
+
+Zook.
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Gemein... (Rumata, 14. Feb 2007, 10:25:57):
+~#! rn=Zook rt=1171443434 rg=schmarrn.netdigest
+~#! tid=1171407970
+Leider ist das nicht zu verallgemeinern.
+Die von Tele2 stellen trotzdem Rechnungen.
+Rum**
+
+-----------------------------------------------------------------------------
+
+
+
+Paderborn. Im Gegensatz zu Bielefeld gibts das. (Ronda, 21. Feb 2007, 23:13:16):
+Message-ID: <45d73cbd$0$20298$9b4e6d93@newsspool3.arcor-online.net>
+From: Christopher Creutzig <christopher@creutzig.de>
+Newsgroups: de.soc.recht.misc
+Subject: Re: Abmahnung ohne Streitwert
+Date: Sat, 17 Feb 2007 18:34:54 +0100
+
+Heiko Nock wrote:
+
+> > "Zu Nachtzeiten faellt das Gebaeude allerdings dadurch auf, dass es von
+bunten
+> > Scheinwerfern angestrahlt wird. Diese Beleuchtung ist derart auffaellig,
+dass
+> > jeder Mensch, der im Leben steht, auch ohne irgendwelche Hinweise erkennen
+> > kann, dass es sich um einen bordellaehnlichen Betrieb handelt."
+> > -- AG Herford Beschluss v. 4.3.1998 (3 Gs 41/97)
+
+  Die sollten mal waehrend des Weihnachtsmarktes nach Paderborn kommen, 
+ist ja nicht weit. Da trifft die Beschreibung seit einigen Jahren auf 
+den Dom zu ... :-)
+
+
+Gruss,
+Christopher
+
+-----------------------------------------------------------------------------
+
+
+
+Ist das witzig oder nicht? (Ronda, 25. Feb 2007, 20:30:57):
+From: Mark Obrembalski <markobr@web.de>
+Subject: Re: Auskunft
+Newsgroups: de.etc.finanz.misc
+Date:Sat, 24 Feb 2007 23:39:06 +0100
+Message-ID: <54bt4bF20gi4kU1@mid.individual.net>
+
+> > From:   "Helger Dooley" <helger@catholic.org>
+                                  ^^^^^^^^^^^^
+> > Wie werde ich schnell reich ohne viel Arbeit ???
+
+Klassischerweise durch den Verkauf von Ablassbriefen.
+
+-----------------------------------------------------------------------------
+
+
+
+Beaufort-Skala fuer Segler. (Ronda, 25. Feb 2007, 20:54:20):
+From: "Matthias Luczak" <luczak@gmx.de>
+Subject: Re: Bierkastendaempfung
+Newsgroups: de.rec.sport.segeln
+Date: 23 Feb 2007 00:28:24 -0800
+Message-ID: <1172219304.697407.46720@z35g2000cwz.googlegroups.com>
+
+Ich weiss nich genau, ob es bei dem Thema hilft. Aber es passt gut
+dazu:
+
+aus
+http://www.baw.de/vip/abteilungen/wbk/Publikationen/scn/sc4-2000a/node25.htm
+Beaufort-Skala
+Windstaerke 0:
+Es ist Zeit zu doesen, Kinder koennen zum Bier holen unter Deck
+geschickt werden.
+Windstaerke 1:
+Man sollte mindestens ein Auge geoeffnet halten um auf die im folgenden
+geschilderten Eventualitaeten vorbereitet zu sein. Nichts hindert einen
+die Kinder wiederholt zu schicken.
+Windstaerke 2:
+ Der Bierkasten sollte in nicht zu grosser Entfernung auf den Boden
+gestellt werden, da die Kinder bereits beginnen sich ungeschickt zu
+bewegen.
+Windstaerke 3:
+Bierflaschen koennen nicht allein stehen und m"ussen in die Hand
+genommen werden.
+Windstaerke 4:
+Leere Bierflaschen rollen herum und koennen ueber Bord fallen.
+Windstaerke 5:
+Alle Bierflaschen, die zum Kuehlen aussenbords haengen, muessen nun an
+Deck geholt werden.
+Windstaerke 6:
+Kein Crewmitglied darf fuer mehr als eine Flasche verantwortlich sein.
+Windstaerke 7:
+Der Bierkasten rutscht jetzt auf dem Deck herum. Ein Mann wird
+abgeteilt, um sich darauf zu setzen.
+Windstaerke 8:
+Flaschen koennen noch von einem Mann geoeffnet werden. Erste Probleme,
+diese zum Mund zu fuehren.
+Windstaerke 9:
+Bierflaschen muessen mit beiden Haenden gehalten werden. Nur Geuebte
+bekommen die Flasche noch alleine auf.
+Windstaerke 10:
+Man braucht zwei Mann zum Flaschenoeffnen. Leergut fliegt in Lee ueber
+Bord. Erste Zaehne werden mit der Flasche losgeschlagen.
+Windstaerke 11:
+Bier schaeumt ueber. Sehr gefaehrlich zu trinken. Lippen springen dabei
+auf und Zaehne fallen aus.
+Windstaerke 12:
+Alle Flaschen schaeumen ueber. Unmoeglich zu trinken. Absolutes
+Bierflaschenoeffnungsverbot!
+
+mfg
+matthias
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Ist das witzig oder nicht? (Orktoeter, 25. Feb 2007, 22:31:29):
+~#! rn=Ronda rt=1172431857 rg=schmarrn.netdigest
+~#! tid=1172431857
+Auch immer sehr beliebt gewesen; Der Hexerei oder Ketzerei bezichtigen, toeten
+und das Erbe einsacken.
+
+-----------------------------------------------------------------------------
+
+
+
+Disclaimer (Ronda,  2. Mar 2007, 22:36:55):
+Liebe Kinder, macht das nicht nach. Eltern: Ihr auch nicht. Wenn Ihr nicht
+wisst was ihr tut und zu langsam mit dem Schluessel weg seid.
+
+Ronda
+
+Subject: Re: Mensch ist Schuld
+From: Ralf Kusmierz <me@privacy.invalid>
+Date: Wed, 28 Feb 2007 18:58:31 +0100
+Message-ID: <es4fs7$74o$1@online.de>
+Newsgroups: de.soc.umwelt,de.soc.verkehr,de.rec.fahrrad
+
+[Anmerkung des Einreichers: Es ging darum, dass, wegen der vom Menschen
+verursachten hoeheren Abgasmenge unter der Woche, das Wetter am Wochenende
+statistisch gesehen schlechter ist, als waehrend der fuenf Werktage]
+
+Ralf Kusmierz schrieb:
+
+>>>> ...und dann gibts noch so seltsame Individuen, die beim
+>>>> Broetchenholen den Motor ihres Alfa 156 laufen lassen und auf meinen >>>>
+Kommentar hin, dass der Kraftstoff wohl immer noch nicht teuer
+>>>> genug sei, nur mit Unverstaendnis und persoenlichen Beleidigungen
+>>>> reagieren.
+
+>>> Der Mensch ist schuld und Idioten wie die oben beschriebenen gehoeren >>>
+verhauen.
+
+>> Ach wo, ins Auto setzen und wegfahren (lassen). Wegen grober
+>> Fahrlaessigkeit gibts da auch nix von der Versicherung.
+
+> Aber es gibt bestimmt was vom Staatsanwalt, naemlich Aerger
+> fuer Dich. Schluessel abziehen (und je nach Laune entweder
+> im Fussraum verstecken oder in den naechsten Gully werfen)
+> duerfte einem "billiger" kommen, und man wird auch nicht
+> so leicht erwischt. ;-)
+
+Erwischt??? Ich habe in solchen Faellen gelegentlich den Motor
+ausgemacht, das Auto abgeschlossen, Kennzeichen notiert und den
+Schluessel zur Polizeiwache gebracht, mit der Bemerkung, ich haette da
+und da ein ungesichertes Auto mit laufendem Motor vorgefunden, was ich
+dann "gesichert" haette.
+
+Gruss aus Bremen
+
+Ralf 
+
+-----------------------------------------------------------------------------
+
+
+
+Winbloed Vista (Amaryllis,  3. Mar 2007, 10:42:08):
+From: Gotschiau - Sinudon <nakor@hush.com>
+Subject: Re: Erfahrungen mit Windows Vista?
+Newsgroups: ch.talk
+Date: Sun, 25 Feb 2007 23:11:39 +0700
+Message-Id: <ersckv$bev$1@news.taunusstein.net>
+
+Andre R. Mastel schrieb:
+> Am Fri, 16 Feb 2007 22:36:23 +0100 schrieb Tim Hager:
+>
+>> Irgendwelche Erfahrungen mit Windows Vista?
+>
+> Userin ruft die Vista-Hotline an:
+> "Ich installiere gerade Windows Vista. Was soll ich druecken?"
+> Computerhotline: "Beide Daumen, gute Frau!"
+>
+> And "oder so...." re
+Warum man Vista kaufen sollte!
+
+
+Da bleibt einem der Mund offen stehen, wenn man sich das neue
+Wunderbetriebssystem aus dem Hause Microsoft ansieht. Schick, schnell,
+super! Mit Windows Vista ist dem weltweit groessten Softwarehersteller
+endgueltig der grosse Durchbruch gelungen - Microsoft hat es geschafft!
+
+Keine andere Firma kann sieben Jahre alte Technik zum sechsfachen des
+marktueblichen Preises verkaufen und dem Kunden dabei ein Gefuehl der
+Zufriedenheit vermitteln. Doch Microsoft hat es geschafft!
+
+Technik, die begeistert
+Der NT-Kernel und das Dateisystem NTFS sind veraltet. Eingefuehrt 1993,
+hat sich im Grunde kaum etwas geaendert. Die sechs Jahre alte Version von
+NTFS wurde sogar unveraendert in Vista uebernommen. Das muss man sich auf
+der Zunge zergehen lassen. Ein Dateisystem, das so alt ist, dass es
+defragmentiert werden muss. Viele wissen gar nicht mehr was das
+ueberhaupt ist. Jedes moderne Dateisystem legt die Daten auf der
+Festplatte so ab, dass es gar nicht erst fragmentiert. Egal - Microsoft
+hat es geschafft!
+Warum sollte sich Microsoft auch nach neuen Technologien oder Standards
+richten? Sie erfinden einfach ihre eigenen. Wenn kuemmert es, dass der
+Internet-Explorer nicht einmal die gaengigsten Web-Standards unterstuetzt?
+Oder, dass Technologien wie EAX in einem Betriebssystem fuer Spiele nicht
+unterstuetzt wird? Den Besitzern von hochwertigen X-Fi-Soundkarten fiel
+die Kinnlade herunter und zertruemmerte die Schreibtischplatte, als
+Microsoft verkuendete, dass die Schnittstelle fuer 3D-Ton einfach entfernt
+wurde. DTS-, DVD-Audio- und Dolby Digital-Unterstuetzung wurde ebenfalls
+aus dem System gestrichen. Trotzdem - Microsoft hat es geschafft!
+
+Its not a bug its a feature
+Microsoft hat es geschafft, dass man zum oeffnen eines Textdokuments eine
+Grafikkarte mit DirectX 9.0 und 256 MB Grafikkartenspeicher benoetigt.
+Zum einfachen Besuch im Internet genuegen 2 GB Arbeitsspeicher sowie ein
+2 GHz Prozessor. Wahrscheinlich haben sich einige Mitarbeiter der
+Geheimdienste ueber die langsamen Rechner beschwert, die sie
+ausspionieren muessen. Hey, auch Beamte haben Rechte.
+Microsoft hat Recht behalten. Windows Vista ist schneller geworden. Nun,
+das liegt vor allem daran, dass es 2001 noch keine Vierkern-Prozessoren
+und 1-GHz-Speicherriegel gab. Man muss sich heute lediglich einen
+vierfach schnelleren Rechner kaufen, um doppelte Geschwindigkeit zu
+erleben. Ich gratuliere Microsoft - ihr habt es geschafft!
+
+Wir wissen, was Sie gerade hoeren
+Natuerlich gibt es kein Windows ohne lebenswichtige Neuerungen. Eine
+verbesserte Suchfunktion soll senilen Menschen helfen, ihre verlegten
+Dokumente zu finden. Der Service geht sogar so weit, dass der Benutzer
+jede Minute daran erinnert wird, dass der Rechner durch das Internet
+gefaehrdet ist. Leider wird die Ursache der Gefaehrdung, der
+Internet-Explorer, nicht genannt. Das wird aber in der naechsten Version
+behoben, ganz bestimmt.
+Microsoft hat es geschafft digitale Notizzettel auf den Desktop zu
+zaubern. Das war auch der Grund, warum die Entwicklung sechs Jahre
+gedauert hat. Das Design-Team konnte sich einfach nicht auf die Farbe
+der Zettel einigen. Jedenfalls sind diese kleinen, geklauten Programme
+wichtige Helfer im Alltag. Sie hoeren auf den Namen Widgets - Verzeihung
+Gadgets. Sie sagen einem, ob draussen die Sonne scheint oder ob es
+regnet. Eine perfekte Erfindung fuer paranoide Amerikaner, die sich in
+ihrem Atombunker vor Ali Baba und den 19 Raeubern verstecken. Temperatur,
+Kalender, Aktien, Notizen - Wahnsinn! Wahrscheinlich ist dies das Ende
+der Klebezettel-Industrie. Hurra Microsoft - ihr habt sie geschafft!
+
+DirectX 10 - ein Geniestreich
+Microsoft hat es geschafft unsere Spielerherzen zu erpressen. Kaeufer des
+PC-Spiels Crysis sind verpflichtet, sich Windows Vista zu kaufen, wenn
+sie es in voller Pracht erleben wollen. Da aber kein EAX unterstuetzt
+wird, kann man seine 300-Euro-Soundkarte in den Muell werfen. Doch ohne
+Ton ist Crysis langweilig und so kauft sich der gewiefte Zocker eine
+DirectX-10-Grafikkarte fuer 600 Euro. Leider hat Vista sich als
+Spieleplattform durch fehlende OpenGL-Unterstuetzung selbst
+disqualifiziert. Und so verscherbelt man den Krempel bei eBay -
+Startpreis 1 Euro. Genial! Microsoft hat es geschafft!
+
+550 Euro? Ein Schnaeppchen
+Windows Vista kostet in Deutschland 550 Euro. Das sind satte 250 Euro
+mehr als in den vereinigten Staaten. Ein stolzer Preis, moechte man
+meinen. Bedenkt man aber, wie viel Spannung, Spass und ueberraschung in
+Windows Vista steckt, ist der Preis vollkommen gerechtfertigt. Der
+Nervenkitzel, wenn man feststellt, dass der normalen SB-Version keine
+64-Bit-DVD beiliegt, und man noch einmal 190 Euro bezahlen muss. Jeder
+Linuxbesitzer wuerde jetzt vor Lachen vom Stuhl fallen. Aber die Jungs
+aus Redmond haben eben einen sehr eigentuemlichen Humor.
+
+Die ganze Softwareindustrie lacht sich schlapp, waehrend Microsoft
+versucht sich das Rad patentieren zu lassen, um es als "Feature" im
+naechsten Windows einzubauen. Dafuer, und fuer die Tatsache, dass ihr immer
+wisst, was ich gerade mache, moechte ich euch danken - ihr habt es mal
+wieder geschafft!
+Windows Vista - Ich liebe es!
+
+So ist es weiterhin nicht moeglich, Dolby Digital- und DTS-Signale ueber
+die Soundkarte wiederzugeben. [&] DVD-Audio werden wir unter Vista nicht
+laenger unterstuetzen koennen.
+(Creative zum Thema DTS/Dolby)
+
+Selbst der finale Vista-Treiber wird nicht alle X-Fi-Funktionen von
+Windows XP unterstuetzen.
+(Creative zum Thema EAX)
+
+Microsoft behaelt sich vielmehr vor, das Betriebssystem bis hin zu
+Unbenutzbarkeit zu deaktivieren, wenn der Prozess [der Validierung]
+scheitert.
+(EULA*, Punkt 5)
+
+Daneben soll sich Vista generell regelmaessig mit Microsoft verbinden,
+ohne im Einzelfall den Benutzer auch nur davon zu unterrichten, und
+Informationen ueber den PC und die installierte Software uebermitteln.
+(EULA*, Punkt 7)
+
+Mit der Benutzung von Windows Vista stimmt man zu, dass Microsoft via
+Windows Defender ohne jede Nachfrage potenziell unerwuenschte Software
+vom Rechner entfernt, auch wenn dadurch andere Software auf dem Computer
+nicht mehr funktioniert [...] Das kann durchaus auch Software betreffen,
+die vom Benutzer gar nicht unerwuenscht ist.
+(EULA*, Punkt 6)
+
+*Microsofts Endbenutzer-Lizenzvertrag
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Winbloed Vista (Kellybundy,  3. Mar 2007, 16:05:00):
+~#! rn=Amaryllis rt=1172914928 rg=schmarrn.netdigest
+~#! tid=1172914928
+Das geld, das M$ Europa den Benutzern aus der Tasche leiert, werden sie auch
+brauchen, bei den anstehenden Millionenklagen seitens der EU-Kartellbehoerde.
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Winbloed Vista (Orktoeter,  3. Mar 2007, 16:18:51):
+~#! rn=Kellybundy rt=1172934300 rg=schmarrn.netdigest
+~#! tid=1172914928
+Bei dem Preis und der Gewinnmarge die die haben zahlen die selbst so eine 0,5
+Mrd Euro Strafe aus der Portokasse.
+
+Habe letztens gelesen sie wollen den Support fuer Vista schon vor dem
+Sopportende von XP einstellen, kann das wer bestaetigen? Gibt es IRGENDEINEN
+vernuenftigen Grund sich Vista zu besorgen?
+
+OrkT.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Winbloed Vista (Grimmborn,  3. Mar 2007, 16:59:58):
+~#! rn=Orktoeter rt=1172935131 rg=schmarrn.netdigest
+~#! tid=1172914928
+Klar gibts den: Neuer ist besser!
+
+GdA
+
+-----------------------------------------------------------------------------
+
+
+
+Korrektes Deutsch? (Ronda,  5. Mar 2007, 21:27:11):
+Hm... wer also "viertel zwoelf" sagt, wird bestraft? Zum Beispiel, indem er in
+Bayern oder Oesterreich leben muss? Habe ich das richtig verstanden?
+
+Ronda
+
+Subject: Re: "Viertel zwoelf?" korrektes Deutsch?
+From: Michael Baumgartner <michaelsusenet@hotmail.com>
+Date: Fri, 2 Mar 2007 12:52:19 +0100
+Message-ID: <38a6hqr6zfb0.1e1ykd9ur94vj.dlg@40tude.net>
+Newsgroups: de.etc.sprache.deutsch
+
+Am Fri, 2 Mar 2007 12:18:52 +0100 schrieb Bernd Pietsch:
+
+> > Hallo,
+> > der deutsch Sprachraum  scheint ja geteilt, was die Uhrzeit angeht.
+> > Korrekt sagt man ja: "viertel nach elf".
+> > Bayern und Oesterreich sagen aber "viertel zwoelf".
+> > Die erste Variante ist sicherlich korrektes Hochdeutsch.
+> > Ist es aber auch die zweite und zwar in Deutschland? Oder duerfte man das
+> > hier nicht so schreiben?
+
+Nein. 135 StGB Absatz 2 Satz 1-2:
+Wer Zeitangaben muendlich oder schriftlich in anderer Weise als in der
+Bundeszeitangabenverordnung vorgeschrieben macht, wird mit
+Freiheitsstrafe bis zu einem Jahr oder mit Geldstrafe bestraft.
+Zusaetzlich kann ein befristetes Sprechverbot verhaengt werden.
+
+Gruss,Michael
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Korrektes Deutsch? (Justavius,  6. Mar 2007, 18:00:08):
+~#! rn=Ronda rt=1173126431 rg=schmarrn.netdigest
+~#! tid=1173126431
+viertel zwoelf etc. gibts nur im wiener raum ...
+der rest von oesterreich sagt schoen brav 1/4 nach 11
+
+just, kein wiener
+
+-----------------------------------------------------------------------------
+
+
+
+Sichere Passwoerter... (Amaryllis,  6. Mar 2007, 23:13:18):
+
+From: Oliver Schad <o.schad@web.de>
+Subject: Re: sichere Passwoerter erzeugen ...
+Newsgroups: de.comp.security.misc
+Date: Mon, 05 Mar 2007 12:32:05 +0100
+Message-Id: <552ddlF22itl2U1@mid.dfncis.de>
+
+Mark Riemann (castle) schrieb:
+
+> ich glaube hier mal irgendwo gelesen zu haben, dass es Programme,
+> oder Webseiten gibt, wo man sich lange kryptische
+> Schluessel/Passwoerter erzeugen lassen kann, um bspw. die
+> Datenuebertragung auf einer WLAN Strecke (WPA2) abzusichern.
+>
+> Ich finde das nicht mehr. Hat hierfuer jemand einen Tip?
+
+Katze an 230V verkabeln und ueber der Tastatur arretieren, im Suff eine
+E-Mail schreiben oder aber einen oeffentlich bekannten Text von einem
+deutschen Schueler abschreiben lassen - gibt alles genug verwendbares
+Schluesselmaterial.
+
+mfg
+Oli
+
+--
+Man darf ruhig intelligent sein, man muss sich nur zu helfen wissen.
+
+
+-----------------------------------------------------------------------------
+
+
+
+Scheiss Kalauer (Ronda, 14. Mar 2007, 19:52:49):
+Message-ID: <t1672dz70z13.dlg@www.theodor-rieh.de>
+From: Wolfram Heinrich <theodor.rieh@freenet.de>
+Newsgroups: de.etc.sprache.deutsch
+Subject: Re: "zweimal weniger"
+Date: Tue, 13 Mar 2007 14:04:08 +0100
+
+Am Tue, 13 Mar 2007 13:16:16 +0100 schrieb Martin Bodenstedt:
+
+> > Volker Gringmuth schrieb:
+> > 
+>> >> Tschuljunk, aber jetzt muss der hier kommen: Heute morgen hatten wir 
+>> >> 0 C - morgen soll es doppelt so kalt werden.
+> > 
+> > Also 00 C?
+
+Eine Scheisskaelte halt.
+
+Ciao
+Wolfram
+
+-----------------------------------------------------------------------------
+
+
+
+Akzeptable Verzoegerung beim Telefonieren (Ronda, 22. Mar 2007, 19:18:51):
+Hm. Also ich glaube die akzeptable Verzoegerung liegt eher so um zwei Minuten.
+Zumindest bei Telefonaten mit meiner Mutter. Nach der Zeit wird sie dann meist
+irgendwann aufmerksam, warum ich nicht mehr "hmmm" mache.
+
+Ronda
+
+[Vom Einreicher auf einen hervorzuhebenden Teil gekuerzt, was nicht
+heisst, dass das Original nicht in seiner Gesamtheit interessant zu
+lesen ist. Es geht darum, welche Verzoegerungen bei der Audiouebertragung
+zu telefonischen Zwecken noch unbemerkt bleibt/tolerabel ist.]
+
+From: Oliver Bartels <spamtrap@bartels.de>
+Newsgroups: de.comm.internet.infrastruktur
+Subject: Re: Suuuper Artikel auf heise.de
+Date: Sun, 18 Mar 2007 20:44:08 +0100
+Reply-To: obartels@bartels.de
+Message-ID: <8g4rv21b9gqclagjon58spe11uvgq3cadr@4ax.com>
+
+On Sun, 18 Mar 2007 19:36:52 +0100, Carsten Krueger
+<use.net.cakruege@neverbox.com> wrote:
+> >Nein, die liegt so bei 120ms.
+
+Mag sein.
+
+Vielleicht wurde die Studie aber auch an harten "Wummer
+Scheppa Wumma" Disse-Besuchern nach dem Genuss
+von mindestens drei Alkopops gemacht.
+
+"Was jammert ihr eigentlich, selbst junge Kunden mit dem
+bekanntlich besten Gehoer (heuchel) haben mit der VoIP-
+Qualitaet kein Problem" ;-/
+
+[...]
+
+Gruss Oliver
+
+-----------------------------------------------------------------------------
+
+
+
+Schuhe (Ronda, 25. Mar 2007, 17:57:19):
+Also mir stinken solche Artikel ja irgendwie. Aber na gut...
+
+Ronda
+
+From: Oliver Cromm <lispamateur@yahoo.de>
+Subject: Re: STinkendst
+Newsgroups: de.etc.sprache.deutsch
+Date:Wed, 21 Mar 2007 12:14:24 -0400
+Message-ID: <1hqp0u0czx1r1.dlg@ocromm.my-fqdn.de>
+
+> > SpOn erzaehlt gerade etwas ueber "Amerikas stinkendstes Paar Schuhe".
+ 
+> > Rebelliert Euer Logikgefuehl ebenso wie meines? Meine Schuhe koennen 
+> > schlimmer stinken als Deine, aber koennen sie stinkender sein?
+
+Mein Logikmodul bleibt ganz ruhig, mein Grammatikmodul fiepst leise.
+
+-----------------------------------------------------------------------------
+
+
+
+Schokoladenschaumkuss (Ronda, 25. Mar 2007, 18:15:13):
+[Notiz des Einreichers: anonymisiertes firmeninternes Fundstueck]
+
+Newsgroups: xxxxxx.infoboerse
+Subject: Re: Schokoladenschaumkuss?
+From: $NAME <$ADRESSE@xxxxxx>
+Date: Thu, 22 Mar 2007 13:31:04 +0100
+Message-ID: <ettsu9$cr$1@news.xxxxxx.de>
+
+$VORREDNER wrote:
+> > Hallo Kollegen,
+> > 
+> > Heute aufm Speiseplan als Dessert:
+> > "Schokoladenschaumkuss".
+> > 
+> > Also, auch wenn "Negerkuss" politisch nicht mehr korrekt ist,
+> > sollte man doch Bezeichnungen waehlen, die die Sache
+> > halbwegs richtig beschreiben. Aus Schokoladenschaum
+> > isses naemlich net (.. hoffe ich zumindest).
+
+Scholokadenschaumwaffel mit Migrationshintergrund?
+
+-----------------------------------------------------------------------------
+
+
+
+Getrennt Schreibung (Ronda, 26. Mar 2007, 22:10:59):
+From: Andreas Kabel <andreas.kabel@gmail.com>
+Newsgroups: de.etc.sprache.deutsch
+Subject: Re: Getrennt Schreibung des Tages
+Date: Sun, 25 Mar 2007 11:10:59 -0700
+Message-ID: <86y7llry6k.fsf@penguin.slac.stanford.edu>
+
+Oliver Voss <voss.oliver@t-online.de> writes:
+
+> > Ich habe heute bei einem Elektroladen ein huebsches Schild entdeckt:
+> > "Alarm und Video ueberwacht". Schoen, die ueberwachen also den Alarm und
+> > das Video, gut zu wissen.
+
+Aehnlich die Kreissparkasse Suedholstein mit Subjectheadern der Form
+"$Subject -- Viren geprueft". Da macht sich offenbar jemand die Muehe,
+die Viren vor dem Versand nochmal auf einwandfreie Funktion zu uebepruefen.
+
+-----------------------------------------------------------------------------
+
+
+
+Mit Toten Hosen in den Feierabend (Ronda, 26. Mar 2007, 22:20:21):
+Subject: Re: abschiedslieder
+Date: Sun, 25 Mar 2007 14:44:24 +0200
+From: "Nati 'Albdreamgirl' Husar" <sina26@gmx.at>
+Newsgroups: de.rec.musik.recherche
+Message-ID: <ada0$46066ea3$5341f10c$6737@news.inode.at>
+
+[SN: Quoting ergaenzt]
+
+"Stephan Goesling" <goesling@gmx.de> schrieb
+
+> > Nati 'Albdreamgirl' Husar schrieb:
+> > 
+>> > > hoffe, das ist die richtige NG dafuer. Brauche fuer meine Filiale
+lieder die 
+>> > > wir kurz vor Ladenschluss anspielen koennten( um die Leute aufmerksam
+zu 
+>> > > machen, das sie jetzt heimgehen sollen*g*). Beim Ikea verwenden die
+dafuer 
+>> > > das "Wer hat an der Uhr gedreht"; moecht ich aber nicht nachmachen.
+> > 
+> > Was habt ihr denn fuer eine Kundenstruktur?
+> > Die Toten Hosen "Schoenen Gruss, Auf Wiedersehn" sind nicht jedermanns 
+> > Sache.
+
+Nunja, Beate Uhse Shop:-)
+
+Lg
+Nati
+
+-----------------------------------------------------------------------------
+
+
+
+Jetzt fehlt nur noch... (Ronda, 26. Mar 2007, 22:21:31):
+... dass sie nach Bielefeld zieht, oder?
+
+Ronda
+
+From: Thomas Hochstein <thh@inter.net>
+Newsgroups: szaf.talk
+Subject: Re: Fruehere RAF-Terroristin Brigitte Mohnhaupt aus Haft entlassen
+Date: Sun, 25 Mar 2007 11:46:52 +0200
+Message-ID: <st.0703251146.1591@windlord.akallabeth.de>
+MIME-Version: 1.0
+Content-Type: text/plain; charset=iso-8859-1
+Content-Transfer-Encoding: quoted-printable
+
+Arcor Newsticker schrieb:
+
+> > 25.03.2007, 09:32 Uhr
+> >
+> >     Aichach (dpa) - Die fruehere RAF-Terroristin Brigitte Mohnhaupt
+> >   ist am fruehen Morgen aus der Haft entlassen worden. Frau
+> >   Mohnhaupt hat das Gefaengnis in Aichach zwischen 2.00 und 3.00
+> >   Uhr verlassen, sagte ein Sprecher des bayerischen
+> >   Justizministeriums.
+
+Was fuer eine offensichtliche Luege! Heute nacht zwischen 2 und 3 Uhr?
+Ha!
+
+-thh
+
+-----------------------------------------------------------------------------
+
+
+
+DB-Streckenplaene (Amaryllis, 27. Mar 2007, 00:47:35):
+Betreff: Re: Streckenplaene
+Absender: Helmut Barth <Helmut.Barth@arcor.de>
+Datum: Mon, 26 Mar 2007 17:34:12 +0200
+Newsgruppe: de.etc.bahn.misc
+Message-ID: <4607f571$0$6395$9b4e6d93@newsspool2.arcor-online.net>
+
+Salut!
+
+Dieter Bruegmann schrieb:
+
+> Da Didi, da bei Hin- und Rueckfahrt nach HH mal wieder zuverlaessig
+> Verspaetungen wg. Baustelle hatte und sich ueber die angesagten vier
+> Minuten wunderte, aus denen dann rund zehn Minuten wurden.
+
+Dann extra fuer dich eine kleine Interpretationshilfe fuer 
+Verspaetungsmeldungen:
+
+Anzeige/Ansage:                 Realitaet:
+-------------------------------------------------------------
+5 min Verspaetung wegen          Der Zug ist fast puenktlich
+$unbestimmtes Vorkommnis        (2-4 min)
+
+5 min Verspaetung wegen          Der Zug hat mehr als 5 min
+$genauer bestimmtes Ereignis    (normalerweise 8-9)
+
+10 min                          14 min
+12 min                          18 min
+15 min                          kann 18 min sein, oder auch 22
+                                ist abhaengig von der Tagesform des
+                                $Weichenschmierers in Kleinkleckersdorf
+                                nahe
+
+20 min                          mindestens 23 min, es sei denn
+                                die Ursache ist nicht naeher bestimmt
+                                denn dann kann der Zug durchaus bereits
+                                nach 17-18 min ueberraschend am Bstg.
+                                eintreffen.
+
+25 min                          mindestens 33 min (da hat mit Sicherheit
+                                wichtiger Taktverkehr dazwischengefunkt)
+
+30 min                          Gehe eine dreiviertel Stunde
+                                Kaffeetrinken
+
+45 min                          Suche nach Alternativen
+                                (zb. naechster Taktzug ..)
+
+60 min                          Wenn es nicht in der 2a Stunde des
+                                des letzten Oktobersonntags ist ->
+                                das dauert. Wenn es in der 2a Stunde
+                                ist, dauert es auch, aber es besteht
+                                Hoffnung auf puenktliche Abfahrt zur 2b
+                                Stunde
+
+100 min                         Angabe nicht vertrauenswuerdig, die bei
+                                der Bahn (vor allem bei der Schnellen)
+                                koennen gar nicht mit 3-stelligen Zahlen
+                                umgehen
+
+120 min                         Heute im Laufe des Tages, im Laufe der
+                                Nacht.
+
+Der Praktiker sagt uebrigens: einstellig ist plan, zweistellig leicht 
+verzoegert und dreistellig gilt als Verspaetung, letzteres allerdings nur 
+wenn von Stunden die Rede ist.
+
+Gruessle, Helmut
+
+P.S.: Die Anwendung der vorgenannten Informationen erfolgt 
+selbstverstaendlich auf eigenes Risiko und stellt keine offizielle 
+Information der DB dar .. in other Words: SCNR
+
+
+-- 
+Und wann wird diese Bescheinigung nicht geholt wenn man 'se tatsaechlich
+wirklich gebrauchen koennte - also mein Tip waere 'se zu holen wenn man
+'se dringender gebrauchen koennte als welche die 'se sich holen obwohl
+'se wirklich diese ohne wirklich zu gebrauchen sich holen wuerden?!
+
+
+
+-----------------------------------------------------------------------------
+
+
+
+Lost in Translation? (Ronda, 28. Mar 2007, 19:44:57):
+Message-ID: <k8gd03tv0m30bdrqib21vl5l31ofatapn3@4ax.com>
+From: Martin Gerdes <martin.gerdes@gmx.de>
+Newsgroups: de.etc.sprache.deutsch
+Subject: Re: Kultur, ist das die Lebensart?
+Date: Mon, 26 Mar 2007 00:00:07 +0200
+
+Ren <Kar98@The-Coalition.US> schrieb:
+
+>> >> Ich wuerde mir auf meinen Lieferwagen "Bad Service" nicht
+>> >> d'raufschreiben. Weiss nicht, ob er sich damit einen guten Dienst
+>> >> erweist. Schliesslich koennen die meisten Leute ja englisch...
+
+> >Weitertraeumen. In Bad Blankenburg, Thuer. Wald, direkt an der 
+> >Ortsausfahrt nach RU.-Schwarza, gibts, oder gab es einstmalen, einen 
+> >Klempnereifachmarkt namens Bad Design.
+
+Hierzustadt gabs auch einen Laden, der sich Bad Design nannte. Neulich bin
+ich zufaelligerweise wieder daran vorbeigekommen; das Lokal war leer, an den
+Schaufenstern hingen noch Anschlaege "Raeumungsverkauf wegen
+Geschaeftsaufgabe." 
+
+Wer weiss? Vielleicht koennen die Hannoveraner ja wirklich Englisch.
+Hinreichend historische Verbindung zum Land der Angelsachsen gibts ja.
+
+-----------------------------------------------------------------------------
+
+
+
+Prioritaeten. (Ronda, 28. Mar 2007, 19:45:37):
+From: Christoph Schmitz <christoph.schmitz2@post.rwth-aachen.de>
+Newsgroups: oecher.talk
+Subject: Re: Heiraten in und um Aachen
+Date: Mon, 26 Mar 2007 17:17:31 +0200
+Message-ID: <56q6gcF2as0obU1@mid.dfncis.de>
+
+Sebastian Biallas wrote:
+> > Juergen Roesing wrote:
+
+>> >>Deine Aussage erinnert mich
+>> >>schwer an eine Verkaeuferin, die steif und fest behauptete, dass das
+>> >>wichtigste an einer Hochzeit ja wohl ohne Zweifel das Brautkleid waere.
+
+> > Und ein Anwalt wird Dir erzaehlen, dass das wichtigste an einer Hochzeit
+> > ja wohl ohne Zweifel der Ehevertrag ist ;)
+
+Das waere ein dummer Anwalt. An einer richtig
+heftigen Scheidung (die ja heutzutage auf jede
+dritte Ehe oder so folgt) koennen sich mehrere
+Anwaelte dumm und daemlich verdienen. Ueberhaupt
+kein Vergleich zu dem mageren Honorar fuer das
+Aufsetzen eines Ehevertrages, der dann zu einer
+problemlosen Scheidung (wo es nix zu verdienen
+gibt) fuehrt.
+Aber ich finde es auch sehr wichtig, dass die
+Farbe der Kirche zu den Brautschuhen passt. Die
+wichtigste Voraussetzung fuer eine perfekte Ehe
+ist bekanntlich eine perfekte Hochzeit.
+
+Christoph
+
+-----------------------------------------------------------------------------
+
+
+
+Karfreitagsschmarrnpost (am Ostermontag) (Ronda,  9. Apr 2007, 02:37:37):
+[Moderator's note: Heute == Karfreitag.]
+
+Subject: Das passende Programm zum passenden Anlass
+Date: Fri, 6 Apr 2007 20:03:23 +0200
+From: Rene Fuchs <refu@digitalgemuese.de>
+Newsgroups: de.rec.tv.misc
+Message-ID: <15v527r8z28hd.dlg@news.digitalgemuese.de>
+
+Ich moechte einfach mal die kreativen Programmplaner loben. Heute zur
+Prime-Time hat man die Wahl u.a. zwischen "Ghost Whisperer - Stimmen aus
+dem Jenseits" (kabel eins), "Crossing Jordan - Pathologin mit Profil"
+(Vox), "Und wenn sie nicht gestorben sind..." (rbb), "Nicht alle waren
+Moerder" (SWR), "Dune - Der Messias" (SciFi), "Killer Instinct" (Planet),
+"koerper & seele" (ZDFInfo) oder auch "Freunde - Das Leben geht weiter"
+(VIVA).
+
+Nur Pro7 ist der Zeit mit "Shrek 2 - Der tollkuehne Held kehrt zurueck"
+leider ein paar Tage voraus.
+
+Ren
+
+-----------------------------------------------------------------------------
+
+
+
+Da koennte... (Ronda,  9. Apr 2007, 02:40:51):
+... auch ein Gott Spass daran gehabt haben, eine Mail zu schreiben... oder?
+
+Ronda *auch Goetter purzeln leider manchmal laut bruellend aus dem Olymp*
+
+[Michael hatte bei der Verkehrswacht einfach nur nach der Herkunft der 
+Zahlen in einer Pro-Helm-Broschuere gefragt]
+
+From: Ervin Peters <ervin.peters@ervnet.de>
+Newsgroups: de.rec.fahrrad
+Subject: Re: Antwort der Verkehrswacht zu "Helmi"
+Date: Thu, 5 Apr 2007 17:44:06 +0200
+Message-ID: <pan.2007.04.05.15.44.05@ervnet.de>
+
+Mathias Boewe am Thu, 05 Apr 2007 16:20:43 +0200:
+
+> > Michael Schebaum <michaels11@gmx.de> zitierte:
+> > 
+>> >> "Leider schreiben Sie nicht, was das Motiv fuer Ihre Anfrage ist. Ich
+>> >> kann daher nicht speziell auf Ihre Belange eingehen, werde aber
+>> >> versuchen, Ihnen einen Ueberblick ueber die Thematik zu geben.
+> > 
+> > Was hat die Motivation einer Anfrage mit der Quelle nackter Zahlen zu
+> > tun?
+
+Nichts. Aber Werbefuzzis, Glaubensverbreitern und Verkaeufern geht es
+nicht um die Realitaet nach wissenschaftlichen Kriterien sondern die
+gefuehlte individuelle Realitaet und darum sie in Ihrem Sinne zu
+beeiflussen. Deshalb stehen sie ziemlich auf dem Schlauch wenn es um
+etwas wissenschaftlich objektivierbares geht.
+
+Aber immerhin geben sie damit auch zu das keine Beleg dafuer existieren.
+
+ervin
+
+-----------------------------------------------------------------------------
+
+
+
+*HICKS!* (Ronda,  9. Apr 2007, 02:42:52):
+From: "Ralf P. Plank" <liebe70@arcor.de>
+Subject: Re: BR 120 geht in den Nahverkehr
+Newsgroups: de.etc.bahn.eisenbahntechnik
+Date: Mon, 2 Apr 2007 21:27:42 +0200
+Message-ID: <46115a37$0$15942$9b4e6d93@newsspool4.arcor-online.net>
+
+> > Am Mon, 02 Apr 2007 20:55:54 +0200 schrieb Jan Marco Funke:
+> >
+>> >> Wie auf
+>> >> <http://www.db.de/site/bahn/de/unternehmen/presse/presseinformationen/bb
+mv/bbmv20070402.html>
+>> >> zu lesen ist, will die DB auf der Strecke Rostock - Schwerin - Hamburg
+> >
+> > Ich habe es dreimal lesen muessen, aber scheinbar steht das wirklich da:
+> >
+> > | Die Dostos sind die Leistungstraeger im Nahverkehr. Der Komfort der
+> > | Fahrzeuge wird von den Reisenden sehr geschaetzt. Die eingesetzten Wagen
+> > | sind energieeffizient und damit umweltfreundlich. Auf 100 Kilometer
+> > | benoetigen sie pro Reisenden bei rund 50 Prozent Auslastung umgerechnet
+> > | lediglich 1,8 Liter Sprit.
+> >            ^^^^^^^^^^^^^^^
+> > Fuer was benoetigen die Doppelstockwagen Kraftstoff bzw. Alkohol?
+
+ Nicht fuer was, sondern fuer wen! Fuer die "Serviceorientierten
+Zugbegleiter" 
+natuerlich. Manches laesst sich eben nur noch aushalten, wenn man schon einen
+gut 
+in der Krone hat... ;-)
+
+Gruss, Ralf 
+
+-----------------------------------------------------------------------------
+
+
+
+Plusquamperfekt oder so (Ronda,  9. Apr 2007, 02:46:52):
+Also ich haette die letzten Tage gern mindestens fuenf Helme gehabt haben
+wollen... das ist doch auch nach neuer Rechtschreibung noch Plusquamperfekt,
+oder?
+
+Ronda *hat Bammel. Und wie!*
+
+From: Walter Jann <jehova@weibsvolk.org>
+Newsgroups: de.rec.fahrrad
+Subject: Re: Das uebliche zum Saisonstart: heute Zitty
+Date: Tue, 03 Apr 2007 12:10:07 +0200
+Message-ID: <qu84131hee2v5h78d0k3pve894d5opj3j6@4ax.com>
+
+Thomas Weiner schrieb:
+
+> >Im "Spezial Fahrrad" in der aktuellen Zitty findet sich das zu 
+> >erwartende, leider auch zum Helm:
+> >
+> >| Wahnsinnig sinnvoll
+> >| [Bla Bla zum schlechten Image]
+> >| Denn der Helm steht fuer Angst. Allerdings fuer berechtigte
+> >| Angst. Einer Sudie zufolge wird die Aufprallgeschwindigkeit
+> >| des Kopfes durch den Helm um 15 Stundenkilometer vermindert,
+> >| das Risiko, toedliche Verletzungen zu erleiden, ist 19 Mal
+> >| geringer. Vorgeschrieben ist der Helm allerdings nicht.
+> >
+
+Gestern hab ich beim Fahren noch mal ueber die 15 km/h
+Geschwindigkeitsverminderung nachgedacht.
+
+Irgendwie kommt mir das merkwuerdig vor.  :o)
+
+Wenn der Kopf eines Radfahrers stuerzt (es stuerzt ja nur der Kopf, der
+Radfahrer selbst bleibt natuerlich auf dem Rad), woher merkt der Helm,
+dass der Kopf stuerzt, damit er die Geschwindigleit des stuerzenden Kopfes
+verringern kann? Und wie stellt der Helm fest, wann diese 15 km/h
+erreicht sind? Wie unterscheidet der Helm zwischen einem Sturz und einem
+schnellen Absteigen? Kann man ausschliessen, dass es eine Fehlfunktion
+gibt und der Helm z.B. beim Fahren ploetzlich die Geschwindigkeit des
+Kopfes verringert? Das koennte zu schwerwiegenden Verletzungen fuehren,
+wenn der Kopf durch den Helm ploetzlich um 15 km/h abgebremst wird, aber
+der Rest des Radfahrers weiter faehrt.
+
+Und wie genau laeuft diese Verzoegerung beim Sturz ab? Wird der Kopf kurz
+vor dem Aufprall um 15 km/h abgebremst? Oder faengt die Verzoegerung
+bereits beim Beginn des Sturzes an und steigert sich, so dass der Kopf
+dann langsam zu Boden schwebt?
+
+Was passiert, wenn man zwei Helme traegt? Addieren sich die 15 km/h pro
+Helm dann zu 30 km/h? Waere es somit denkbar, dass ein Fallschirmspringer
+mit einer ausreichenden Zahl Helme dann sicher aus einem Flugzeug
+springen kann?
+
+Und wie lange haelt diese wundersame Verzoegerungsfaehigkeit an? Ist die
+Batteriebetrieben? Wann muss mit einem Nachlassen der
+Verzoegerungsfunktion gerechnet werden und wie stellt man das rechtzeitig
+fest?
+
+Kann sich diese Funktion auch nachteilig auf die Geschwindigkeit des
+Radfahrers auswirken, so dass bei einer Geschwindigkeit unterhalb 15 km/h
+der Radfahrer rueckwaerts faehrt oder bei exakt 15 km/h Geschwindigkeit
+steht?
+
+Und was passiert, falls man den Helm unachtsamerweise falsch herum
+aufsetzt? Wird der Kopf dann beschleunigt?
+
+Wichtige Fragen, die von der Helmglaeubigenlobby noch zu beantworten
+sind.
+
+Walter
+
+-----------------------------------------------------------------------------
+
+
+
+Telekolleg Logistik I (Warensicherung - keine Ahnung, ob das jemand ohne drei Bier und Zurueck in die Zukunft II witzig findet) (Ronda,  9. Apr 2007, 02:56:02):
+From: Hans-Joachim Zierke <Usenetspam010@Zierke.com>
+Newsgroups: de.etc.bahn.misc
+Subject: Re: Unfallursache, was: Re: Chloressigsaeure in Tornesch
+
+
+Will Berghoff schrieb:
+
+
+> > Bevor hier weiter solch gefaehrlicher Unsinn geschrieben wird, empfehle 
+> > ich den Blick auf den Link, den Michael Rudolf bereitgestellt  hat.
+
+
+Statt hier herumzumaulen, solltest Du vielleicht erst einmal erklaeren,
+was genau Du nicht verstanden hast.
+
+
+
+
+Wenn es um richtig schwere Sachen geht, ob das nun Coils sind oder 
+andere Dinge, die dicht am massiven Stahlblock liegen, lautet das erste
+Grundprinzip der Ladungssicherung: "LKWs sind teuer, Kanthoelzer und 
+Naegel billig."
+
+Du moechtest damit erstens keine Punktlast, und zweitens keine 
+Linienlast. Das macht naemlich den LKW kaputt, siehe oben.
+
+Weiterhin kannst Du ein Coil nicht mit Gurten gegen Wegrollen sichern.
+Das Ding reisst Dir Deine Gurte locker durch und lacht Dich aus, wegen
+Doofheit. Mit Gurten kannst Du verhindern, dass das Ding bei Vibrationen
+in der Federung zu rappeln und dann alles kaputtzuschlagen beginnt, aber
+fuer die Wegrollsicherung wurde bereits vor langer Zeit das Kantholz 
+erfunden.
+
+
+Gehen wie also systematisch vor. Hier Dein LKW im Querschnitt:
+
+|                        |
+|                        |
+|                        |
+|________________________|
+
+Sieht man doch, dass das ein LKW ist.
+
+Die einfachste Idee ist, mehrere Kanthoelzer quer in den LKW zu legen, 
+und zwar muss die Laenge der Innenbreite des Behaelters fast entsprechen. 
+Sagen wir mal, Du nimmst 8 davon (haengt alles von Groesse und Gewicht des
+Coils ab), und natuerlich nimmst Du richtige Kanthoelzer und keine 
+Zaunlatten. Bittesehr, 8 Kanthoelzer:
+
+|                        |
+|                        |
+|________________________|
+|________________________|
+
+Sieht man doch, dass das 8 hintereinander sind.
+
+Wenn Du jetzt ein Coil da draufpackst, wirst Du zu Deinem Bedauern 
+feststellen, dass das schwere Ding die Kanthoelzer zusammenmatscht. Dann
+biegen die sich, oder entlasten zumindest die Enden, und Du hast
+8 Punktlasten, statt etwas verteilt zu haben.
+
+Ausserdem kann das Coil beliebig wegrollen, und wenn Du das Ding mit 
+Gurten sichern willst, lacht es Dich aus.
+
+Also nagelst Du rechts und links Keile auf Deine Kanthoelzer, und zwar
+so, dass Dein Coil nicht mehr auf dem Bodenholz aufliegt:
+
+|                        |
+|         _    _         |
+|________|_\__/_|________|
+|________________________|
+
+Sieht man doch, dass das 16 Keile sind.
+
+Das ist schon viel besser, weil jetzt Deine unteren 8 Kanthoelzer schoen 
+gerade liegenbleiben und auf einer betraechtlichen Laenge Kraft 
+uebertragen.
+Leider stellst Du aber fest, dass Deine Keile ziemlich gequetscht werden,
+und dass Du die Sache ausserhalb einer Werkstatt, auf einem LKW nicht 
+genau genug hingenagelt kriegst. Dein Coil schiebt erst einen Keil weg,
+dann den naechsten, und verruckelt ausserdem dabei Deine 8 Kanthoelzer.
+Also ersetzt Du die vielen Keile durch zwei abgeschraegte Kanthoelzer.
+Das geht auch viel schneller.
+
+|                        |
+|         _    _         |
+|________|_\__/_|________|
+|________________________|
+
+Sieht man doch, dass das jetzt nicht mehr 16 Keile, sondern 2 seitlich
+abgeschraegte Kanthoelzer sind.
+
+Damit hast Du jetzt 2 Linienlasten, die vernuenftig eingeleitet und
+grossflaechig uebertragen werden. Ausserdem hast Du Deine 8 Kanthoelzer zu 
+einer soliden Leiter zusammengefuegt. Damit koenntest Du unter Umstaenden
+vorsichtig um den Block fahren, ohne grosses Risiko einzugehen. Im 
+richtigen Leben gibt es aber jede Menge Kurven, Schlagloecher, und 
+wasweissich. Binnen ziemlich kurzer Frist wird sich Dein Coil um Deine
+Verbindung zwischen den 2 Laengskanthoelzern und den 8 Bodenhoelzern 
+gekuemmert haben: Naegel verbogen, Schrauben gebrochen ... Das Ding ist
+nun mal eklig schwer, und zeigt duennem Metall den Stinkefinger.
+
+Also musst Du Deine Laengskanthoelzer solide abstuetzen. Das machst Du mit
+16 kuerzeren Kanthoelzern.
+
+|                        |
+|__________    __________|
+|________|_\__/_|________|
+|________________________|
+
+Sieht man doch, dass das 16 kurze Kanthoelzer sind.
+
+Das sieht schon richtig gut aus. Bei grossem Coildurchmesser kommen da
+noch Keile obendrauf, sonst kannst Du jetzt zurren. Merke: Auf sich 
+allein gestellt, ist der Zurrgurt ein Witz, aber zusammen mit dem Keil,
+aeh, Laengskantholz davor durchaus coil-beeindruckend.
+
+Wenn Du an Murphy glaubst, nagelst Du ausserdem noch Laengslatten drauf an
+den Enden. Die muessen nicht dick sein.
+
+|                        |
+|-_________    _________-|
+|________|_\__/_|________|
+|________________________|
+
+Aber wenn doch irgendetwas knackseln sollte, haelt das den Kladderadatsch
+in Form.
+
+
+Gut, jetzt hast Du eine halbe Stunde gebraucht, um eine einzige dumme
+Rolle zu laden, wischst Dir den Schweiss ab und weisst, warum, wer so 
+etwas staendig faehrt, lieber Spezialbehaelter nimmt dafuer. Oder auch, 
+warum Klamottenkutscher lieber pfuschen dabei.
+
+Dein Vorteil: Coils werden eigentlich nur dort verladen, wo staendig
+Coils verladen werden. Das notwendige Geruempel liegt also schon fertig
+zugeschnitten herum in der Regel, und es laufen dort Leute herum, die
+wissen, wie es geht.
+
+
+
+So, mein Herr, jetzt kannst Du weitermaulen.
+
+
+
+Hans-Joachim
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Plusquamperfekt oder so (Gloinson,  9. Apr 2007, 03:40:18):
+~#! rn=Ronda rt=1176079612 rg=schmarrn.netdigest
+~#! tid=1176079612
+Jemand der "Helmglaeubigenlobby" schreibt ist ohnehin mit dem Klammerbeutel
+gepudert worden.
+
+
+-----------------------------------------------------------------------------
+
+
+
+Einheitliches Rauchverbot in Gaststaetten (Ronda, 11. Apr 2007, 00:12:36):
+From: Dirk Schneider <spam_scd603@gmx.de>
+Subject: Re: Leerzeichensetzung und Klein-Grossschreibung
+Newsgroups: de.etc.sprache.deutsch
+Date:Mon, 09 Apr 2007 13:48:38 +0200
+Message-ID: <evd91t$u31$00$1@news.t-online.com>
+
+Endlich ein einheitliches Rauchverbot in Gaststaetten!!! 1) 2) 3) 4) 5) 6). 
+
+  1) Gilt nach 22 Uhr nur in NW, BW, BY u. HH. 
+  2) Gilt in B, NS nur ueber 66 qm. 
+  3) Gilt nicht in Ecklokalen. 
+  4) In NW Einr. ausg. R. m. Kennz. "R" zul. 
+  5) MV entf. 
+  6) Ausgen. Muenchen i.d.Z. vom 1.5. bis 31.8.
+
+-----------------------------------------------------------------------------
+
+
+
+Peinlich... (Amaryllis, 11. Apr 2007, 21:07:33):
+
+From: Richard Blume <richard@radbasteln.de>
+Subject: Peinlich...
+Newsgroups: de.rec.fahrrad
+Date: Tue, 10 Apr 2007 19:52:59 +0200
+Message-ID: <evgifs$r6q$01$1@news.t-online.com>
+
+Kurt Fischer <Imogkoanspam@web.de> schrub:
+
+> Hupen - wobei in diesem Zusammenhang darunter eher ein kurzes
+> Antippen der Hupe zu verstehen ist - als hilfreich gedachtes
+> Signal gemeint war:
+
+Mir geschah vor etwa 2 Wochen, dass ich auf Kopfsteinpflaster vor mich hin
+hueserte, Gegenwind und die Zunge flatterte in eben jenem. Von hinten
+Hupen, ich werde sofort sauer, dreh mich um, guck boese, zieh ein bisserle
+mehr Richtung Strassenmitte... Huphuphup. Okay, das weckt natuerlich den
+Wolf im Manne, also mittig der Fahrbahn angehalten. Der (Bauarbeiter)-
+Kleintransporter zieht nach, bleibt stehen, die Scheibe wird
+runtergedreht....
+
+"Sie haben da hinten ihre Zigaretten verloren, sie muessen nochmal
+zurueckfahren.".
+
+Ui.... aehhh... bedankt und rotbaeckig umgedreht. Die Welt ist schlecht.
+Meistens jedenfalls.
+
+-----------------------------------------------------------------------------
+
+
+
+Gilt das auch fuer die MPA? (AUA!) (Ronda, 12. Apr 2007, 11:19:07):
+From: Enrico Bauer <Henniku@expires-31-03-2007.news-group.org>
+Subject: Re: Kleines Erziehungsproblem - 2 Jahre Sohn hat    Spass am Tueren
+rummsen
+Newsgroups: de.soc.familie.kinder
+Date: Wed, 11 Apr 2007 08:10:51 +0200
+Message-ID: <110407.081051.dsfk.238@ID-5349.user.uni-berlin.de>
+
+10.04.2007 22:35:56, *Friedrich Bartel*:
+> > Da hilft nur der, die Tuer hat Aua und ist traurig Trick.
+> > Checkt der Bub das nicht, eins auf die Finger das er heult und sagen,
+> > das ist Aua. [...]
+> > Sollte dass nicht greifen, Arsch versohlen, wenn er wieder die Tueren
+> > knallt und erklaren das die Tueren jetzt alle Aua haben.
+
+Ich gehe mal davon aus, dass du nicht aufhoerst, Bloedsinn zu posten, weil
+ich dir sage, dass das Usenet davon Aua hat, richtig? Kommen wir nun zu
+Phase 2 ...
+
+-----------------------------------------------------------------------------
+
+
+
+Nix fuer Segler (sorry, J :-) ) (Ronda, 15. Apr 2007, 09:54:42):
+From: Ren <Kar98@The-Coalition.US>
+Subject: [de.etc.fahrzeug.auto] Re: Gebrauchtwagenkauf, worauf sollte man
+alles achten?
+Newsgroups: de.etc.fahrzeug.auto
+Date: Fri, 13 Apr 2007 23:15:10 GMT
+Message-id: <news:2007041318151075249-Kar98@TheCoalitionUS>
+
+On 2007-04-13 16:43:32 -0500, Frank Kemper <samplerama@googlemail.com> said:
+
+> > Thomas Dreher wrote:
+> >
+>> >> Nein. Du willst immer und immer wieder de gleich Frage debattieren: "Ich
+>> >> will nen V8 und hab kein Geld. Bitte sagt mir, dass ein alter V8 ein
+>> >> vernuenftiges, sparsames Auto ist!"
+> >
+> > Als ich meinen Segelschein machte, kam auch die Frage nach einem
+> > eigenen Boot (oder eher einer kleinen Yacht) auf. Der Segellehrer sagte
+> > uns: "Stattdessen koennen Sie sich auch an den Starnberger See stellen
+> > und Hundertmarkscheine zerreissen, das ist genauso teuer"
+
+Ein Boot ist ein Loch im Wasser, mit Holz drum rum, in das man Geld wirft.
+In anderen Worten: if it flies, fucks or floats, you're better off
+renting than buying.
+
+-----------------------------------------------------------------------------
+
+
+
+Elektronische Unterschrift (Ronda, 17. Apr 2007, 22:01:15):
+[SN: Anm.: Adresse durch G00gle zerbombt.]
+
+From: Volker Gringmuth <einkl...@gmx.net>
+Newsgroups: de.etc.sprache.deutsch
+Subject: Re: =?Iso-8859-1?Q?Bu=DFgeldbescheid?=
+Message-ID: <Xns99106A66AC0B3bx@h2.einklich.net>
+
+G.O.Tuhls wrote:
+
+> > Dieses Posting gilt auch ohne Unterschrift, weil es mit einem
+> > Computer erstellt wurde.
+
+Furchtbar, dieses Gossendeutsch. 
+
+"Infolge des hiermit rechtskraeftig beurkundeten Tatbestandes der 
+Erfolgtheit des Erstellens dieses Schreibens unter Zuhilfenahme einer 
+elektronischen Datenverarbeitungseinrichtung bedarf ihre Gueltigkeit 
+nicht der Notwendigkeit zu einer von Hand auszufertigenden Signatur" 
+waere stilistisch das absolute Minimum.
+
+
+vG
+
+-----------------------------------------------------------------------------
+
+
+
+Maslow (Ronda, 17. Apr 2007, 22:12:25):
+Irgendwie erinnert mich das an die Beduerfnispyramide von Herrn Maslow...
+
+Ronda
+
+From: Andreas Karrer <ak-7b@gmx.ch>
+Subject: Re: Bussgeldbescheid
+Newsgroups: de.etc.sprache.deutsch
+Date: 12 Apr 2007 06:33:33 GMT
+Message-ID: <slrnf1rklt.a8o.ak-7b@chimborazo.ee.ethz.ch>
+
+* Holger Hirschfeld <hirschfeld@gmx.de>:
+
+> > "Sie ueberschritten die zulaessige Hoechstgeschwindigkeit ... um 29 km/h.
+> > Zulaessige Geschwindigkeit: 60 km/h
+> > festgestellte Geschwindigkeit (abzgl. Toleranz): 89 Km/h."
+
+In der Schweiz waerst du den Schein drei Monate los, die Bussgeld betruege
+etwa 1000 EUR, dazu administrative Gebuehren in etwa gleicher Hoehe und
+*DU* beklagst dich ueber Rechtschreibung :-)
+
+-----------------------------------------------------------------------------
+
+
+
+Gleichsetzung? (Ronda, 21. Apr 2007, 12:48:59):
+... da hier in schmarrn.netdigest kaum wer schreibt, liest das hier doch auch
+keiner.
+
+Ronda
+
+Message-ID: <1p6ucv6l8rdmd$.dlg@ocromm.my-fqdn.de>
+From: Oliver Cromm <lispamateur@yahoo.de>
+Newsgroups: de.admin.news.groups
+Subject: Re: 1. RfD zur Entfernung von de.etc.lists
+Date: Tue, 17 Apr 2007 18:25:00 -0400
+
+* Roman Racine wrote:
+
+> > de.etc.lists dagegen
+> > ist unmoderiert, so dass jeder Listen posten koennte. Tatsaechlich
+erscheinen
+> > aber jeden Monat dieselben automatisch geposteten Texte. Das deutet IMHO
+> > nicht darauf hin, dass da allzuviele Leute aktiv mitlesen.
+
+Ich war neulich in der Oper. Es hat niemand mitgesungen. Die haben
+wahrscheinlich alle gar nicht zugehoert.
+
+
+[Moderator's note: Aeusserst wuerdige Gleichsetzung. /Verbeugung und
+Kusshand, dann Abgang./ ;-)]
+
+-----------------------------------------------------------------------------
+
+
+
+Korrelation Typos-Breit. Was heisst das fuer MPA-Artikel? (Ronda, 25. Apr 2007, 22:52:35):
+From: Andy Angerer <parafrantic@web.de>
+Newsgroups: de.soc.drogen
+Subject: Re: [DP] Marihuana hat heute drei Mal mehr Wirkstoff als vor 15
+Jahren
+Date: Tue, 24 Apr 2007 15:18:59 +0200
+Message-ID: <clmr23dn7u6css2l736ejg7r9bij1tb40p@4ax.com>
+
+chris formulierte aufs eloquenteste:
+
+> > Man barucht nur ein drittel rauchen in Zweifelfalle, das ist gut.
+Ansonsten 
+> >fuer sich genommen ein weierer Propagandaversuch der sich gut in der Presse
+> >macht und jaehlich "NEU" entdeckt wird. Inzwischen muesste der Gehalt schon
+> >weit ueber 100% sein.
+> >Man nimmt halt ne Zug weniger ooder tut mehTabak rein. Fqlls derbKonsumet, 
+> >wenn er dan diese Hasch geaaet zu breit sein sollte kann er immer nochn 
+> >Notarztwagen rufen, aber immer schoeoeoeoen langsam :-).
+
+Erwischt: Du kiffst beim Posten!
+Man merkt richtig, wie Du von Zeile zu Zeile breiter wirst....
+
+ :-D
+
+-----------------------------------------------------------------------------
+
+
+
+Rap Raps. (Ronda, 25. Apr 2007, 22:53:43):
+From: Gunhild Simon <famsim2000@yahoo.de>
+Subject: Re: Genitiv von Rap
+Newsgroups: de.etc.sprache.deutsch
+Date: 23 Apr 2007 00:12:10 -0700
+Message-ID: <1177312330.746287.284730@l77g2000hsb.googlegroups.com>
+
+> > Laut Duden ist das eine wie das andere moeglich. Aber warum sollte "Die
+> > Sprache des Raps" missverstaendlich sein.
+
+Weil Raps eine Pflanze ist und man eine Dokumentation vermuten koennte
+ueber "Kommunikation in der Pflanzenwelt unter besonderer
+Beruecksichtigung monokultureller Sozialformen zur Foerderung des
+typischen Landschaftsbildes von Schleswig-Holstein, zur Erhaltung des
+Deutschen Imkerbundes und  zur Herstellung von Biokraftstoff, mehrfach
+ungesaettigten Pflanzenoels oder cholesterinspiegelsenkender Margarine".
+
+-----------------------------------------------------------------------------
+
+
+
+WoW! So was braucht man haeufiger! (Ronda, 27. Apr 2007, 22:28:40):
+... ok, Subject aus aktuellem Anlass gewaehlt.
+
+Ronda
+
+From: Joerg Dorchain <joerg@dorchain.net>
+Subject: Re: Kreislaufmittel...
+Message-ID: <f0n06f$7d1$1@piesbach.saarnet.de>
+Newsgroups: de.alt.sysadmin.recovery
+Date: Wed, 25 Apr 2007 07:32:32 +0000 (UTC)
+
+Falk Willberg <Faweglassenlk@falk-willberg.de> wrote:
+
+> > Jaja, ich hoerte schonmal, dass ich bei der GF gelegentlich den Eindruck
+> > erweckte, eine Katastrophe[1] nicht ernst zu nehmen, weil ich sie wie
+> > ein Problem behandle und ueber lieber eine Loesung nachdenke, statt
+> > aufgeregt hin- und herzurennen.
+
+In meinem ersten Job hatte ich einen EDV-Leiter kennengelernt. Der
+Mensch hatte BS200 gelernt, welche vor kurzem ersetzt wurde  und hatte
+die 60 schon ueberschritten. AIX wollte (und konnte) er nicht mehr
+lernen, war sozusagen auf Gnadenbrot.
+Als dann mal der schoene HACMP Cluster samt IBM-approved Portierung der
+BS2000 Anwendung die Graetsche machte, der fsck etwas laenger dauerte und
+auch Oracle nicht ganz freiwillig sofort hochfahren wollte, kamen nach
+ca 2min der Vorstandsvorsitzende der Holding und der Marktleiter rein und
+stimmten eine Art Regentanz um die Konsole an, an der ich sass und
+murmelten Dinge wie "10K Umsatz die Minute", "Eskalation",
+"Kassendatenbank", "Weltuntergang", "Wie lang das dauert" etc. Irgentwie
+hatte jener EDV-Leiter meinen Blick aufgefasst, sich die beiden Herren
+im teuren Zwirn am Schlafittchen (woertlich; ein Bild fuer Goetter) gepackt
+und mit den Worten "Halten wir unseren Kriegsrat doch draussen und lassen
+die Leute arbeiten" vor die Tuer bugsiert.
+
+Narrenfreihiet gepaart mit Erfahrung hat wirklich was fuer sich.
+
+Joerg
+
+-----------------------------------------------------------------------------
+
+
+
+650 Watt Netzteile im PC (Ronda, 30. Apr 2007, 18:55:27):
+[Moderator's note: Wer gleich nicht klicken mag, der rot13t spaeter das
+folgende, um zu erfahren, was sich hinter dem genannten Link verbirgt: 
+        Mvtnerggranamueaqre suee 5,25" (zvg Sbgb va rvarz Bayvar-Fubc).]
+
+From: Ulrich Gierschner <trashcan@wopr.de>
+Subject: 650 Watt Netzteile in PCs? Wofuer? DAFUeR!
+Newsgroups: ger.ct
+Date: Fri, 27 Apr 2007 10:56:09 +0200
+Message-ID: <4631baaa@news02.heise.de>
+
+Hi,
+
+Jaaa... wozu bei einem mit Cool'n'Quiet ausgestatteten Rechner und OnBoard
+GEForce 6100 ein 120 Watt Netzteil verbauen um Energie zu sparen? 
+Auch dorthinein kommen mindestens Werbewirksame 400 Watt - ach was, selbst
+angebliche 560 Watt Netzteile hab ich schon fuer weniger als 30 Euronen
+gesehen... Wofuer? Hierfuer vermutlich - vor allem, wenn man zwei oder drei
+davon einbauen moechte...:
+
+http://tinyurl.com/2v6o3a
+
+
+Ich wuerde lieeeeebend gerne mal die Support-Anfragen hoeren:
+
+TechCenter: "Hallo, mein Name ist xyu, wie kann ich Ihnen helfen?"
+
+Customer: "Hi, immer wenn ich mir eine Zigarrette anzuende, friert mein
+Computer ein..."
+
+TechCenter: "Aehem... Sind Sie sicher, das Ihre Rauchergewohnheiten mit dem
+einfrieren Ihres Rechenrs zusammenhaengen?"
+
+Customer: "Ja. Ganz sicher. Der Windows-Desktop ist oben... ich werde mir
+mal eine Anzuenden..."
+
+TechCenter: "..."
+
+Customer: "Klack! - Da! Schon wieder - [zieh_an_Zigarrette] - eingefroren,
+nichts geht mehr..."
+
+TechCenter: "...wir schicken einen Techniker 'raus..."
+
+-----------------------------------------------------------------------------
+
+
+
+Und wieder mal... (Ronda,  4. Mai 2007, 21:45:26):
+... ein Artikel, dessen Titel nichts mit dem Inhalt zu tun hat. Aber mir ist
+grad keiner eingefallen. Aber denen in der Newsgroup auch nicht. Oder die
+Erfahrungen die er beschreibt sind sehr lange her.
+
+Ronda
+
+Subject: Re: 1943
+From: Wolfram Heinrich <theodor.rieh@freenet.de>
+Date: Fri, 27 Apr 2007 14:38:59 +0200
+Message-ID: <124xn9ftoig3w.dlg@www.theodor-rieh.de>
+Newsgroups: de.etc.sprache.deutsch
+
+Am Fri, 27 Apr 2007 13:44:25 +0200 schrieb Jirka Klaue:
+
+> > Wolfram Heinrich:
+> > 
+>> > > Italien steht in dem Ruf, dass dort kein geparktes Auto sicher ist,
+weil es
+>> > > sofort aufgebrochen, ausgeraubt oder gleich ganz gestohlen wird.
+>> > > 
+>> > > Und dann machst du auf irgendeinem Parkplatz eine ganz merkwuerdige
+>> > > Beobachtung: Der auf - sagen wir mal: - 20 Plaetze ausgelegte Parkplatz
+ist
+>> > > von mindestens 30 Autos absolut und flaechendeckend zugeparkt. Keine
+Chance
+>> > > fuer die inneren Autos, da je wieder rauszukommen.
+>> > > 
+>> > > Nur: die Autos sind offen, der Schluessel steckt. Waehrend du noch
+dastehst
+>> > > und dich ueber diesen unglaublichen Leichtsinn wunderst (denn etliche
+der so
+>> > > leicht zu stehlenden Autos sind durchaus noch relativ neu und gut in
+>> > > Schuss), siehst du jemand kommen, der sich ein paar Sekunden lang die
+>> > > Situation betrachtet und dann in den hintersten Wagen einsteigt. Er
+faehrt
+>> > > ihn ein Stueck zurueck, schafft Raum. Dann steigt er in einen zweiten
+Wagen
+>> > > ein, faehrt auch diesen zurueck, steigt wieder in den ersten Wagen ein
+und
+>> > > stellt ihn dort hin, wo der zweite gestanden hatte.
+>> > > 
+>> > > Dann steigt er in den zweiten, seinen eigenen Wagen ein und faehrt
+davon.
+> > 
+> > Hab ich auch schon gehoert. Wenn Du das als Augenzeuge sagen kannst, will
+> > ich das mal glauben.
+
+Ja, hab ich eigenhaendig beobachtet. Und zumindest hier oben in 
+Castellabate lasse ich immer wieder mal die Schluessel stecken, wenn ich 
+beim Einkaufen bin.
+
+> > Andererseits wuerde ich meine Brieftasche trotzdem
+> > nicht im Auto lassen. Weder hier noch in Nordnordafrika.
+> > 
+Vor Jahren waren wir einmal in Bari, meine Frau wollte sich unbedingt 
+die Altstadt ansehen, ich riet dringend davon ab, denn im Reisefuehrer 
+stand, dass die Altstadt von Bari von scippatori nur so wimmele. Diese 
+scippatori grapschen dir in Windeseile Handtasche, Photoapparat etc. und 
+sind im Gassengewehr verschwunden, noch ehe du reagieren kannst.
+Meine Frau aber war optimistisch und also...
+Wir waren noch keine hundert Meter weit gekommen, als zwei Halbwuechsige 
+von vorne kamen, ein dritter von hinten, unauffaellig an der Wand 
+entlang. Meine Frau hatte in ihrer Umhaengetasche das ganze Geld, so dass 
+ich meine Aufmerksamkeit drauf konzentrierte. Und watsch und noch ehe 
+ich reagieren konnte, war der Typ von hinten auf mich zugerannt, hatte 
+mir die hintere Hosentasche, wo mein Geldbeutel steckte, aufgerissen und 
+war mit der Geldboerse, samt meinen saemtlichen Papieren auf und davon in 
+der naechsten Seitengasse verschwunden.
+Da stand ich nun, ein Hosenbein von der Arschbacke bis zu den Knoecheln
+aufgerissen und ohne Boerse. Die Hose war frueher mal eine sogenannte 
+"gute Hose" gewesen, Teil eines grauen Sommeranzugs, war inzwischen nur 
+noch auf den ganz ersten Blick als gute Hose erkennbar, ansonsten eher 
+verschmuddelt und mit kleinen Brandflecken von Zigaretten versehen. So 
+gesehen war der Schaden nicht gross, Geld war auch keins weg, ausser 
+vielleicht ein paar Mark in deutschen Muenzen.
+Aber die Ausweise!!! Das ganze Geschiss, die wiederzubekommen!!!
+Verdattert, unfaehig, uns zu bewegen, standen wir da, ueberlegten, ob es 
+Sinn haette, den Ueberfall anzuzeigen oder nicht. Wir waren noch zu keinem
+Ergebnis gekommen (wenn auch die Tendenz eher zu "nein" neigte), als 
+einer der Raeuber, vielleicht 15, 16 Jahre alt, aus der Seitengasse 
+zurueckkam, auf mich zuging und mir die Geldboerse mit einem "scusi" und 
+einigen Saetzen, die ich nicht verstand, zurueckgab.
+Sakra!
+Die Geldboerse erwies sich beim Pruefen als intakt, nichts fehlte.
+
+Ich kann die Strassenraeuber von Bari jedermann nur waermstens empfehlen.
+
+Ciao
+Wolfram
+
+-----------------------------------------------------------------------------
+
+
+
+Fuer Zesstra. (Ronda,  7. Mai 2007, 22:54:19):
+From: Juergen Gerkens <Gerkens@nurfuerspam.de>
+Newsgroups: de.rec.sport.fussball
+Subject: Re: Klose offenbar doch zu den Bayern
+Date: Wed, 2 May 2007 00:02:43 +0200
+Message-ID: <f18deq$10o$01$1@news.t-online.com>
+
+Annabelle Meyer haute in die Tasten:
+
+> > Immerhin hat sich die
+> > Geschaeftsfuehrung des SV Werder inzwischen oeffentlich darauf
+> > festgelegt, Klose nicht abzugeben. Da muessen schon gute Argumente
+> > ueber den Tisch wandern, damit die Herren ihre Ansicht aendern.
+
+Argument ist nur eine nette Umschreibung fuer zwei Ziffern mit
+mit sechs Nullen.
+
+Schoene Gruesse
+Juergen Gerkens
+
+-----------------------------------------------------------------------------
+
+
+
+Noch eins. Und nein, Zesstra hat kein Rad ab. (Ronda,  7. Mai 2007, 22:56:43):
+From: Martin Schuster <no.email@web.de>
+Newsgroups: de.etc.haushalt
+Subject: Re: Mikrowelle "explodiert" - Rat gesucht
+Date: Sat, 05 May 2007 16:57:49 +0200
+Message-ID: <f1i61a$d5e$01$1@news.t-online.com>
+
+
+Ralf Muschall schrieb:
+
+> > Das beste waren bisher die Waschhinweise auf einem T-Shirt.  Auf
+> > Englisch das uebliche (Temperatur usw.), auf Franzoesisch: "Es tut uns
+> > leid, dass unser Praesident so ein Idiot ist.  Wir haben nicht fuer ihn
+> > gestimmt."
+
+Ein gutes Stichwort. C&A laesst seit einigen Jahren in alle 
+(?)Kleidungsstuecke ein Etikett einnaehen mit der Aufschrift "Keep away 
+from fire".
+
+Mein all-time-Lieblingsbeispiel sind allerdings Schubkarrenreifen aus 
+Fernost, auf denen regelmaessig zu lesen steht, "Not for highway use".
+
+
+Gruss
+Martin
+
+-----------------------------------------------------------------------------
+
+
+
+Nicht fuer Zesstra. (Ronda,  7. Mai 2007, 22:58:04):
+From: Jens-Peter Schulze <jp.schulze@ginko.de>
+Newsgroups: de.comp.sys.mac.misc
+Subject: Re: Typische CPU-Auslastung bei USB-DVB-T-Empfaengern
+Date: Sat, 05 May 2007 07:49:35 +0200
+Message-ID: <5a2k7gF2m3m36U1@mid.individual.net>
+
+
+Guido Neitzer schrieb:
+> > amerikanisches (und kanadisches)
+> > Fernsehen ist noch schlechter und hat noch mehr Werbung als deutsches
+> > ....
+
+Das halte ich fuer absolut unmoeglich.
+
+Der Krankenstand in Deutschland ist nicht aus Sorge um den Arbeitsplatz
+auf dem Tiefststand.
+
+Alle die mal Krank waren und das Deutsche Vormittagsprogramm gesehen
+haben, gehen jetzt lieber mit dem Kopf unter dem Arm zur Arbeit.
+
+Vor allem die privaten stehen auf der Liste der verbotenen Kampfstoffe
+ganz oben.
+
+jens
+
+-----------------------------------------------------------------------------
+
+
+
+1live und der Swinger-Club (Ronda,  7. Mai 2007, 23:00:36):
+... aus der Newsgroup de.alt.soc.knigge. Man glaubt es kaum.
+
+Ronda
+
+Hans-Georg Bickel <hgbusenetmuell@gmx.de> writes:
+> >ram@zedat.fu-berlin.de (Stefan Ram) wrote:
+>> >>Sind Clubs wirklich Nachfolger von Discotheken oder
+>> >>existierten und existieren beide nebeneinander?
+> >Pah! "Discothek". Wie das schon klingt! Das sind die Brueder Gibb,
+> >Schlaghosen, Plateauschuhe, Foenfrisuren, Brusthaartoupets und
+> >Stehblues zu den Klaengen von Carlos Santana.
+> >Ein Club dagegen: Das sind k3wle Events zwischen Hiphop, House
+> >und New Rave. Natuerlich gepowert von abgefahrenen Deejays. Und
+> >wenn's zuviel wird, dann ist eine Chill-Out-Lounge angesagt.
+
+  Inzwischen habe ich noch bemerkt, dass es vor dem Aufkommen von
+  Discotheken bereits Clubs (oder Klubs) auf dem Gebiet der
+  heutigen Bundesrepublik Deutschland gab.
+
+  Damit waren Orte gemeint, an denen Kapellen spielten
+  (beispielsweise auch Beat) und an denen zur Musik getanzt
+  wurde. WIMRE berichtete auch Joy Flemming in solchen
+  aufgetreten zu sein, und beschwerte sich dann, dass die
+  Diskotheken spaeter dann keine Musikantenauftritte mehr
+  veranstalteten, sondern Musik aus der Konserve verwendeten.
+
+  Gerade las ich noch:
+
+      Frank vom Outlog hat bei einem Radio-Quiz auf 1live einen
+      tollen Preis gewonnen: Einen Monat freien Eintritt im Club
+      seiner Wahl. Der Gewinner hat sich fuer einen Swingerclub
+      entschieden. Nun meint 1live, unter Club sei keinesfalls
+      etwas anderes zu verstehen, als ein Musik- oder Tanzlokal,
+      welches man auch als "Diskothek" bezeichnen koennte, wenn
+      der Begriff nicht veraltet waere und daher fuer eine Nennung
+      auf dem up-to-daten Sender 1live nicht in Frage kaeme.
+
+http://wwwxra-blogxde/1706-Radiosender-uebervorteilt-Quizgewinner
+
+  (In der URI wurden von mir . durch x ersetzt.)
+
+
+-----------------------------------------------------------------------------
+
+
+
+Erster! (Mesirii,  8. Mai 2007, 02:34:50):
+Du hast 1 neuen Brief im Postamt liegen.
+[<MasteR>:Mesirii laesst die Ebene 'cpp' entstehen.]
+[<MasteR>:Mesirii laesst die Ebene 'ParaWarok' entstehen.]
+[<MasteR>:Mesirii laesst die Ebene 'fdo' entstehen.]
+[<MasteR>:Mesirii laesst die Ebene 'Nuernberg' entstehen.]
+[<MasteR>:IRC laesst die Ebene '#MG.DE' entstehen.]
+[<MasteR>:Mesirii laesst die Ebene 'TF' entstehen.]
+[<MasteR>:Mesirii laesst die Ebene 'megaschmarrn' entstehen.]
+[<MasteR>:Mesirii laesst die Ebene 'Baerenknochen' entstehen.]
+[<MasteR>:Mesirii laesst die Ebene 'Fraternitas' entstehen.]
+[<MasteR>:Mesirii laesst die Ebene 'Arks' entstehen.]
+% world history capacity changed to 10000 lines.
+[#MG.DE:#[MG] kommt an Bord.]
+[#MG.DE:#] [MG] apic Mr-Spock
+Reportmodus ist jetzt eingeschaltet.
+Vorsicht wird angezeigt.
+Du siehst saemtliche Angriffsmeldungen von Dir.
+[Allgemein:Mesirii] Ah Moin Mud :)
+      Liste der Mitspieler vom Die,  8. Mai 2007, 02:34:28 (1 Teilnehmer)    
+
+Mesirii..........Z
+
+-----------------------------------------------------------------------------
+
+
+
+Fuer eine gewisse Unke. (Ronda, 11. Mai 2007, 01:28:32):
+[Anm. vom Einsender: http://de.wikipedia.org/wiki/Suv]
+
+From: Florian Diesch <diesch@spamfence.net>
+Newsgroups: de.alt.folklore.urban-legends
+Subject: Re: Rind faellt vom Himmel
+Date: Sat, 05 May 2007 02:21:09 +0200
+Message-ID: <20070505002110.4533.6.NOFFLE@dieschf.news.arcor.de>
+
+Katharina Fuhrmann <fuhrmann.katharina@chello.at> wrote:
+
+> > Frank Weinberg schrieb:
+>> >> Volker Gringmuth <einklich@gmx.net> writes:
+>> >>
+>>> >>> Aber erst aus "Twister" wissen wir, dass es Gelaendewagen gibt, die
+>>> >>> ganz ruhig geradeausfahren, ohne dass das Lenkrad auch nur zittert,
+>>> >>> waehrend ein Tornado fuenf Meter weiter eine Kuh horizontal
+>>> >>> vorbeitraegt.
+>> >>
+>> >> Fuer irgendwas muessen diese >>2t schweren SUV ja gut sein.
+> >
+> > Genau! Jetzt weiss ich auch endlich, warum ich meine Karre hab! Falls
+> > mich in Oesterreich einer der vielen, vielen Tornados hier erwischt!
+
+Hier in Deutschland brauchen wir sowas nicht, unsere Tornados sind in
+Afghanistan.
+
+-----------------------------------------------------------------------------
+
+
+
+Einstein ist trivial. (Ronda, 16. Mai 2007, 20:59:35):
+(SN: Auf das Wesentliche gekuerzt)
+
+Betreff: Re: Vorgeschobenes, Ausweichendes
+Absender: Priska Rubischon <priska@0x1b.ch>
+Message-ID: <Pine.LNX.4.58L.0705160759170.15775@max.0x1b.ch>
+Datum: Wed, 16 May 2007 08:02:14 +0200
+Newsgruppe: de.talk.romance
+
+Aber gewisse Maenner wuerden sich halt besser mit einfacheren Dingen als
+Frauen auseinandersetzen. Z.B. der Relativitaetstheorie ;-)
+ 
+Gruss Priska
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Einstein ist trivial. (Huraxprax, 16. Mai 2007, 22:01:53):
+~#! rn=Ronda rt=1179341975 rg=schmarrn.netdigest
+~#! tid=1179341975
+Dieser Aussage muss ich uneingeschraenkt zustimmen. Auch wenn die Allgemeine
+Relativitaetstheorie einiges komplexer ist als die Spezielle, im Vergleich zur
+Knenntnis von Frauen sind beide absolut trivial.
+
+hurax
+
+-----------------------------------------------------------------------------
+
+
+
+Der Vergleich ist etwas fishy? (Ronda, 21. Mai 2007, 00:39:52):
+SN: der OP meckerte, dass im Thread auch Antworten kamen, die nicht exakt dem
+entsprachen, wonach er gefragt hatte.
+
+Message-ID: <464c7760$0$6402$9b4e6d93@newsspool2.arcor-online.net>
+From: Henning Paul <henningpaul@gmx.de>
+Subject: Re: Mini Solarzellen - Quelle?
+Newsgroups: de.sci.electronics
+Date: Thu, 17 May 2007 17:44:44 +0200
+
+Rolf_Bombach schrieb:
+
+> > Franz Herrmann schrieb:
+>> >> 
+>> >> Ich fragte nach der naechsten Tankstelle, aber anstatt mir mit einer
+>> >> einfachen Wegbeschreibung zu helfen, wollte man mir ein neues Auto
+>> >> verkaufen. :-(
+> > 
+> > Willkommen im Usenet. Fragst du nach der Zeit, wird dir erklaert,
+> > wie eine Uhr funktioniert. Da muss man durch.
+
+"Gibst Du einem Hungrigen einen Fisch, machst Du ihn einen Tag satt.
+Erklaerst Du ihm, wie man angelt, wird er Dich anpoebeln, er haette
+besseres zu tun, als den ganzen Tag irgendwelche Schnuere ins Wasser
+haengen zu lassen."
+
+Gruss
+Henning
+
+-----------------------------------------------------------------------------
+
+
+
+Bounty (Ronda, 21. Mai 2007, 22:02:14):
+From: "Joern G. Steinmann" <j.g.steinmann@gmx.co.uk>
+Subject: Re: Akku NB-2LH und die Preisunterschiede
+Newsgroups: de.alt.rec.digitalfotografie
+Date:Sun, 20 May 2007 21:00:58 +0200
+Message-ID: <f2qcua.no.1@message-id.mixed-pixels.de>
+
+Det Hoffmann schrieb:
+
+> > 1. Fuer mich ist der Produktname entscheidend, nicht ein Bild und das
+Produkt
+> > heist nun mal eben NB-2LH von accu-Batt.
+
+... und es steckt eben unter Umstaenden etwas anderes drin als 
+im NB-2LH von Canon - wenn auch vielleicht die Unterschiede 
+nicht ganz so dramatisch sind wie beispielsweise bei einer
+Packung Bounty von Masterfoods und einer von Procter & Gamble. 
+(Falls fuer Dich aber auch da nur der Produktname entscheidend
+ist, kann es durchaus sein, dass beim einen die mangelnde
+Saugfaehigkeit stoert und beim anderen der Papiergeschmack.)
+
+js
+
+-----------------------------------------------------------------------------
+
+
+
+Inhaltsschwer? (Ronda, 23. Mai 2007, 22:34:18):
+From: Christian Knappke <chknews@gmx.net>
+Subject: Re: Zeigernamen
+Newsgroups: de.etc.sprache.deutsch
+Date: Wed, 23 May 2007 09:27:04 +0000 (UTC)
+Message-ID: <Xns9939747CCBF5AHZqjX8Z9@news.sap-ag.de>
+
+>> >> undiskutabel
+ 
+> > Ist das eigentlich sowas aehnliches wie "undiskret" oder
+> > "unlegal"? 
+ 
+> > Ich meine seit zwei, drei Jahren eine Tendenz zu erkennen, dass
+> > das Negationspraefix zunehmend germanisiert wird.
+
+Und die das tun halten sich auch noch fuer telligent! 
+Intelligent sind die, jawohl!1elf
+
+Das musste mal 'raus.
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Inhaltsschwer? (Darklor, 24. Mai 2007, 08:06:11):
+~#! rn=Ronda rt=1179952458 rg=schmarrn.netdigest
+~#! tid=1179952458
+Das klingt wie das Unwort "unfroh" - fuer mich is das entweder traurig oder
+ungluecklich...
+
+Darklor
+
+-----------------------------------------------------------------------------
+
+
+
+Arcor und Telekom (Ronda, 25. Mai 2007, 20:52:45):
+[SN: Man beachte das Subject...]
+
+From: Rene Fuchs <refu@digitalgemuese.de>
+Subject: Re: Telekom will Arbeitsniederlegungen deutlich ausweiten
+Newsgroups: arcor.misc
+Date: Sun, 13 May 2007 13:08:02 +0200
+Message-Id: <1cc6ss1h1hqc1.dlg@news.digitalgemuese.de>
+
+Am 13 May 2007 09:55:02 GMT schrieb Arcor Newsticker:
+
+Die Telekom ist eine ungewoehnliche Firma.
+
+Ren
+
+-----------------------------------------------------------------------------
+
+
+
+Antiquierte Technik (Ronda, 25. Mai 2007, 20:54:37):
+Betreff: Re: Gesucht: Ideen fuer 128MB USB-Stick
+Datum: Fri, 20 Apr 2007 10:35:08 +0200
+Von: Armin Wolf <Bitte_keine_PM@mail.invalid>
+Newsgruppen: de.comp.hardware.misc
+Message-ID: <f09to8$vu2$1@aioe.org>
+
+"Christian Kirsch" <dipsi@mensaplan.tk> schrieb im Newsbeitrag
+
+>> > > Fuer den ganz normalen Office- Text- Transport ist er noch
+>> > > viel zu gross, denn dafuer reicht meistens eine Diskette...
+> >
+> > Dis... was???
+
+Die sieht aus, wie eine zu gross gewachsene SD- Karte.
+Der Memoyy- Slot fuer dieses Monster ist fast 9 cm breit,
+hat eine Schutzklappe, und einen mechanischen Auswurf-
+mechanismus, erkennbar an einem Schalter, der die Ro-
+bustheit einer Armatur eines alten Ruehrenradios hat.
+
+Platz auf der Karte ist fuer ca. 20 Word- Dokumente bzw.
+1 1/2 Minuten MP3- Genuss, oder fuer ein Bilde einer
+(billigen) Digicam.
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Arcor und Telekom (Orktoeter, 25. Mai 2007, 20:54:57):
+~#! rn=Ronda rt=1180119165 rg=schmarrn.netdigest
+~#! tid=1180119165
+Wenn die wirklich 50000 oder so zu viel an Mitarbeitern haben, was stoert es
+da, wenn weniger als 50000 gleichzeitig streiken? So lange die, die noch
+arbeiten brav hackeln, ist doch fuer die Telekom alles bestens.
+
+-----------------------------------------------------------------------------
+
+
+
+Leckeres Wasser (alt) (Ronda, 27. Mai 2007, 22:42:05):
+From: Dieter Bruegmann <nutznetz@bruhaha.de>
+Subject: Re: Cola
+Newsgroups: de.alt.fan.aldi
+Date:Sun, 27 May 2007 12:20:06 +0200
+Message-ID: <f3bt1n.3vv1lbn.1@boogie.bruhaha.de>
+
+Mathias Fuhrmann (Sun, 27 May 2007 11:07:08 +0200):
+
+> > Andreas Cammin schrieb:
+> >
+>> >> Fuer mich gibts keinen, ich krieg von allen Sodbrennen.
+> >
+> > Du darfst sie ja auch nicht pur trinken, verduennt mit Mekhong whiskey
+> > ist/war das Zeug viel bekoemmlicher. ;-)
+
+Frueher trank ich Whisk(e)y mit Wasser, dann ohne Wasser und jetzt wie
+Wasser.
+
+-----------------------------------------------------------------------------
+
+
+
+Ich wuerd ja gern wissen... (Ronda, 27. Mai 2007, 22:44:04):
+... was da tatsaechlich der Unterschied ist...
+
+Ronda *neugierig wie immer*
+
+From: Michael Block <MinkiNE1@web.de>
+Subject: Re: HiPath Manager: Spracheinstellung
+Newsgroups: de.comm.geraete.isdn.tk-anlage
+Date: Fri, 25 May 2007 22:49:29 +0200
+Message-ID: <5bp0eoF2sv295U2@mid.individual.net>
+
+> > Mir ist im Manager [der Einstellsoftware der Telefonanlage] 
+> > aufgefallen, dass man bei der Spracheinstellung fuer Endgeraete 
+> > neben "Deutsch" auch "Deutsch Telekom" auwaehlen kann. Leider 
+> > schweigt sich die Hilfe zu den Spracheinstellungen weitestgehend aus.
+
+> > Worin besteht der Unterschied zwischen "Deutsch" und "Deutsch Telekom"?
+
+Alle Grundfunktionen haben eine Fussnote mit dem Hinweis, dass diese
+kostenpflichtig sind. ;-)
+
+-----------------------------------------------------------------------------
+
+
+
+Nicht witzig. Aber gut. (Ronda, 27. Mai 2007, 22:46:44):
+Aber: die Newsgroup de.talk.romance passt da nur bedingt dazu, oder?
+
+Ronda
+
+Newsgroups: de.talk.romance
+Subject: Re: Subtile Trollereien - Gegenmassnahmen
+From: David Kastrup <dak@gnu.org>
+Date: Fri, 25 May 2007 00:03:31 +0200
+Message-ID: <85hcq13mmk.fsf@lola.goethe.zz>
+
+Johannes Mueller <joh_im_usenet@gmx.de> writes:
+
+> > Martina Diel <martina.k.diel@web.de> skribis:
+> >  
+>> >> Also duerfte der Neonazi in der Strassenbahn den Schwarzen anpoebeln -
+du
+>> >> wuerdest es ignorieren? Wegschauen? 
+> >
+> > Ignorieren wuerde ich es, nicht wegschauen. Ich erklaere dir jetzt mal,
+was
+> > der Unterschied ist zwischen Ignorieren und Wegschauen:
+> >
+> > Ich wuerde mich an den Schwarzen wenden und ihn in ein
+> > unverfaengliches Gespraech verwickeln. Was weiss ich. Ihn nach der
+> > naechsten Haltestelle fragen, irgendsowas. Und dabei demonstrativ den
+> > Poebler keines Blickes wuerdigen. Die Botschaft soll sein: "Dein
+> > Poebeln interessiert keinen und aengstigt auch keinen." Den Poebler
+> > zuredestellen ist kontraproduktiv, weil es ihn bestaetigt, dass seine
+> > Provokation Wirkung zeigt. Wegschauen ist auch kontraproduktiv, weil
+> > es dem Poebler auch die Bestaetigung gibt, dass seine Provikation
+> > Wirkung zeigt; die Wegschauenden signalisieren naemlich Angst. Mein
+> > Ansatz waere, dem Opfer zur Seite zu stehen, ohne dass der
+> > Provokateur dabei Aufmerksamkeit bekommt.
+
+Nun, meine Mutter war einmal in Suedafrika, und auf einem Flug hat sich
+eine Weisse beschwert, dass auf dem Platz neben ihr ein Schwarzer sass,
+was sie fuer nicht zumutbar hielt.  Der Steward versuchte ihr
+klarzumachen, dass das vollkommen normal sei, aber sie war nicht
+ruhigzukriegen, auf eine ziemlich penetrante Weise.  Schliesslich
+meinte der Steward, er saehe ein, dass die Situation unzumutbar sei und
+es waeren in der ersten Klasse noch Plaetze frei.  Hier sprach er dann
+an ihr vorbei ihren Nachbarn direkt an und fragte ihn, ob er so
+freundlich sein koenne, dort Platz zu nehmen.  Was ihm spontanen
+Applaus einbrachte.
+
+-----------------------------------------------------------------------------
+
+
+
+Wie ist denn... (Ronda, 30. Mai 2007, 22:54:55):
+... der Aufschlag, wenn der Kunde Berater ist?
+
+Ronda *neugierig*
+
+From: Jens Arne Maennig <maennig.0704@cricetus.com>
+Subject: Re: Betontreppe schalen+giessen
+Newsgroups: de.rec.heimwerken
+Date:28 May 2007 15:08:02 GMT
+Message-ID: <nemoMon052807050558@alphaone.com>
+
+> > Dieses Knowhow kaufst du dir am besten gleich zusammen mit einem
+> > Maurer,  der das ganze ausfuehrt, mit dir als tatkraeftige
+> > Unterstuetzung.
+
+Bei mithelfendem Kunden haben wir frueher immer einen Zuschlag von 25%
+kalkuliert, wenn der mithelfende Kunde Lehrer war, 50%.
+
+-----------------------------------------------------------------------------
+
+
+
+Geht das auch in der MPA? Welche Rubriken? (Ronda, 30. Mai 2007, 22:56:48):
+[SN: Der OP moechte eine 8kg-Waschmaschine kaufen, um darin Bettdecken zu
+waschen. Quoting-Zeilenlaenge angepasst]
+
+From: Axel van Bergen <van_bergen@arcor.de>
+Newsgroups: de.etc.haushalt
+Subject: Re: Waschmaschine - Kaufberatung
+Message-ID: <1180479328.608876.244830@o5g2000hsb.googlegroups.com>
+Date: 29 May 2007 15:55:28 -0700
+
+On 27 Mai, 18:14, gartm...@nonsense.immunbio.mpg.de (Christoph
+Gartmann) wrote:
+
+> > 8 kg wirst Du normal nicht kriegen, das haben Waeschereien. Fuer den
+> > Mehrpreis einer Profimaschine kannst Du mit dem Taxi in die Reinigung
+> > fahren, um Deine Bettdecke waschen zu lassen.
+
+Dafuer extra ein Taxi vorzuhalten, waere unserem Tom vermutlich auch
+nicht recht. Das koennte man doch auf einen wirtschaftlicheren
+Zweiradbetrieb umstellen.
+
+F'up2 drm: Welches Motorrad bietet mindestens 150 Liter Stauraum?
+Cooler Blubbersound eines V8 waere bevorzugt.
+F'up defa: Welches Taxi soll ich nehmen, damit ich 150 Liter Gepaeck
+ohne Kontamination von der Waescherei nach Hause bringe? Gibt es
+emissionsfreie Elektrotaxis?
+F'up de.verfolgungswahn.elektrosmog: Ich moechte ja gerne auf ein
+Elektromopped umsteigen, aber schaedigt das nicht meine Erbanlagen?
+F'up dsrs: Ich bin mit meinem Elektromopped zu schnell gefahren. Kann
+ich das EVU auf Schadenersatz verklagen, weil es Ueberspannung
+geliefert hat?
+
+Weitere F'ups bieten sich an.
+dsr.a+s: Ich muss die dreckige Waesche vom Tom durch die Gegend fahren
+und kriege dafuer drei Euro die Stunde...
+dafa: Wann gibt es neue Bettdecken?
+
+Es fe len noch die Eisenbahner, und auf Fahrradhelme sind wir auch
+noch nicht eingegangen. Ansonsten sollte das de.usenet in angemessene
+Aufregung versetzt sein.
+
+Gute Nacht,
+Axel
+
+-----------------------------------------------------------------------------
+
+
+
+Italophil, francophil... (Ronda, 31. Mai 2007, 22:05:09):
+From: Andreas Prilop <AndreasPrilop2007@trashmail.net>
+Subject: Re: Italophil, francophil ...
+Newsgroups: de.etc.sprache.deutsch
+Date: Thu, 31 May 2007 10:30:05 +0200
+Message-ID: <Pine.GSO.4.63.0705311027260.3615@s5b004.rrzn.uni-hannover.de>
+
+On Wed, 30 May 2007, Daniela Duerbeck wrote:
+
+> > Wie nennt man es, wenn man Spanien mag? Hispanophil vielleicht?
+
+Mag England:     Anglophil
+Mag Frankreich:  Frankophil
+Mag Deutschland: Kollaborateur
+;-)
+
+-----------------------------------------------------------------------------
+
+
+
+Linear B und "Lena" von Pur (Ronda,  3. Jun 2007, 01:12:30):
+From: Hans-Georg Bickel <hgbusenetmuell@gmx.de>
+Subject: Re: Jugendliche von heute...
+Newsgroups: de.alt.soc.knigge
+Date: Fri, 01 Jun 2007 00:24:06 +0200
+Message-ID: <f3nov6.2mc.1@ID-108823.user.uni-berlin.de>
+
+Norbert Raps <mail@norbert-raps.de> wrote:
+
+> >Kaum, dass Jugendliche den Windeln entwachsen sind, meinen die, sie waeren
+> >bedeutende Koenige, und benehmen sich auch entsprechend.
+
+Erst kuerzlich wurde auf Kreta eine in Linear B beschriftete
+Tontafel dieses Inhalts ausgegraben und nach der Lektuere gleich
+wieder eingegraben.
+
+> >Gestern abend um ca.
+23.30 Uhr habe ich fuenf von dieser Sorte des Mietshaus-Hofes verwiesen, weil
+> >sie da auf einer dortigen Bank biertrinkend und laut herumgroelend
+> >rumgesessen waren. Auf meinen Hinweis, sie wuerden Ruhestoerung begehen
+> >(Hofanlage zwischen zweier Mehrfamilienhaeuser, und ich selbst haette es um
+> >diese Zeit lieber etwas ruhiger gehabt), wurde ich von ihnen nur dumm
+> >angeredet und ausgelacht.
+
+Falsche Methode! Damit hast Du dich genau als einer der
+verspiesste Alten Saecke[tm] gebaerdet, gegen die man in der
+Pubertaet so gerne rebelliert.
+
+Setz' Dich zu ihnen, gib den kumpelhaften Berufsjugendlichen,
+schnorre sie um ein Bier an. Und spaetestens nach fuenf Minuten
+werden sie sich entnervt trollen.
+
+Neulich an der Bushaltestelle: Ein paar Viertelwuechsige hoerten in
+voller Lautstaerke Pornorap mit dem Handy, natuerlich ohne
+Kopfhoerer. Da packte mich der Schalk und ich dachte mir: "Das
+kann ich auch. Und im Zweifelsfall lauter."
+
+Ich zueckte mein Handy, waehlte zur maximalen Abschreckung 'Lena'
+von PUR und liess es krachen. Die erste Strophe war noch nicht
+vorbei, da waren die Kopfhoerer ausgepackt und angeschlossen.
+
+Von dem erstaunten Gesichtsausdruck, wieso da irgend so ein
+Krawattenfuzzi mit einem /ihrer/ Spielzeuge einen Gegenangriff
+startet, habe ich noch Tage gezehrt.;-)
+
+HG
+
+-----------------------------------------------------------------------------
+
+
+
+So wahrheitsgemaess dann doch bitte auch nicht?! (Ronda,  3. Jun 2007, 01:26:42):
+From: Thomas Huehn <newsgroups@thomas-huehn.de>
+Newsgroups: de.soc.recht.misc
+Subject: Re: Arbeitsrecht: gute Beurteilung einklagen?
+Date: Sat, 02 Jun 2007 13:04:09 +0200
+Message-ID: <87abviehxy.fsf@mid.thomas-huehn.de>
+
+Thomas Hochstein <thh@inter.net> writes:
+
+> > Franki Rommel schrieb:
+
+>> >> Habe mal gehoert, dass Beurteilungen nicht zu Ungunsten des AN ausfallen
+>> >> duerfen.
+
+> > Das ist so nicht zutreffend. Sie muessen zwar wohlwollend, aber auch
+> > wahrheitsgemaess sein.
+
+"Herr Meier hat meine Frau umgebracht. Ich bin ihm zu tiefstem Dank
+verpflichtet."? ;-)
+
+Thomas
+
+-----------------------------------------------------------------------------
+
+
+
+Bestellbestaetigung (Ronda,  5. Jun 2007, 22:06:04):
+Grad reingekommen (also ausnahmsweise nicht aus de.alt.netdigest). Und das ist
+kein Spam, Sternchen gesetzt wo nicht so wichtig.
+
+Ronda
+
+Vielen Dank fuer Ihre neuen T*** M***, Amazon Marktplatz-Ordnung!
+
+Ihre Bestellnummer Ist: 280****
+
+Ihr Artikel schiffte sich aus unserem Lager am 6/4/2007:
+Titel Verladene Menge
+Things of Beauty [Audio CD] Loituma1
+
+Verschiffen der Adresse:
+***
+
+Ihre Ordnung wird sich aus den USA einschiffen und nimmt typisch 5-10
+Werktage, um ueber die LUFTPOST anzukommen.
+
+Erlauben Sie bitte zwei volle Wochen vor dem Fragen von uns ueber seine
+Ankunft.
+
+Wenn Sie irgendwelche Fragen ueber Ihre Ordnung haben, setzen Sie sich mit uns
+bitte in Verbindung: de@***.com.
+
+ANTWORTEN SIE bitte dieser E-Mail NICHT, wie Antworten zu dieser
+E-Mail-Rechnung nicht kontrolliert werden.
+
+Vielen Dank fuer Ihr Geschaeft!
+
+www.***.com
+
+-----------------------------------------------------------------------------
+
+
+
+Endlich! Auf so eine Meldung habe ich Jahre gewartet! (Ronda,  5. Jun 2007, 22:21:55):
+From: Timo von Burg <timo.von.burg@mymail.ch>
+Subject: Re: Eine Lanze fuer das X
+Newsgroups: de.etc.sprache.deutsch
+Date: Mon, 04 Jun 2007 12:20:30 +0200
+Message-ID: <f40p1c$j9s$1@news.albasani.net>
+
+>> >> Eine Methode ist nicht schlecht, nur weil sie nicht perfekt ist.
+ 
+> > Ein Satz zum Einrahmen und den Perfektionisten um die Ohren zu hauen.
+
+Dazu eine passende wahre Geschichte:
+
+"Warum nutzten sich die Fahrleitungen, die franzoesische Unternehmen an 
+die japanische Eisenbahngesellschaft geliefert hatten, erheblich 
+schneller ab als die genau gleichen Draehte in Frankreich? Die Fachleute 
+standen vor einem Raetsel - bis einer von ihnen Gelegenheit hatte, eine 
+Gruppe japanischer Arbeiter beim Setzen der Oberleitungsmasten zu 
+beobachten. Waehrend man in Frankreich den vorgeschriebenen Mastabstand 
+von 100 Metern nur ungefaehr einzuhalten pflegte, wurde er in Japan exakt
+ausgemessen. Jeder Drahtabschnitt zwischen zwei Masten wirkt 
+physikalisch wie eine schwingende Saite; wegen ihrer gleichen Laengen 
+gerieten die Saiten in Resonanz, es bildeten sich stehende Wellen grosser
+Amplitude, und die dadurch vermehrte Reibung am Stromabnehmer hatte den 
+erhoehten Verschleiss des Materials zur Folge. Das Problem lag also in der
+Perfektion und seine Loesung in einer gewissen Schlampigkeit."
+
+Quelle: Spektrum der Wissenschaft
+http://www.spektrumverlag.de/artikel/821675
+
+-----------------------------------------------------------------------------
+
+
+
+Wohl bekomm's! (Ronda,  5. Jun 2007, 22:29:39):
+[SN: Auf den relevanten Anteil gekuerzt]
+
+From: Hans Bonfigt <bonfigt.ses-koeln@t-online.de>
+Newsgroups: de.rec.fahrrad
+Subject: Re: Nabenschaltungen
+Date: Thu, 31 May 2007 19:43:43 +0200
+Message-ID: <f3n149$i10$02$1@news.t-online.com>
+
+
+Als jemand, der _leiderleiderleider_ sehr haeufig "Dokumentationen"
+schreiben muss, muss ich Dir antworten:
+
+Verschiedene gesetzliche Bestimmungen und stetige Rechtsprechung
+_zwingen_ Unternehmen geradezu, die Dokumentationen so daemlich und
+schlecht zu schreiben, wie sie nun einmal sind.
+Jahrelang habe ich Hebebuehnen nach DIN EN 1570 konstruiert resp. die
+dazu benoetigte Konstruktionssoftware entwickelt.  Und jahrelang, ei-
+gentlich seit 1982, rege ich mich ueber die Dokumentation zum Hydrau-
+likoel- oder Zylinderwechsel auf.  Vor lauter Vorsichtsmassnahmen und
+Sicherheitshinweisen findet man die wesentlichen Positionen nicht.
+Auf Rueckfrage, was den der Scheiss solle ("Hydraulikoel nicht trinken"),
+wurde ich beschieden:  "Jeder Satz dort drinnen hat einen prozessualen
+Ursprung".   Na, denn.
+
+
+
+Gruss Hans
+
+-----------------------------------------------------------------------------
+
+
+
+Das ist doch Verleumdung! (Ronda,  6. Jun 2007, 23:55:29):
+Schliesslich ist die Aufenthaltswahrscheinlichkeit einer Frau definitiv nicht
+so zufaellig! Sie steigt proportional zur Anzahl der Schuhe!
+
+Ronda *ab und wech...*
+
+From: Christoph Schmitz <christoph.schmitz2@post.rwth-aachen.de>
+Newsgroups: oecher.talk
+Subject: Re: Aachener Frauen
+Date: Tue, 05 Jun 2007 17:12:36 +0200
+Message-ID: <5clcr4F30qrs1U3@mid.dfncis.de>
+
+Torsten Bronger wrote:
+> > Halloechen!
+> > 
+> > Andreas Demant schreibt:
+> > 
+>> >>Cornelius Drautz schrieb:
+>> >>
+>>> >>>Ich LIEBE die Unschaerferelation - wie sagt Harald Lesch so schoen:
+>>> >>>"Der heilige Gral der Physik" :-)
+>> >>
+>> >>Kann daneben noch eine Frau bestehen?
+>> >>*g*
+> > 
+> > Doch, schon.  Sowohl die gewisse Zufallskomponente, als auch das
+> > "man kann nicht beides haben", waeren ja gleich.
+
+Deshalb ist es ja auch so, dass man entweder nur
+wissen kann, *wann* eine Frau erscheint, oder *wo*,
+nie beides zugleich. Also entweder an einem Ort
+unendlich lange auf sie warten oder zu einem
+festen Zeitpunkt an allen Orten nach ihr suchen
+(ersteres ist noch eher machbar).
+
+Christoph
+
+-----------------------------------------------------------------------------
+
+
+
+Damalige Frau == Ex-Frau. Irgendwie kein Wunder, oder? (Ronda,  6. Jun 2007, 23:58:02):
+Subject:     Re: Wie man sich zum Doofmann macht....
+From:        Ralf Wenzel <ralf.wenzel@web.de>
+Newsgroups:  de.comp.sys.mac.soc
+Date:        5 Jun 2007 11:23:31 GMT
+Message-ID:  <nemoTue060507012236@alphaone.com>
+
+Klaus-Peter Friedl <spamdump@chello.at> schrieb:
+> >  Ralf Wenzel schrieb:
+>> >>   [Newton] Das Ding konnte sogar meine Handschrift
+>> >>   lesen - was meine damalige Frau nicht konnte (und was ich selbst
+>> >> nicht immer kann).
+> >  *ROTFL*
+> >  ;-)
+
+Nur  damit hier keine Missverstaendnisse auftauchen. Das war KEIN Witz!
+Ich habe meine Frau ueber Monate damit aufgezogen (guck mal, dieser
+kleine Newton hier, DER kann das lesen was ich schreibe - und du
+nicht???) :D Das hat sie echt irre gemacht.
+
+Ralf
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Das ist doch Verleumdung! (Gloinson,  6. Jun 2007, 23:58:38):
+~#! rn=Ronda rt=1181166929 rg=schmarrn.netdigest
+~#! tid=1181166929
+Na, "alle Orte" war etwas inkorrekt. Alle von der Frauenauftrittswhkeit
+vorgegebenen Orte natuerlich. Dass die Whkeit an den Orten mit vielen Schuhe
+maximiert wird ist schon iO.
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Das ist doch Verleumdung! (Orktoeter,  7. Jun 2007, 00:00:14):
+~#! rn=Ronda rt=1181166929 rg=schmarrn.netdigest
+~#! tid=1181166929
+Nur musst du in ersterem Fall evtl. unendlich lange auf die Frau warten, im
+zweiten Fall kannst du (dank der menschlichen unvollkommenheit) wohl alle Orte
+ausserhalb der Erde vernachlaessigen und kannst es evtl. mit hinreichender
+Wahrscheinlichkeit auf einen Kontinent oder gar ein Land oder eine Sadt
+einschraenken), wenn du dann noch die noetige Geschwindigkeit an den tag
+legst, stehen deine Chancen im 2. Fall sogar besser.
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Das ist doch Verleumdung! (Vanir,  7. Jun 2007, 16:31:29):
+~#! rn=Orktoeter rt=1181167214 rg=schmarrn.netdigest
+~#! tid=1181166929
+Du hast nicht zuende gedacht! So gesehen kann man den Ort an dem man
+endlich(!) lange warten muss auf den Platz neben einem Schuhschrank
+beschraenken.
+
+Damit erklaere ich das Problem fuer geloest.
+
+V.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Das ist doch Verleumdung! (Ronda,  7. Jun 2007, 16:35:10):
+~#! rn=Vanir rt=1181226689 rg=schmarrn.netdigest
+~#! tid=1181166929
+Nein, ist glaube ich nicht hinreichend schluessig. Weil Du von der - irrigen -
+Annahme ausgehst, dass _eine_ Frau ihre Schuhe nur an _einem_ Ort lagert.
+Voellig falsche Annahme!
+
+Ronda *heute wieder ueber Schuhe gestolpert*
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: Das ist doch Verleumdung! (Humni,  8. Jun 2007, 14:29:00):
+~#! rn=Ronda rt=1181226910 rg=schmarrn.netdigest
+~#! tid=1181166929
+Ich erinner mich an den Umzug einer Bekannten, als ich den Karton (echt
+grosser Umzugskarton, kein Schuhkarton) mit der Aufschrift "Schuhe Winter 1".
+Es ging noch ein wenig weiter (ich glaub nach 2 oder 3 war auch schluss,
+trotzdem).
+
+Humni
+
+-----------------------------------------------------------------------------
+
+
+
+Re^5: Das ist doch Verleumdung! (Humni,  8. Jun 2007, 15:39:28):
+~#! rn=Humni rt=1181305740 rg=schmarrn.netdigest
+~#! tid=1181166929
+Ich fuege hinzu: Tragen durfte. Im ersten Nebensatz. Sonst kein Verb. Danke
+Highlander!
+
+Humni
+
+-----------------------------------------------------------------------------
+
+
+
+Re^5: Das ist doch Verleumdung! (Gnome,  8. Jun 2007, 19:22:09):
+~#! rn=Humni rt=1181305740 rg=schmarrn.netdigest
+~#! tid=1181166929
+das geht doch alles noch.
+ich kenne fluechtig eine frau, die mir erzaehlt hat, sie haette erst
+vor ein paar tagen 17 paar ihrer schuhe notgedrungen weggeschmissen, weil
+einfach der platz immer weniger wurde.
+nun haette sie nur noch 176 paar.
+die arme sau.
+
+gnOme
+
+-----------------------------------------------------------------------------
+
+
+
+Re^6: Das ist doch Verleumdung! (Orktoeter,  8. Jun 2007, 20:20:04):
+~#! rn=Gnome rt=1181323329 rg=schmarrn.netdigest
+~#! tid=1181166929
+Wie hiess die First Lady von den Philipinen damals? Imelda Marcos?Ich glaube
+die spielte in einer Liga fuer sich...
+
+-----------------------------------------------------------------------------
+
+
+
+Re^7: Das ist doch Verleumdung! (Alboin,  8. Jun 2007, 22:31:21):
+~#! rn=Orktoeter rt=1181326804 rg=schmarrn.netdigest
+~#! tid=1181166929
+Hatte die englische Koenigin nicht auch so ne Macke, zwar nicht Schuhe, aber
+es hiess mal sie wrde ihre Klamotten nie ein zweites Mal anziehen. Keine
+Ahnung ob das bei Schuhen auch so ist.
+al
+
+-----------------------------------------------------------------------------
+
+
+
+Re^8: Das ist doch Verleumdung! (Orktoeter,  8. Jun 2007, 22:32:15):
+~#! rn=Alboin rt=1181334681 rg=schmarrn.netdigest
+~#! tid=1181166929
+Waren das nicht eher die Huete?
+
+-----------------------------------------------------------------------------
+
+
+
+Damals... (Ronda, 10. Jun 2007, 16:47:06):
+... war alles anders. Passende Signatur uebrigens.
+
+Ronda
+
+From: Thomas Wildgruber <excpronto@web.de>
+Newsgroups: de.alt.rec.digitalfotografie
+Subject: Re: Frage wegen EOS 400D/Windows 98
+Date: Thu, 7 Jun 2007 11:19:44 +0200
+Message-ID: <1bjps265wnbxk.dlg@pronto.org>
+
+On Thu, 7 Jun 2007 08:57:46 +0200, Michael Schebaum wrote:
+
+> > Ich denke mit leichtem Grausen daran, dass ich 1995 mit 486er und 32 MB
+RAM
+> > ein 300-MB-Poster erstellt habe.
+
+Und - schon fertig? ;-)
+
+Bye Tom und in diesem Sinne...
+-- "Ausdauer wird frueher oder spaeter belohnt - meistens aber spaeter."
+(Wilhelm Busch)
+
+-----------------------------------------------------------------------------
+
+
+
+schreibe Dingdong (Ronda, 13. Jun 2007, 01:26:44):
+From: Ekki Plicht <df4or@web.de>
+Newsgroups: de.alt.sysadmin.recovery
+Subject: Re: Spammer-Messe in Nuernberg
+Message-ID: <v9950mrgnxkp.15y890hzn3pgb$.dlg@40tude.net>
+
+Am Thu, 7 Jun 2007 13:44:47 +0200 schrieb Christoph Forkmann:
+
+> > * Benedikt Gievert <intensief06@arcor.de>:
+>> >>  Am Thu, 07 Jun 2007 10:28:13 +0200
+>> >>  schrieb Falk Willberg <Faweglassenlk@falk-willberg.de>:
+>> >> 
+>>> >>> Ich biete ein Zaunkoenigsnest im Wilden Wein an der Schlafzimmerwand.
+>> >> 
+>> >>  Biete Nachtigall im Kirschbaum gegenueber, die kann mehrere
+Telefontoene
+>> >>  perfekt.
+> > 
+> > Ich hatte letzten Sommer immermal einen Vogel vorm Fenster sitzen, der
+> > sich genau wie mein Wecker angehoert hat. Bloedes Vieh.
+
+Das erinnert mich an eine hypsche Geschichte...
+
+Praktikum vor Studium war gefordert, der lokale Fernsehhaendler der
+geeignete Provider. Ich war jung, ich brauchte das Ge^WPraktikum...
+
+Ich bin also mit dem Meister raus, Fernseher reparieren. Wir hocken hinter
+der Kiste, schrauben, messen und loeten, die Dame des Hauses sitzt auf der
+Couch und geniesst es, uns zuzugucken anstatt der ARD.
+
+Es klingelt an der Tuer. Die gute Frau bleibt ungeruehrt sitzen, obwohl man
+diese Klingel einfach nicht ueberhoeren konnte. Egal.
+
+Es klingelt wieder an der Tuer. Laut. Madame bleibt sitzen. Ich gucke den
+Meister an, der zieht die Augenbrauen hoch und schraubt weiter.
+
+Es klingelt erneut - dieses Mal ist es das Telefon. Laut und so wie diese
+schoenen, alten, grauen TFep halt klingelten. Wieder keine Reaktion der
+Frau, sie laechelt uns an, offensichtlich gefaellt ihr das
+Alternativprogramm. Ich gucke den Meister an, der zieht die Augenbrauen
+hoch, zuckt mit den Schultern und schraubt weiter.
+
+Das Telefon klingelt. Laut, mehrfach. Keine Reaktion seitens der
+TV-Zuschauerin. 
+
+Das Telefon klingelt weiter.
+
+Der Meister guckt links am TV vorbei, ich rechts am TV vorbei, hat bestimmt
+witzig ausgesehen. Daruf hin sie: 'Sie wundern sich bestimmt, warum ich
+nicht an die Tuer oder ans Telefon gehen, nicht wahr?' Der Meister nickt,
+ich nicke, schweigend.
+
+Sie: 'Naja, dann kommse mal mit in die Kueche.'
+
+Dort sitzt ein riesengrosser grauer Ara im Kaefig... und klingelt. So wie
+die Tuer oder das Telefon. Oder rauscht wie die Klospuelung.
+U_n_g_l_a_u_b_l_i_c_h perfekt nachgemacht. 
+
+Madame erzaehlt uns, das sie und ihr werter Gatte etwa zwei Jahre gebraucht
+haetten, um das echte Telefon oder die echte Tuerglocke von den nachgemachten
+Geraeuschen des Papageies zu unterscheiden. 
+
+Der Piepmatz hatte offensichtlich groesstes Vergnuegen daran, die Besitzer
+aufzuschrecken, die sich dann das tuet-tuet-tuet am Telefon anhoerten oder in
+den leeren Hausflur starrten...
+
+Nun blieben sie halt auch nachts im Bett und rennen nicht mehr zur Tuer.
+
+Und der arme, einsame Ara (Papageien sind Herdentiere) hat sich andere
+Geraeusche gesucht um die Leute wieder zu einer Reaktion zu bewegen...
+Geschirrklappern, Werbespotmelodien usw. Nur gespochen hat er kein Wort.
+Genial war er trotzdem.
+
+
+Gruss,
+Ekki
+
+-----------------------------------------------------------------------------
+
+
+
+Das Usenet kompetent erklaert. Und T-Online streikt doch nicht. (Ronda, 13. Jun 2007, 01:32:26):
+From: T-Online-Team@t-online.com (T-Online-Team)
+NewsGroups: t-online.talk.allgemein,internal.fups,internal.threads
+Subject: Re: Begriff gesucht
+Date: Thu, 07 Jun 2007 12:39:28 +0200
+Message-ID: <466addb5.1988203@T-Online-Team.dialin.t-online.de>
+
+Hallo Michael,
+
+Bezug:<news:f47h0o.2ec.1@ich.michaelhermes.de>
+Michael 'Silvia' Hermes schrieb in t-online.talk.allgemein:
+
+>> >> Sicher. Aber man muss doch nichts zu Dingen schreiben, von denen man
+>> >> nichts versteht. Nuhr mal so nebenbei. <eg>
+
+> > Bist du sicher, dass du das Usenet verstanden hast?
+
+Natuerlich. Es handelt sich um eine Ansammlung von Diskussionsgruppen,
+in denen sich vor allem altruistische Akademiker und andere hilfsbe-
+reite Spezialisten, aber natuerlich auch Hilfesuchende, in ueberaus kom-
+petenter Weise ueber alle Aspekte Ihrer Wissensgebiete austauschen.
+Die aeussere Form wird durch ein strenges Regelwerk, welches gleichwohl
+allein auf dem Konsens basiert, vorgegeben. Neulinge, die weder fach-
+lich glaenzen koennen, noch diese Regeln kennen und anwenden, werden in
+sehr toleranter und freundlicher Weise von diesem zwar anarchistisch
+entstandenem, aber gleichzeitig auch vorbildlichem Wertesystem ueber-
+zeugt, so dass sie selbst zu Traegern und Botschaftern dieser Ideologie
+der virtuellen Raumes "Usenet" werden.
+
+WAS ALSO SOLL DIESE UeBERAUS DUMME FRAGE, HAeH??!
+
+Mit freundlichen Gruessen
+Dein T-Online-Team ;-)
+-- "Tja, das sind halt die schlechten Anbieter, die ungepflegte Newsserver wie
+Sauerbier anbieten. *Sie* aber haben den besten News-Anbieter der Welt
+gewaehlt und erhalten daher den Service, den Sie erwarten duerfen!" *Das* Team
+in t-otu ueber Ihren Newsserver vs. andere die Controls nicht zeitnah
+ausfuehren. 
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Linear B und "Lena" von Pur (Bambi, 13. Jun 2007, 23:42:27):
+~#! rn=Ronda rt=1180825950 rg=schmarrn.netdigest
+~#! tid=1180825950
+Ich hab uebrigens "Amoklauf" aufm Handy. Ich krieg immer nen freien Sitzplatz
+in der S-Bahn, wenn ich will... }=)
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Linear B und "Lena" von Pur (Gloinson, 13. Jun 2007, 23:47:40):
+~#! rn=Bambi rt=1181770947 rg=schmarrn.netdigest
+~#! tid=1180825950
+Frueher mussten alte Leute nicht mit komischer Musik auf ihr prekaere LAge
+aufmerksam machen.
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Linear B und "Lena" von Pur (Leyla, 13. Jun 2007, 23:49:16):
+~#! rn=Gloinson rt=1181771260 rg=schmarrn.netdigest
+~#! tid=1180825950
+Sondern mit Gestank?
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: Linear B und "Lena" von Pur (Gloinson, 14. Jun 2007, 06:48:58):
+~#! rn=Leyla rt=1181771356 rg=schmarrn.netdigest
+~#! tid=1180825950
+Der leichte Uringeruch ist doch zu ertragen. Und du warst bestimmt nie ein
+Jungpionier!
+
+
+-----------------------------------------------------------------------------
+
+
+
+Bayerische Filter und so (Ronda, 15. Jun 2007, 22:19:33):
+From: Gabriele Conrad <nc-conradga@netcologne.de>
+Newsgroups: de.alt.sysadmin.recovery
+Subject: Re: Spammer-Messe in Nuernberg
+Date: Thu, 14 Jun 2007 12:18:36 +0200
+Message-ID: <f4r4lr$mbn$1@newsreader3.netcologne.de>
+
+Juergen Ernst Guenther schrieb:
+
+> > Der echte Geek denkt auch in der Freizeit.
+
+Und unser Ex-Azubi (Originalzitat: "Ich bin Informatiker!" das "Fach-"
+vorneweg unterschlaegt er gerne) anscheinend nicht mal waehrend der
+Arbeit. *seufz*
+
+Gestern erzaehlte er mir ganz stolz, unser Spamfilter wuerde ja
+"Bayerisches Lernen" beherrschen. Ich konnte nur mit Muehe die Traenen
+zurueckhalten. Mord im Affekt waere eine Moeglichkeit.
+
+
+-- Allein die Dunkelheit ist real, das Licht scheint nur so. -- end of
+forwarded message -- 
+
+-----------------------------------------------------------------------------
+
+
+
+Zeitgenoessische Prosa (Ronda, 15. Jun 2007, 22:20:53):
+Subject:     Zeitgenoessische Prosa
+From:        Volker Gringmuth <einklich@gmx.net>
+Newsgroups:  de.rec.buecher
+Date:        Thu, 14 Jun 2007 07:07:13 +0000 (UTC)
+Message-ID:  <Xns994F5CC6591C8bx@h2.einklich.net>
+
+Einklich liest man sowas ja nicht, aber dieser Absatz eines jener 
+tagtaeglich um meine sexuelle Leistungsfaehigkeit besorgten Zeitgenossen 
+fing doch meine Aufmerksamkeit:
+
+| It will make your squib a real space rocket that will raise you up to 
+| the seventh sky of the sexual satisfaction!
+
+Heilig Vaterland - so eine ausgefeilte Metaphorik erwarte ich in /dem/ 
+Kontext einklich net. 
+
+Da steht zu befuerchten, dass solche Texte von kuenftigen Generationen als 
+die Literatur des fruehen 21. Jahrhunderts betrachtet werden.
+
+
+vG
+
+-----------------------------------------------------------------------------
+
+
+
+Boese (fuer L.) (Ronda, 15. Jun 2007, 22:22:54):
+From: "Harald Maedl" <Harald.Maedl@gmx.de>
+Subject: Re: Evolutionsfrage zu homo s. schleswigholgiensis femininus
+Newsgroups: de.sci.biologie
+Date: Tue, 12 Jun 2007 20:58:18 +0200
+Message-ID: <f4mqce$etl$00$1@news.t-online.com>
+
+Joachim Warner wrote:
+
+> > wir diskutieren im kleinen Kreis schon laenger darueber, das warme
+> > Wetter zeigt es ueberdeutlich, also nun mal in die Biologenrunde die
+> > ernstgemeinte Frage gestellt:
+> > Noch vor nicht allzu vielen Jahren waren die BH-Groessen B und C am
+> > staerksten nachgefragt.
+> > Der Nachwuchs (hier nur ab ca. 18 Jahre betrachtet) tendiert entweder
+> > zu Koerbchen ?? und Bauchumfang in etwa = Brustumfang, oder zu
+> > Koerbchengroesse null - A.
+
+Das ist eine natuerliche Anpassung an die flache Umgebung
+Schleswig-Holsteins. Es dient dem Schutz vor dem allzu raubgierigen
+Homo Bavarensis Masculinus, da sich Homo Schleswigholgiensis Feminina
+durch simples Hinlegen dem vorherrschenden Gelaende nahtlos anpassen und
+somit tarnen kann.
+
+Gruesse
+Harald
+
+-----------------------------------------------------------------------------
+
+
+
+Kurz. Fett. (Ronda, 15. Jun 2007, 22:26:02):
+Subject: Re: Deutschland schrumpft weiter
+From: Florian Diesch <diesch@spamfence.net>
+Date: Thu, 07 Jun 2007 01:04:50 +0200
+Message-ID: <20070606230450.4DB.1.NOFFLE@dieschf.news.arcor.de>
+Newsgroups: arcor.misc
+
+Arcor Newsticker <dpa@arcor-online.net> wrote:
+
+> >   lediglich durch  Zuwanderung. Die Bevoelkerung in Deutschland
+> >   nimmt seit 2003 ab.
+
+Ich nicht!
+
+-----------------------------------------------------------------------------
+
+
+
+Ausbildung Berufspilot (Amaryllis, 16. Jun 2007, 19:09:13):
+Date: Wed, 13 Jun 2007 11:00:06 +0200
+Newsgroups: de.rec.luftfahrt
+Message-ID: <VA.0000750f.0068bef1@hotmail.com>
+Subject: Re: Ausbildung Berufspilot
+From: Thomas Borchert <borchert_thomas@hotmail.com>
+
+
+Sven-Hajo,
+
+> Fakt ist aber das viele mitfliegende Aerzte nicht mehr unbedingt als
+> solche praktizieren
+>
+
+Sehr schoen fand ich mal den Kommentar eines Kardiologen neben mir. Der 
+Flieger war voll von denen, Kongress in San Diego (die armen Aerzte!). 
+Ich sagte: "Ist ja der perfekte Flug, um einen Herzinfarkt zu haben." 
+Darauf er: "Ueberhaupt nicht, da stehen wir alle um Sie rum und streiten 
+uns um die richtige Behandlungsmethode."
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Bayerische Filter und so (Humni, 16. Jun 2007, 21:03:31):
+~#! rn=Ronda rt=1181938773 rg=schmarrn.netdigest
+~#! tid=1181938773
+Ok. Ich oute mich:
+
+Ich habs nicht verstanden. Bitte ein Erklaerbaer ran.
+
+Humni
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Bayerische Filter und so (Amaryllis, 16. Jun 2007, 22:31:41):
+~#! rn=Humni rt=1182020611 rg=schmarrn.netdigest
+~#! tid=1181938773
+Er meinte wohl "Bayes-Filter".
+
+Ama*
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Bayerische Filter und so (Humni, 16. Jun 2007, 22:38:04):
+~#! rn=Amaryllis rt=1182025901 rg=schmarrn.netdigest
+~#! tid=1181938773
+Danke! (Gloinson hatte mir das schon tmmt, aber ich denke, ich bin nicht der
+einzige Depp. Oder? Naja, selbst wenn...)
+
+Humni
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Ausbildung Berufspilot (Darklor, 16. Jun 2007, 23:01:01):
+~#! rn=Amaryllis rt=1182013753 rg=schmarrn.netdigest
+~#! tid=1182013753
+Der is gut! :)
+
+Darklor
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Bayerische Filter und so (Darklor, 16. Jun 2007, 23:03:40):
+~#! rn=Ronda rt=1181938773 rg=schmarrn.netdigest
+~#! tid=1181938773
+Den verstehen nur Informatiker oder? - Erklaert mal - s gib auch ne
+ErklaerDiddlmaus dafuer - denn der TeddyBaer is ja nich weggebbar ;)
+
+Darklor
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Bayerische Filter und so (Zesstra, 17. Jun 2007, 01:53:40):
+~#! rn=Darklor rt=1182027820 rg=schmarrn.netdigest
+~#! tid=1181938773
+Naja, nicht nur Informatiker, aber Bayes ist vermutlich kein Allgemeinwissen.
+Es gibt sog. Bayes-Filter, die auf Wahrscheinlichkeiten beruhen (Anwendung
+z.B. Spam-Filterung). Der Typ hatte das wohl nicht mehr so ganz richtig im
+Kopf. (Bayes war ein Mathematiker, das hat natuerlich nix mit Bayern zu tun.)
+http://de.wikipedia.org/wiki/Bayesscher_Filter
+
+Zesstra
+
+-----------------------------------------------------------------------------
+
+
+
+Management-Speak gut erklaert. Laut lesen... (Ronda, 19. Jun 2007, 01:10:46):
+From: "Helmut P. Einfalt" <helmut.p.einfalt_NOSPAM@NOSPAM_aon.at>
+Subject: Re: "halbverrottet" oder "halb verrottet"?
+Newsgroups: de.etc.sprache.deutsch
+Date:Sun, 17 Jun 2007 06:51:16 +0200
+Message-ID: <4674bd81$0$25613$91cee783@newsreader02.highway.telekom.at>
+
+[SN: Teilzitat]
+>> >> Was ist eigentlich eine Supply-Chain-Managerin?
+
+Das Wort kommt aus der Schweiz und bezeichnet jene Dame, die im Sueppli
+die Nuedeli zu Chanes formt, welch letzteres Wort aus der franzoesischen
+Schweiz kommt und von der Duden-Redaktion bloss falsch geschrieben
+wurde ...
+
+<duckundweg>
+
+
+-----------------------------------------------------------------------------
+
+
+
+Traurig, oder? Und eine passende Sig. (Ronda, 19. Jun 2007, 01:13:04):
+Message-ID: <46751aae@news.uni-ulm.de>
+From: Volker Birk <bumens@dingens.org>
+Newsgroups: de.alt.sysadmin.recovery
+Subject: Re: Und ihr beschwert euch ueber User...
+Date: 17 Jun 2007 13:27:42 +0200
+
+Jens Link <surf@quux.de> wrote:
+> > Gestern, 18:30, ich komme in London am Flughafen an und checke ein. 
+> > Ich werde nach Fluessigkeiten im Handgepaeck gefragt. Keine dabei, alles
+> > ok, weiter zur Sicherheitskontrolle.
+
+Du Gluecklicher. Mir haben sie in Duesseldorf gerade die fast leere
+Zahnpastatube abgenommen. ("Hier ist es strenger als in Zuerich!")
+
+$SICHERHEITSBEAUFTRAGTER: "Sorry, nur ein Behaeltnis bis 100ml pro
+Person." (das zweite war eine Handcreme)
+
+Ich: "Ist Ihnen eigentlich klar, was man mit 50ml Nitroglyzerin
+anrichten kann?"
+
+$SICHERHEITSBEAUFTRAGTER: "Ja, durchaus. Eigentlich bin ich ja CTA, hab
+nur keinen Job gefunden."
+
+Ich: "Kennen Sie den Grund fuer diese merkwuerdigen Massnahmen?"
+
+$SICHERHEITSBEAUFTRAGTER: "Keine Ahnung. Ich nehme mal an, die
+Entscheider haben irgendwas geraucht."
+
+Viele Gruesse,
+VB.
+-- "Es muss darauf geachtet werden, dass das Grundgesetz nicht mit Methoden
+geschuetzt wird, die seinem Ziel und seinem Geist zuwider sind." Gustav
+Heinemann, "Freimuetige Kritik und demokratischer Rechtsstaat" 
+
+-----------------------------------------------------------------------------
+
+
+
+Boese. Oder lecker? (Ronda, 20. Jun 2007, 23:20:09):
+[Moderator's Note: Koettbuller sind schwedische Hackbaellchen]
+
+From: "Helmut P. Einfalt" <helmut.p.einfalt_NOSPAM@NOSPAM_aon.at>
+Subject: Re: Kita
+Newsgroups: de.etc.sprache.deutsch
+Date: Mon, 18 Jun 2007 19:52:42 +0200
+Message-ID: <4676c629$0$25616$91cee783@newsreader02.highway.telekom.at>
+
+Lars Braesicke beliebte zu schreiben :
+
+>> >>  Antiautoritaere schicken ihre Kinder in den
+>> >>
+>> >> http://de.wikipedia.org/wiki/Kinderladen
+> >
+> > Und die Ladenhueter muessen zum Ladenschluss wieder abgeholt werden.
+
+Ikea, Restaurant, Mittagszeit, wir stehen hinter einer aelteren Dame
+an.
+
+Der Lautsprecher quaekt die uebliche Durchsage: "Die kleine
+Nicole-Sophie moechte vom Kinderparadies abgeholt werden! Die kleine
+Nicole-Sophie moechte vom Kinderparadies abgeholt werden!"
+Ich sag zu der meinigen: "Was machen die eigentlich mit den Kindern,
+die bis abends *nicht* vom Kinderparadies abgeholt werden?". Dreht
+sich die Frau vor uns um und sagt trocken: "Koettbuller".
+
+Helmut
+-- Nach dera Zei'n kimmt nix mehr 
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Boese. Oder lecker? (Anthea, 21. Jun 2007, 11:09:21):
+~#! rn=Ronda rt=1182374409 rg=schmarrn.netdigest
+~#! tid=1182374409
+> Dreht sich die Frau vor uns um und sagt trocken: "Koettbuller".
+Kann mir das jemand erklaeren? Was sind Koettbuller?
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Boese. Oder lecker? (Marcus, 21. Jun 2007, 11:11:15):
+~#! rn=Anthea rt=1182416961 rg=schmarrn.netdigest
+~#! tid=1182374409
+Du schreibst jetzt 100 mal an die Tafel:
+
+"Ich soll Googlen bevor ich Fragen stelle."
+
+Ciao, Marcus
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Boese. Oder lecker? (Marcus, 21. Jun 2007, 11:11:57):
+~#! rn=Marcus rt=1182417075 rg=schmarrn.netdigest
+~#! tid=1182374409
+Aber Kloepse/Hackbaellchen aus Kindern ... Nunja.
+
+Ciao, Marcus
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: Boese. Oder lecker? (Rumata, 21. Jun 2007, 11:14:38):
+~#! rn=Marcus rt=1182417117 rg=schmarrn.netdigest
+~#! tid=1182374409
+Da musste man nichtmal Googeln fuer - es stand oben in dem Post drinne.
+Rum**
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: Boese. Oder lecker? (Rumata, 21. Jun 2007, 11:16:32):
+~#! rn=Marcus rt=1182417117 rg=schmarrn.netdigest
+~#! tid=1182374409
+:erinnert sich an eine franzoesische Austauschschuelerin, die
+beim Metzker schokiert vor der Kinderwurst stand.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^5: Boese. Oder lecker? (Grimmborn, 21. Jun 2007, 11:28:01):
+~#! rn=Rumata rt=1182417392 rg=schmarrn.netdigest
+~#! tid=1182374409
+Der Vollstaendigkeit halber: Der schwedische Plural zu "Koettbulle" ist
+"Koettbullar". "Koettbuller" koennte norwegisch sein, notfalls auch daenisch.
+Hat jedenfalls mit Ikea nix zu tun. 
+
+GdA
+
+-----------------------------------------------------------------------------
+
+
+
+Re^6: Boese. Oder lecker? (Gloinson, 21. Jun 2007, 11:28:21):
+~#! rn=Grimmborn rt=1182418081 rg=schmarrn.netdigest
+~#! tid=1182374409
+Den komischen Kram gibt es auch ab und an bei Ikea.
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^7: Boese. Oder lecker? (Grimmborn, 21. Jun 2007, 11:29:35):
+~#! rn=Gloinson rt=1182418101 rg=schmarrn.netdigest
+~#! tid=1182374409
+Nope, das wuerde mich sehr wundern und ich wuerde einen Photobeweis erwarten.
+Bei Ikea gibts tatsaechlich immer nur Koettbullar, nie Koettbuller.
+
+GdA
+
+-----------------------------------------------------------------------------
+
+
+
+Re^8: Boese. Oder lecker? (Gloinson, 21. Jun 2007, 11:32:37):
+~#! rn=Grimmborn rt=1182418175 rg=schmarrn.netdigest
+~#! tid=1182374409
+Ja, ich meine schon Koettbull_a_r mit "komischem Kram".
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^9: Boese. Oder lecker? (Janne, 21. Jun 2007, 11:43:11):
+~#! rn=Gloinson rt=1182418357 rg=schmarrn.netdigest
+~#! tid=1182374409
+Da es sich um ein schwedisches Gericht handelt, welches (sofern selbstgemacht
+und nicht von IKEA) auch superlecker ist, wird es auch in Norwegen mit dem
+schwedischen Namen bezeichnet, wenngleich es dort als Speise insgesamt
+wesentlich weniger verbreitet ist. 
+
+-----------------------------------------------------------------------------
+
+
+
+Re^10: Boese. Oder lecker? (Humni, 21. Jun 2007, 19:01:03):
+~#! rn=Janne rt=1182418991 rg=schmarrn.netdigest
+~#! tid=1182374409
+Ich esse bei Ikea immer die Hot Dogs. Die stopfe ich immer so voll mit
+Roestzwiebeln und Gurken und Co, dass die Haelfte rausfaellt.
+
+Bin ich da der einzige?
+
+Und ja, ich finde die lecker.
+
+Humni
+
+-----------------------------------------------------------------------------
+
+
+
+Re^11: Boese. Oder lecker? (Vanir, 21. Jun 2007, 19:01:51):
+~#! rn=Humni rt=1182445263 rg=schmarrn.netdigest
+~#! tid=1182374409
+Nein. Wobei ich immer hoffe, dass da niemand mit einer Kamera rumsteht.
+V.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^12: Boese. Oder lecker? (Humni, 21. Jun 2007, 19:02:40):
+~#! rn=Vanir rt=1182445311 rg=schmarrn.netdigest
+~#! tid=1182374409
+Gut zu wissen, ich sehe zwar auch immer Leute, die das genauso machen, denke
+aber immer, ich waere trotzdem eine Ausnahme.
+
+Humni
+
+-----------------------------------------------------------------------------
+
+
+
+Re^13: Boese. Oder lecker? (Vanir, 21. Jun 2007, 19:03:46):
+~#! rn=Humni rt=1182445360 rg=schmarrn.netdigest
+~#! tid=1182374409
+Koennte an der beruflichen Vorbelastung liegen. Sowas faellt doch eindeutig in
+den Bereich Optimierung.
+V.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^14: Boese. Oder lecker? (Gloinson, 21. Jun 2007, 22:08:22):
+~#! rn=Vanir rt=1182445426 rg=schmarrn.netdigest
+~#! tid=1182374409
+Man kann mit weiteren Senf-Ketchup-Schichten die Zwiebeln so gut mit dem
+Hot-Dog verfugen, bis man Maulsperrengroesse erreicht hat.
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^10: Boese. Oder lecker? (Bambi, 21. Jun 2007, 22:53:26):
+~#! rn=Janne rt=1182418991 rg=schmarrn.netdigest
+~#! tid=1182374409
+Ich bin unwissend: Wo ist der Unterschied zwischen Kottbullar und Frikadellen?
+(Ersteres kenne ich nicht persoenlich.)
+Ich bekenne mich wie Humni als "Hot Dog bei Ikea essen"-Esser.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^11: Boese. Oder lecker? (Kessa, 22. Jun 2007, 00:00:21):
+~#! rn=Bambi rt=1182459206 rg=schmarrn.netdigest
+~#! tid=1182374409
+Koettbullar sind vor allem kleiner als Frikadellen (so Partybaellchengroesse)
+und werden mit Preiselbeeren serviert. _Gute_ Koettbullar sind ausserdem viel
+zarter und weicher als die herkoemmliche pappige Frikadelle. Hat wohl mit dem
+Brot- oder Semmelbroeselanteil zu tun. Ich mach sie ganz ohne Brot und dafuer
+mit nem guten Schlapp Sahne drin. Bei den ersten muss man dann etwas
+aufpassen, dass sie nicht beim Braten zerfallen, aber das ist wie bei
+Pfannkuchen, die naechsten werden immer besser und besser. Und jetzt hab ich
+Hunger.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^12: Boese. Oder lecker? (Kessa, 22. Jun 2007, 00:10:09):
+~#! rn=Kessa rt=1182463221 rg=schmarrn.netdigest
+~#! tid=1182374409
+(Nun editier ich doch) Ach ja, und das frikadellentypische Ei weglassen hilft
+auch sehr. Wem es so zu locker wird, moege es mal mit einer zerdrueckten
+gekochten Kartoffel statt Brot + Ei probieren, das geht erstaunlich gut.
+
+-----------------------------------------------------------------------------
+
+
+
+Nun darf ich das posten... (Ronda, 22. Jun 2007, 00:35:19):
+... nun sind die Waldorfschueler und -lehrer im Bett ;-)
+
+Ronda
+
+From: Neil Asset <neilasset@netscape.net>
+Subject: Neulich bei ALNATURA ...
+Newsgroups: de.alt.talk.unmut
+Date:Thu, 14 Jun 2007 18:56:12 +0200
+Message-ID: <f4rrvc$6q5$02$1@news.t-online.com>
+
+... jetzt koennte man eigentlich schon aufhoeren. 
+
+"Selbst Schuld!"
+
+Fertig, naechster Thread.
+
+Aber es geht ja noch weiter. Also, da stehe ich an der Kasse vom
+hiesigen Alnatura (klingt das nicht wie der gruene Ableger der
+Al-Khaida?), um mich herum viele gebildete Besserbuerger, die mit
+angestrengtem und ernstem  Blick jede Minute ihres Lebens damit
+beschaeftigt sind, die Welt zu retten.
+
+Man sieht Designer-Brillen, helle Cordhosen und Roecke aus Leinen. Die
+Luft ist schwanger vom Erleuchtet sein, allen scheint etwas Sonne aus
+dem Hintern. Da sehnt man sich fast wieder nach Karl Blase ausm Aldi,
+der eine Palette Schaedel-Bier und ein halbes Dutzend Mettwuerste aus
+Fleischereiabfaellen in seinen Wagen wuchtet.
+
+Vor mir eine Mutter mit zwei entzueckenden Waldorfkindern, die die
+einzigen in diesem Laden zu sein scheinen, die ihren Spass haben
+(natuerlich abgesehen von mir). Circa vier und sechs Jahre alt (das
+Maedchen ist die aeltere von beiden) kaspern und scherzen sie direkt vor
+mir herum. Ich beobachte die beiden und amuesiere mich ueber ihre
+Ausgelassenheit. Die Mutter betrachtet mich jedoch, als haette ich laut
+darueber nachgedacht, wie ich die beiden auf moeglichst widerliche Weise
+schaenden koennte. Dann laufensie durch den Laden und spielen Fangen.
+Und jetzt kommt es:
+
+"Gustav, Cosima!, Kommt doch mal her. Mama zahlt eben und dann gehen
+wir."
+
+Gustav? Cosima? Leck mich am Poppes! Wer tut Kindern sowas an?
+
+Ich sehe Gustav in fuenfundzwanzig Jahren an der Flasche haengen, weil
+er mit seinem Vornamen nur Comedian oder Abwehrspieler in Oesterreich
+werden kann. Cosima wird vermutlich keinen Job in einer fuehrenden
+Position kriegen, es sei denn, sie verpflichtet sich, ihren Vornamen
+auf den Visitenkarten der Firma abzukuerzen.
+
+Wenn Eltern kreativ sein wollen, sollen in der Volkshochschule einen
+Kurs fuer Batik oder Holzarbeiten belegen. Aber warum lassen sie ihren
+Drang nach Neuem immer an ihren Kindern aus? Ich kenne eine Mutter,
+die hat ihre Kinder ausschliesslich mit Namen aus der Arthus-Sage
+bedacht! 
+
+Ich bin fuer eine Gesetzesaenderung. Kinder sollten mit zehn Jahren
+ihren Lieblingsnamen annehmen duerfen, und die Eltern sollten machtlos
+zuschauen muessen.
+
+Aber mich fragt ja keiner.
+
+NA
+
+-----------------------------------------------------------------------------
+
+
+
+Re^13: Boese. Oder lecker? (Vanir, 22. Jun 2007, 00:39:00):
+~#! rn=Kessa rt=1182463809 rg=schmarrn.netdigest
+~#! tid=1182374409
+War in den echten Kottbullar nicht Elk ?
+V.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^14: Boese. Oder lecker? (Alboin, 22. Jun 2007, 10:53:24):
+~#! rn=Vanir rt=1182465540 rg=schmarrn.netdigest
+~#! tid=1182374409
+Ich oute mich auch als Hot-Dog-bei-Ikea-Esser und ich finde es sollte gleich
+mit allem (also Wuerstchen und Brot) zum all-you-can-eat gemacht werden. Mir
+tun auch immer die vielen Zwiebeln leid die runterfallen.
+al
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Nun darf ich das posten... (Kessa, 22. Jun 2007, 13:37:03):
+~#! rn=Ronda rt=1182465319 rg=schmarrn.netdigest
+~#! tid=1182465319
+Das ist gar nichts. Ich kannte mal ein Waldorf-Geschwisterpaar mit Namen Venus
+und Mars. 'Mamaaaaaa, der Mars hat mich schon wieder an den Haaren gezogen!'
+
+Kessa, aber immer noch Waldorf-Sympathisantin :)
+
+-----------------------------------------------------------------------------
+
+
+
+Re^14: Boese. Oder lecker? (Kessa, 22. Jun 2007, 13:40:54):
+~#! rn=Vanir rt=1182465540 rg=schmarrn.netdigest
+~#! tid=1182374409
+Urspruenglich ja, kriegt man hier nur nicht so ohne weiteres. Oder weiss
+jemand, wo?
+
+-----------------------------------------------------------------------------
+
+
+
+Re^15: Boese. Oder lecker? (Grimmborn, 22. Jun 2007, 14:03:07):
+~#! rn=Kessa rt=1182512454 rg=schmarrn.netdigest
+~#! tid=1182374409
+Die Quelle fuer das "urspruenglich" wuerde mich echt interessieren. Wie bei
+den meisten traditionellen Gerichten handelt es sich bei den Koettbullar um
+ein praktisches Gericht, ein Rumfort-Essen ("was steht rum und muss fort?").
+Insofern wuerde ich davon ausgehen dass "urspruenglich" die Koettbullar aus
+Schwein oder Rind gemacht wurden, und zwar nicht aus den edelsten Teilen. 
+Natuerlich lassen sich heutzutage Elch-Koettbullar (die nichts mit der
+polnischen Stadt Elk zu tun haben, aus der Deiner Meinung nach offenbar solche
+Koettbullar sind), Rinderfilet-Koettbullar und auch solche aus Rentierfleisch
+finden, wenn man die entsprechenden fancy Restaurants aufsucht. Das Prinzip
+ist ja einfach genug und laesst sich beliebig variieren. Allerdings nicht
+durch Fisch, dann heisst das ganze wiederum Fiskbullar und ist ein verpoentes
+Schulmittagessen.
+
+GdA[ex-R] OHdMuBdE  
+
+-----------------------------------------------------------------------------
+
+
+
+Re^16: Boese. Oder lecker? (Gloinson, 22. Jun 2007, 15:14:12):
+~#! rn=Grimmborn rt=1182513787 rg=schmarrn.netdigest
+~#! tid=1182374409
+Wikipedia offenbart, dass Koettbullar das Lieblingsessen von Karlsson auf dem
+Dach waren. Ergo werden Mitte der 80er viele Muetter gelernt haben das zu
+machen ... :)
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^16: Boese. Oder lecker? (Kessa, 22. Jun 2007, 16:19:46):
+~#! rn=Grimmborn rt=1182513787 rg=schmarrn.netdigest
+~#! tid=1182374409
+Das 'Elk' habe ich kritiklos und bereitwilligst von Vanir uebernommen, weil es
+mich sentimental gemacht hat. Aus irgendnem Grund hiess es bei uns zuhause
+auch immer so. In langvergangenen Schweden-Urlauben pflegten wir an Regentagen
+Wikinger-Regeln zu verfassen, deren eine lautete: 'Hoert der Vik die Elke
+roehren, haelt er zu sich beide Oehren.' Hachja. - Mit einer
+wissenschaftlichen Anspruechen genuegenden Quelle fuer das 'urspruenglich'
+kann ich nicht aufwarten. Es war ein alter Schwede, der aussah, als haette er
+die Anfaenge der Koettbullar selbst miterlebt. Ich hab dem geglaubt.
+
+Jetzt hab ich schon wieder Hunger.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^17: Boese. Oder lecker? (Bambi, 22. Jun 2007, 18:55:48):
+~#! rn=Kessa rt=1182521986 rg=schmarrn.netdigest
+~#! tid=1182374409
+Vielleicht koennte man an der naechsten winterburglichen Weihnachtsparty ja
+mal selbst kochen...
+
+-----------------------------------------------------------------------------
+
+
+
+Re^16: Boese. Oder lecker? (Darklor, 24. Jun 2007, 18:59:16):
+~#! rn=Grimmborn rt=1182513787 rg=schmarrn.netdigest
+~#! tid=1182374409
+Klingt irgendwie nach Bulletten...
+
+Darklor
+
+-----------------------------------------------------------------------------
+
+
+
+Re^17: Boese. Oder lecker? (Gnome, 25. Jun 2007, 11:11:12):
+~#! rn=Darklor rt=1182704356 rg=schmarrn.netdigest
+~#! tid=1182374409
+heissen die nich Bulledden?
+
+-----------------------------------------------------------------------------
+
+
+
+HP und WLAN (Ronda, 26. Jun 2007, 00:35:34):
+From: M G Berberich <berberic@forwiss.uni-passau.de>
+Newsgroups: de.alt.fan.harry-potter
+Subject: Re: Das dunkle Mal
+Date: Fri, 22 Jun 2007 19:45:07 +0200
+Message-ID: <3eetk4-up4.ln1@ID-306968.user.individual.net>
+
+Am Fri, 22 Jun 2007 16:25:41 +0200 schrieb Mirko Mielte:
+
+> > Ich frage mich uebrigens, ob das dunkte Mal auf dem Oberarmen der Todesser
+> > wieder verschwindet, sollte Voldemord sterben.
+
+Nein, die veraendern sich nur. Da steht dann Netzsuche, bis sie sich
+beim naechsten boesen Lord einbuchen koennen.
+
+     MfG
+     bmg
+
+-----------------------------------------------------------------------------
+
+
+
+Das gilt auch fuer die MPA! (Ronda, 26. Jun 2007, 00:36:10):
+Betreff: Re: Mobbing durch Polizei auf den Hals jagen ...
+Datum: Fri, 22 Jun 2007 00:16:26 -0700
+Von: Axel van Bergen <van_bergen@arcor.de>
+Newsgruppen: de.soc.recht.misc
+Message-ID: <1182496586.379432.57910@c77g2000hse.googlegroups.com>
+
+On 22 Jun., 07:15, "Ulrich F. Heidenreich" <nospam.
+0x4...@tremornet.de> wrote:
+
+> > Warum werden im Usenet mit schrecklich steigender Tendenz eigentlich
+> > immer Fragen beantwortet, die nie gestellt waren?
+
+Die Usenetverwaltung ist bestrebt, den Gegenwert deiner
+Postinggebuehren durch "added value" zu erhoehen. Das Konzept "buy one,
+get one free" spielt in diesem Zusammenhang eine wesentliche Rolle.
+
+Erlaeuternde Gruesse,
+Axel
+
+-----------------------------------------------------------------------------
+
+
+
+Und wieder mal: MPA == Newsgroups? (Ronda, 26. Jun 2007, 23:41:57):
+Subject:     Re: Erheblich abweichende Grundrissmasse bei Mietvertrag
+From:        Thomas Mueller <newsgroupspam@elfstone.de>
+Newsgroups:  de.soc.recht.wohnen
+Date:        Sun, 24 Jun 2007 18:50:06 +0200
+Message-ID: <f5m7bu$pph$2@svr7.m-online.net>
+
+Kurt Guenter wrote:
+
+> > Martin Kessel <f338@gmx.de> schrieb:
+> > 
+>> >>Hi,
+>> >>folgende Situation:
+> > 
+> > was willst Du?
+
+Ich denke er will mehrere widerspruechliche und teilweise unfundiertet
+Antworten. Ansonsten wuerde er einen Anwalt fragen, nicht eine Newsgroup.
+
+Gruesse,
+Thomas
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Und wieder mal: MPA == Newsgroups? (Zook, 27. Jun 2007, 00:38:55):
+~#! rn=Ronda rt=1182894117 rg=schmarrn.netdigest
+~#! tid=1182894117
+Worum es auch immer in dem Artikel ging, aber der eine Fall ist
+wirklich lustig: Es wird in D zum Thema Wohnungen und Wohnen
+wahnsinnig viel sehr hart reguliert, aber wie man die Groesse
+einer Wohnung bemisst, das ist leider nicht geregelt. ;) 
+
+Z
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Und wieder mal: MPA == Newsgroups? (Vanir, 27. Jun 2007, 18:36:00):
+~#! rn=Zook rt=1182897535 rg=schmarrn.netdigest
+~#! tid=1182894117
+Nicht? Ich dachte bis soundsoviel Meter Raumhoehe alles, unter 1,50 nur x %.
+usw. Hab ich da was falsches im Kopf ?
+
+V.
+
+-----------------------------------------------------------------------------
+
+
+
+*gaehn* (Ronda, 27. Jun 2007, 22:44:04):
+From: Michael Fesser <netizen@gmx.de>
+Newsgroups: de.soc.familie.kinder
+Subject: Re: Mittagsschlaf
+Date: Sun, 24 Jun 2007 20:19:11 +0200
+Message-ID: <7cdt73lc1epv0t5m7vhi9i7hcv316tj9cv@4ax.com>
+
+.oO(Enrico Bauer)
+
+> >24.06.2007 14:20:59, *Helga Buss*:
+>> >> susanne schrieb:
+>>> >>> Nachts kommt er aber 2-3 mal und will noch mal Nukeln.
+> >
+>> >> Wie sieht es nachts aus, wenn Mama einfach nicht 
+>> >> wachzukriegen ist und Papa im Kinderzimmer erscheint ;-)?
+> >
+> >Was soll der Papa denn allein im Kinderzimmer?! :-)
+
+In Ruhe schlafen.
+
+SCNR
+Micha
+
+-----------------------------------------------------------------------------
+
+
+
+Warum bin ich auf dieser Erde? (Ronda, 30. Jun 2007, 15:32:42):
+Erstaunlich, dass das in ner Recht-Newsgroup diskutiert wird. Und was meint er
+mit "auf _dieser_ Erde"? Gabs ne Moeglichkeit, den Storch zu ner anderen Erde
+zu lotsen?
+
+Ronda
+
+Subject: Re: warum nicht muslim sein
+Date: 28 Jun 2007 15:51:53 +0200
+From: Dirk Moebius <dirk.nospam.moebius@gmx.de>
+Newsgroups: de.soc.recht.misc
+Message-ID: <jjwsxogpae.fsf@virtual.pudel.in-berlin.de>
+
+Leo Oeler writes:
+
+> > On Wed, 27 Jun 2007 17:09:15 -0700, ahmad <6132AHMAD@gmail.com> wrote:
+>> >> Warum bin ich auf dieser Erde?
+
+> > Ist das neuerdings religionsspezifisch?
+
+Sicher.
+
+Hedonisten wind auf der Erde, um zu geniessen.
+Atheisten sind rein zufaellig hier.
+Agnostiker wissen nicht genau, warum sie hier sind.
+Calvinisten werden geboren, um zu arbeiten.
+Katholiken sind hier, weil sie es nicht besser verdient haben.
+Zeugen Jehovas sind hier, um von Tuer zu Tuer zu gehen.
+Buddhisten schauen einfach mal wieder vorbei.
+Moslems sind auf der Erde, weil Allah es so wollte.
+Juden werden geboren, um mit ihrem Gott zu hadern.
+Stoiker sind zwar auf der Erde, aber das geht auch vorbei.
+Scientologen wissen nicht, warum sie auf der Erde sind, solange sie
+die entsprechende Kurse nicht absolviert haben.
+
+Dirk
+
+-----------------------------------------------------------------------------
+
+
+
+Wie heissts denn nun?! (Ronda, 30. Jun 2007, 15:35:52):
+Political correctness. Puh. Ganz schoen schwer! Und: man beachte auch die
+Signatur.
+
+Ronda
+
+From: Wolfram Heinrich <theodor.rieh@freenet.de>
+Newsgroups: de.etc.sprache.deutsch
+Subject: Re: korrektes Wort fuer "farbige"
+Date: Thu, 17 May 2007 12:09:45 +0200
+Message-ID: <3qu0l4r5l2s2$.dlg@www.theodor-rieh.de>
+
+Am Wed, 16 May 2007 22:10:35 +0200 schrieb Lars Braesicke:
+
+> > Martin Bodenstedt schrieb:
+>> >> Sebastian Arendt schrieb:
+>> >>
+>>> >>> wie bezeichnet man eigentlich korrekt "farbige" Menschen auf Deutsch?
+>>> >>> Ich wurde heute dahingehend verbessert, dass sowohl "schwarzer" als
+>>> >>> auch "farbiger" diskreminierend sei.
+>> >>
+>> >> Warum haeltst Du denn die Hautfarbe ueberhaupt fuer erwaehnenswert?
+> > 
+> > Eine kurzgedacht sicher verstaendliche Frage.
+> > Allerdings: Warum sollte man die Hautfarbe weniger erwaehnenswert finden 
+> > als die Haarfarbe ("die Blonde, die Bruenette")?
+> > 
+Da gab es mal einen Sportreporter mit anscheinend erheblichen Zweifeln in
+der Negerfrage. Der hatte im Fernsehen einen Fight zwischen einem schwarzen
+Amerikaner und einem weissen Briten zu kommentieren und liess sich dabei zu
+dem Satz hinreissen: "Den Amerikaner erkennen Sie an der weissen Hose".
+
+Ciao
+Wolfram
+-- Wie viele Metzger wohl moegen schon auf der Suche nach dem Schwein der
+Weisen gescheitert sein? www.theodor-rieh.de, www.theodor-rieh.de/heinrich,
+www.brueckenbauer.it 
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Und wieder mal: MPA == Newsgroups? (Zook,  2. Jul 2007, 11:59:34):
+~#! rn=Vanir rt=1182962160 rg=schmarrn.netdigest
+~#! tid=1182894117
+nicht. das ist nicht normiert bzw. vorgeschrieben. z
+
+-----------------------------------------------------------------------------
+
+
+
+Reisen mal anders. (Ronda,  2. Jul 2007, 22:43:33):
+[SN: Quoting zum Verstaendnis leicht ergaenzt]
+
+From: Reinhard Greulich <usn0208+nospam@greulich.de>
+Newsgroups: de.etc.bahn.misc
+Subject: Re: Strafmass bei Personenbefoerderung mittels Gueterzug
+Date: Sun, 01 Jul 2007 16:49:56 +0200
+Message-ID: <leff83h4ait0ii1st5ktc57g3d81u02nrj@4ax.com>
+
+schtieF schrieb am Sun, 01 Jul 2007 14:25:01 -0000:
+
+> > Meine Frau und ich moechten unseren Sommerurlaub mal ganz anders
+> > verbringen. Wir wollen auf einen Gueterzug aufspringen und mitreisen,
+> > egal wohin.
+> >
+> > Hier noch ein paar Fragen, die uns gerade einfallen, vielleicht kennt
+> > sich ja jemand aus und kann uns vielleicht etwas erzaehlen.
+> > 
+> > * Halten Gueterzuege ueberhaupt, wenn ja wo?
+
+An Gueterzughaltestellen. Die erkennt man an einem Schild mit einem
+gruenen "G" auf gelbem Grund mit einem gruenen Kreis drumherum.
+
+> > * Sind diese Haltestellen Kameraueberwacht? Oder Sogar Hunde?
+> > (Hundeangst)
+
+Hundeueberwachte Gueterzughaltestellen erkennt man daran, dass unter dem
+Haltestellenschild das Zusatzschild "Hasso" steht.
+
+> > * Sind diese Haltestellen evtl. eingezaeunt?
+
+Nein, sonst koennte da kein Zug reinfahren.
+
+> > * welche Wagons sollte man waehlen?
+
+Das haengt von der gebuchten Wagenklasse und vom Wetter ab. 
+
+> > * irgendwelche tips wie man bei dem laerm schlafen koennte?
+
+Besser nicht schlafen, sonst vergesst Ihr, Euch festzuhalten.
+
+> > * was machen wir, wenn wir mal muessen?
+
+Fragt einfach den Lokfuehrer, der hat das gleiche Problem.
+
+Schoenen Urlaub!
+- Reinhard.
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Reisen mal anders. (Vanir,  2. Jul 2007, 22:52:11):
+~#! rn=Ronda rt=1183409013 rg=schmarrn.netdigest
+~#! tid=1183409013
+Wo kriegst Du eigentlich immer diese tollen Artikel her? Da sind ja wirklich
+tolle Sachen dabei. Grosses Lob fuer das Aufspueren dieser Kleinodien.
+
+V.
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Reisen mal anders. (Gloinson,  2. Jul 2007, 22:56:05):
+~#! rn=Vanir rt=1183409531 rg=schmarrn.netdigest
+~#! tid=1183409013
+Ich tippe mal, der Name ist Programm. Aeh, Newsgroup.
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Reisen mal anders. (Ronda,  2. Jul 2007, 22:57:38):
+~#! rn=Gloinson rt=1183409765 rg=schmarrn.netdigest
+~#! tid=1183409013
+Klar - die Newsgroup heisst de.alt.netdigest, pro Tag gibt es drei bis fuenf
+Nachrichten. Ist also nicht auf meinen Mist gewachsen.
+
+Ronda *schmueckt sich nicht mit fremden Federn*
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: Reisen mal anders. (Zook,  3. Jul 2007, 11:35:30):
+~#! rn=Ronda rt=1183409858 rg=schmarrn.netdigest
+~#! tid=1183409013
+praktisch ist, man brauch die nicht zu abonnieren, da ronda
+einige der artikel hier herein postet. z.
+
+-----------------------------------------------------------------------------
+
+
+
+Mal was anderes. (Ronda,  5. Jul 2007, 00:48:12):
+Subject: Hubschraubern [geringfuegig off-topic]
+Date: Sun, 01 Jul 2007 22:25:03 +0200
+From: Thomas Schade <toscha@rrr.de>
+Newsgroups: de.alt.fan.rrr
+Message-ID: <46880D9F.10007@news.toscha.de>
+
+Einige werden sich erinnern, dass ich zum 50. Geburtstag verschiedenste
+Geschenkgutscheine bekam, die sich, mit einer Ausnahme, alle um's Thema
+'Fliegen' drehten. Einer davon war 'Hubschrauber selber fliegen'.
+
+Am Samstag, 30.06., war es dann soweit; am Flughafen Jesenwang war ich
+angemeldet bei Euro-Heli. Wie bei einem 'guten Training'(tm) ueblich gab
+es erst einmal eine Theorie. Die laesst sich kurz so zusammenfassen: wer
+glaubt, Motorradfahren waere irgendwie auch nur ansatzweise schwierig hat
+sich noch nie mit der Steuerung eines Helikopters auseinandergesetzt.
+Beim Motorradfahren, das wissen wir alle, ist die wesentliche
+Einflussgroesse 'das Gas ist rechts!'. Den Rest erledigen Getriebe,
+Lenkimpuls und Kreiselkraefte. Da ist mancher eher mit zielgenauem
+Einparken in der Dose ueberfordert.
+
+Kreiselkraefte spielen, was nicht wirklich verwundert, natuerlich auch
+beim Hubschraubern eine wesentliche, um nicht zu sagen tragende, Rolle.
+Der Hubschrauberpilot, nicht unbedingt aber der Aspirant, ist davon so
+begeistert, dass er gleich zwei Rotoren steuern mag. Gleichzeitig. Deren
+Kreiselkraefte zudem einander bedingen. Zur Steigerung der Motivation,
+aber auch der Nervositaet des Aspiranten, steuert der Pilot den so
+genannten Hauptrotor, der grosse ueber einem, an dem der Hubschrauber
+haengt, sowohl mit der rechten wie mit der linken Hand. Der Heckrotor
+hingegen wird mit den Fuessen bedient. Die linke Hand also steuert Hoch
+und Runter mittels eines 'Kollektiv' genannten Hebels. Der sieht aus wie
+eine Handbremse am Auto, wirkt aber nicht so. Die rechte Hand haelt ein
+Element namens 'Cyclic', das zumindest ansatzweise aussieht wie ein
+Steuerknueppel. Oder wie der Laie sich eben einen Steuerknueppel
+vorstellt. Jedenfalls beeinflusst der Cyclic Vor und Zurueck und Rechts
+und Links. Leider ohne jegliche Rueckmeldung an den Piloten. Der hat
+dafuer Instrumente, die ueber Steig- und Sinkgeschwindigkeit, Hoehe,
+Schraeglage(!) etc. Aufschluss geben. Das ist insofern sinnvoll als jede
+Verstellung am z.B. Kollektiv auch eine Nachsteuerung am Cyclic nach
+sich zieht. Und wenn schon der Cyclic bedient wird ist es fast
+ueberfluessig darauf hinzuweisen, dass umgehend auch die Fuesse die
+Wirkungdes Heckrotors korrigieren muessen.
+Recht beilaeufig wird in der Theorie auch darauf hingewiesen, dass die
+Haende und Fuesse *immer* an den Steuerelementen zu verweilen haben
+alldiweil die sonst in ihre Nulllage zurueck gingen. Das will der Pilot
+wohl nicht. Nicht wenn der Hubschrauber fliegt jedenfalls.
+Hubschrauberfliegen ist also nichts fuer Nasenbohrer...
+Soweit die Theorie, etwa 15 schweisstreibende Minuten.
+
+Die Praxis stellt sich dann vor in Form eines Robinson R-22[1]. Der hat
+etwa die Groesse eines Geraetes, in das man Kinder setzt und sie fuer 50 Ct.
+schaukeln laesst, was ihnen den Glauben vermittelt sie floegen selber. Ein
+Eindruck, oder besser Glaube, der sich in Folge auch beim Aspiranten
+verfestigt. Die Kanzel ist auch nicht wirklich geraeumig, vollverglast
+wie sie ist macht sie allerdings einen optisch groesseren Eindruck. Der
+Eindruck groesserer Stabilitaet allerdings will sich nicht einstellen. Und
+an Stabilitaet waere dem Aspiranten wirklich gelegen, denn die
+Flugbewegungen eines Helikopters sind weit entfernt von jeglicher
+Stabilitaet. Vermutlich entziehen sie sich sogar nach wie vor einer
+physikalischen Beschreibung.
+
+Ungeachtet dessen vermittelt der Fluglehrer aber ein gewisses Vertrauen
+in die Eigenschaften des Geraetes. Dieses Vertrauen ist gross genug, um
+den Aspiranten nach Anlegen des Gurtes aufzufordern nun doch den
+Kollektiv zu ziehen, so dass der Helikopter sich majestaetisch erhebe.
+Gezogen ist so ein Hebel schnell. Wie sich herausstellt, zu schnell. Da
+die Fuesse noch keinen Kontakt mit den Pedalen aufgenommen hatten und auch
+die rechte Hand den Cyclic bestenfalls 'laessig' hielt beantwortete der
+Robinson den Befehl des Kollektors mit einem leichten Kippen ueber die
+rechte Seite und einem eleganten Schwenk des Hecks nach links.
+Majestaetisch hatte ich den Hubschrauber im Stand um 90 gedreht. Immerhin.
+Also gut, wenn ich den Kollektiv ziehe muss ich auch den Cyclic leicht
+nach vorne gebe. Und wenn ich Kollektiv ziehe und Cyclic nach vorne
+gebe, muss ich die linke Pedale etwas treten um den Heckrotor staerker
+anzustellen. Der soll sich anstellen, nicht ich mich. Unter
+Beruecksichtigung all dieser Einflussfaktoren fliegen wir jetzt dann
+ploetzlich. Die Vermutung, dass der Fluglehrer aehnlich eingriff wie ein
+Fahrlehrer in der Dose bei der ersten Fahrstunde, ist allerdings nicht
+voellig aus der Luft(!) gegriffen...
+
+Einmal in der Luft reagiert der Robinson wie ein kleines Sensibelchen.
+Gross ist er ja eh nicht, also teilt er vergnuegt mit, wenn ihn ein
+Windstoesslein trifft. Dann wippt die ganze Zelle lustig auf-ab, vor und
+zurueck. Haende und Fuesse sind jetzt gefragt, um den Hubschrauber in einem
+Zustand zu halten, den stabil zu bezeichnen am Boden wohl niemandem
+einfiele, der aber deutlich stabiler ist als das Tanzen im Wind.
+So geht es, in etwas 600 Fuss Hoehe, ueber den Ammersee. Waehrend der
+Fluglehrer sich bemueht den Aspiranten mit ein wenig Small Talk, siehst
+du den alten hoelzernen Sprungturm rechts unten am Strand?, nein, sehe
+ich nicht, interessiert mich nicht, das Hubschraubergeraet moege einfach
+nur ansatzweise mal meinen Befehlen Folge leisten, vom konzentrierten
+Starren auf Neigungsmesser, Horizont und Cyclic abzulenken ist jener
+damit befasst, intuitiv Windstoesse vorauszuahnen und im Voraus
+abzufangen. Das funktioniert soweit auch ganz gut, nur dass keine
+Windstoesse da sind. Somit auch nicht abgefangen werden muessten. Aber
+Robinson hat auch am Abfangen Spass, jedes Manoever fuehrt zu einem Huepfer,
+Kipper oder sonstigem Flugzustand, bei dem sich eine Beschreibung wie
+'stabil' von selbst verbietet.
+Wir sind jetzt suedlich von Andechs, beherztes Ziehen am Kollektiv hat
+uns auf 3.600 Fuss gebracht. Wenigstens irritieren wir die Segler auf dem
+See nicht mehr so. In einer langen, wie mir scheinen will sogar
+ansatzweise eleganten, Linkskurve, jedenfalls kippt der Helikopter nicht
+zappelnd von einer auf die andere Seite sondern folgt weitgehend der
+Richtungsempfehlung des Fluglehrers, kongenial umgesetzt vom Aspiranten,
+geht es langsam schon wieder zurueck Richtung Jesenwang.
+
+Was dem Fahrschueler in der Dose das rueckwaertige Einparken ist, das ist
+dem Flugschueler das Landen. Viel zu schnell schiessen wir ueber die
+Landebahn, die ein Hubschrauber ja eh nicht braucht. Das geht sich nie
+aus. Geht sich doch aus. Cyclic etwas zurueck nehmen, Kollektiv etwas
+nach unten, rechtes Pedal leicht treten, die Fahrt wird herausgenommen,
+der Robinson schwebt noch leicht ueber der Stelle. Nun gut, 'ueber der
+Stelle' ist so gesehen eine eher relative Angabe und so zu verstehen,
+dass 'die Stelle' doch etwa die Groesse eines Fussballfeldes abdeckt. So
+moechte man nicht landen. Der Fluglehrer greift ein letztes Mal ein,
+jetzt schwebt der Helikopter wirklich auf der Stelle und setzt
+supersanft auf. So einfach also ist das.
+
+Und es hat einfach nur Spass gemacht![2]
+
+Vielen Dank allen, die mir diese Erfahrung ermoeglicht haben. Der
+Gutschein war ein Volltreffer.
+
+
+Ciao
+Toscha
+----
+[1] http://de.wikipedia.org/wiki/Robinson_R22
+[2] http://www.rrr.de/~toscha/hubschrauber/hubschraubern.html
+
+-----------------------------------------------------------------------------
+
+
+
+Das ist aber kein Schweizer Akzent, oder? (Ronda,  7. Jul 2007, 12:30:58):
+From: Diedrich Ehlerding <diedrich.ehlerding@t-online.de>
+Subject: Re: Schweizer Akzent
+Newsgroups: de.etc.sprache.deutsch
+Date:Fri, 29 Jun 2007 22:01:35 +0200
+Message-ID: <v15gl4xk24.ln2@diedrich.ehlerding.dialin.t-online.de>
+
+> > Tempores mutantur ...
+
+Und wie sie sich aendern. Frueher hiessen sie noch tempora.
+
+-----------------------------------------------------------------------------
+
+
+
+Kurze Historie von MacOS X (Ronda,  7. Jul 2007, 12:33:36):
+[SN: Quoting ergaenzt]
+
+From: Noses <noses.nospam@noses.com>
+Organization: Noses' cave
+Newsgroups: de.comp.sys.mac.misc
+Message-ID: <468af4f2@news.bnc.net>
+Subject: Re: E- MAils verschluesseln
+
+
+
+ > Thomas Kaiser <Thomas.Kaiser@phg-online.de> wrote:
+
+ >> Kennt denn wer eine kurze Abhandlung, [die (...) die Historie von
+ >> MacOS X (nebst Ahnen, sprich BSD/Nextstep/Mach, nix Linux)  
+beleuchtet]
+
+
+Ok. Ganz kurz.
+
+Es war einmal das Minix, mit dem Andy T. unbedarften Studenten die
+Implementation eines minimalen unixaehnlichen Betriebssystems vermitteln
+wollte.
+
+Ploetzlich erfand Intel den 80386. Ein gewisser Linus entkam den Peanuts und
+dachte sich, diese Gurke muesse er jetzt so erweitern, dass sie die MMU nutzt
+und virtuellen Speicher verwenden kann.
+
+Andys Magen drehte sich um, hatte doch dieser Schmusedekenschaender so
+ziemlich alle Designregeln verletzt, die er seinen Studenten unter
+Zuhilfenahme des Ausbildungswerkzeugs "Minix" beibringen wollte.
+
+Von da an ging es weiter bergab - ein kernel alleine ist nicht wirklich so
+prickelnd und da ueber dem BSD Userland noch der AT&T-Geier schwebte, nahm
+man, was man unter GNU-Lizenz und reiner BSD-Lizenz finden konnte
+(gluecklicherweise auch den gnu-cc [damals war das noch der GNU C-Compiler
+und nicht die "Compiler Collection"]) und blies es zur ersten halbwegs
+laufenden Schlackwurst auf. Die BSD-Gemeinde sah es und schuettelte sich. Was
+ein Unrat! Alles wurde kreuz und quer irgendwohininstalliert, wo es kein
+Mensch mehr wiederfinden wuerde (nicht, dass irgendwer es wollen wuerde) und
+das meiste funktionierte - wie heute - nur leidlich. Aber irgendwer glaubte,
+damit Kohle machen zu koennen, indem er den etablierten Unix-Herstellern mit
+ihren umwerfenden Lizenzkosten ans Bein pinkelt und so geschah es, dass sich
+aehnlich dem anfaenglich technisch minderwertigen Windows die
+schlechtestmoegliche Alternative durchsetzte. "Die Luete wuerden sogar
+Schlaege
+auf den nackten Arsch in Kauf nehmen, wenn es nur billig ist."
+
+Sie haben sie sich verdient.
+
+
+Noses.
+
+-----------------------------------------------------------------------------
+
+
+
+Frueher war alles besser? (Ronda,  7. Jul 2007, 12:36:59):
+From: hwicht <lobotom@gmx.de>
+Newsgroups: de.rec.motorrad
+Subject: Re: Frueher war alles besser?
+Date: Wed, 4 Jul 2007 08:43:02 +0200
+Message-ID: <5f0u3lF39m3v8U1@mid.dfncis.de>
+
+"Achim Lerch" <lerch@wirtschaft.uni-kassel.de> schrieb
+> >
+>> > > Bei Frauen schaetze ich eigentlich den milden, maedchenhaften,
+>> > > problemlosen Typus.
+> >
+> > In der Oekonomie nennen wir das einen "Nirwana-Approach"...
+
+..in der Philosophie nennen wir das eine "Contradictio in adjecto."
+Oder eine Verletzung des Satzes vom Widerspruch.
+Oder ein Oxymoron.
+
+Am schoensten aber finde ich (zur Bezeichnung des Nirwana und des o.g.
+Frauentypus) folgenden Terminus technicus, den ich bei den Philosophen
+immer
+wieder hoere: das Desiderat.
+
+Seufz.
+
+-----------------------------------------------------------------------------
+
+
+
+Nein! (Ronda,  7. Jul 2007, 12:38:51):
+Ich sag nicht, an welchen Code mich das erinnert...
+
+Ronda
+
+From: Henry Leyh <henry.leyh@rzg.mpg.de>
+Newsgroups: de.alt.sysadmin.recovery
+Subject: Re: Wieso ist C++ eigentlich so schlecht?
+Date: Fri, 06 Jul 2007 11:48:18 +0200
+Message-ID: <f6l353$726$1@gwdu112.gwdg.de>
+
+Thus spake Felix von Leitner On 05.07.2007 19:32:
+> > Ich will hauptsaechlich darauf abheben, dass einem jemand ein an
+> > kompilierendes und linkendes Codestueck gibt, aber man exorbitant Kontext
+> > braucht, um a) das parsen und b) erklaeren zu koennen, was dieser Code
+> > tut.
+
+Muss es C++ sein oder reichen auch Objekte aus C-structs? Ich versuche 
+gerade PETSc (http://www-unix.mcs.anl.gov/petsc) mit intel-C/C++/Fortran 
+10.0 zu uebersetzen und wundere mich, warum das icc-Backend die 4GB RAM 
+vollaufen laesst bis nichts mehr geht -- mit intel 9.1 hatte doch 
+schliesslich auch alles funktioniert. Also mal schnell in den Code 
+geschaut, was los ist... Meine Omma hat immer gesagt "Im Krankenhaus 
+hamse den Erwin aufgeschnitten und gleich wieder zugemacht."
+
+Gruss,
+Henry
+
+-----------------------------------------------------------------------------
+
+
+
+Mag jemand das BKA abmahnen? (Ronda,  8. Jul 2007, 14:17:27):
+From: Christoph Drube <ch.drube@gmx.de>
+Subject: Re: Braucht jemand einen Peilsender?
+Newsgroups: de.etc.beruf.selbstaendig
+Date: Sat, 07 Jul 2007 11:20:38 +0200
+Message-ID: <f6nlt6$43n$03$1@news.t-online.com>
+
+
+[SN1: nach G8 wurde an einem Privatauto ein Peilsender entdeckt. Siehe
+http://www.heute.de/ZDFheute/inhalt/28/0,3672,5563548,00.html ]
+[SN2: Wer ein elektr. Geraet in Verkehr bringt, hat einen Geldbetrag an die
+Stiftung Elektro-Altgeraete Register www.stiftung-ear.de fuer die spaetere
+Entsorgung zu bezahlen]
+
+Christian Wielandt schrieb:
+
+> > Gerrit wrote:
+>> >> Die Antifa Berlin hat die Freie Marktwirtschaft entdeckt, das BKA
+>> >> scheint nicht so begeistert:
+> > 
+> > Verraetst Du uns noch, was dieses Thema mit beruflicher Selbstaendigkeit
+> > zu tun hat?
+
+Ist doch ganz einfach: Da nicht davon auszugehen ist, dass das BKA dieses
+Geraet in seiner monatlichen Mengenangabe gegenueber der EAR ausgewiesen hat
+und das BKA wortwoertlich als "Inverkehrbringer" anzusehen ist, ist das ganz
+klar ein Fall fuer mich, Lutz und andere hier: Abmahnen!
+Und wir sind Selbststaendige :-)
+
+Ansonsten: bitte nicht weinen
+
+Christoph
+
+P.S.: Das Ding hat sogar ein tolles CE-Zeichen 8-)
+
+-----------------------------------------------------------------------------
+
+
+
+Bahnfahrt mit Self-Service? (Ronda,  8. Jul 2007, 14:23:44):
+Betreff: Re: Streik und Zugbindung
+Datum: Fri, 06 Jul 2007 22:07:57 +0200
+Von: Helmut Barth <Helmut.Barth@arcor.de>
+Newsgruppen: de.etc.bahn.tarif+service
+Message-ID: <468ea03f$0$3828$9b4e6d93@newsspool4.arcor-online.net>
+
+Salut!
+
+Falk Schade schrieb:
+
+> > wieder mal beweist Du das Du keine Ahnung vom Job eines ZUB hast.
+(Urteilen 
+> > willst Du natuerlich trotzdem darueber)
+> > 
+> > wenn keiner den Zug abfertigt, keiner die Tueren schliesst, keiner
+ueberprueft 
+> > ob die Tueren geschlossen sind, keiner die Bremsprobe durch fuehrt, keiner
+den 
+> > Zug aufschreibt, keiner dem Tf den Bremszettel ausrechnet ... etc
+> > 
+> > Wie soll der Zug auch nur einen Meter fahren?
+
+Ganz einfach, der Tf haengt seinen Zug selbst ein, schreibt ihn selbst
+auf, macht alleine eine Bremsprobe und bittet alle Fahrdienstleiter oder
+sonstigen Bahnmitarbeiter an der Strecke um Mithilfe beim Abfertigen.
+Geht nicht?
+
+Ich kenne drei dutzend Fahrgaeste und eine Fastnachtskapelle die sich
+nach entsprechender Einweisung sehr kooperativ zeigten und ob des
+eigenen Fortkommens mehr als willig mitarbeiteten.
+
+Nach kurzer Schilderung der Lage und der Bitte um entsprechende Vorsicht
+willigten die Beteiligten ein, zu kooperieren. Danach bat ich mehr im
+Scherz, die Reisewilligen moegen mir doch bitte noch kurz ihre Fahrkarten
+zeigen woraufhin die Mehrheit zumindest etwas Ticketaehnliches aus der
+Tasche holte und hochhielt, was ich mit einem freundlichen "ok, die
+genauere Kontrolle fuehren sie dann halt gegenseitig durch, sie wissen ja
+wie das geht" quittierte. Kurz darauf ging es guter Stimmung los.
+
+Ein Trompetensignal ersetzte deutlich mehr als wirksam den
+Achtungspfiff. Die Tueren wurden von Hand geschlossen und vom
+ordnungsgemaessen Zustand hab ich mich selbst ueberzeugt. Zugegeben, eine
+141er mit zwei Wagen an einem Fastnachtsdienstag zwischen Backnang und
+Gaildorf blieben uebersichtlich genug, dass man das ohne Bedenken
+handhaben konnte.
+
+Besonderer Clou: Selbst der letzte hat hinter sich die Tueren
+geschlossen, und das einzige Problem der Fahrt war, dass ich unterwegs
+mehrere Fdl davon ueberzeugen musste, dass der Zug tatsaechlich verkehrt [1].
+
+Dessen vermeintliches Nichtverkehren am Vortag hatte naemlich fuer
+reichlich Irritationen zwischen dem Zugpersonal, den Fdl und den
+Reisenden gesorgt und mir den ausdruecklichen Auftrag eingebracht diesen
+Zug zu fahren. Der Zub war leider der gleiche wie am Vortag, und da war
+er vom Tf "aufgeklaert" worden, dass der erste Teil der Schicht wegen
+Ferien nicht verkehren wuerde. Bewegliche Ferientage der Schulen  zur
+Fassnacht zaehlen aber nicht als Schulferien, so dass diese Leistung zu
+fahren war.
+
+Gruessle, Helmut
+
+[1] In Sulzbach war das einfach. Der Fdl kam aus seinem Bahnhof und
+fragte mich: "Was machst du hier? Der Zug verkehrt heute gar nicht." Ich
+fragte zurueck: "Was siehst du hier?" woraufhin er antwortete: "Einen Zug
+.. aeh .. " worauf ich erwiderte "Na also, wenn das hier wie ein Zug
+aussieht, wird es wohl auch wie ein Zug verkehren?".
+
+Nach einem resignierten Schulterzucken und dem erfolglosen Versuch eine
+Weisung von der Betriebsleitung einzuholen meldete er mich nach
+Murrhardt vor, wo der Fdl vom verkehren des Zuges so ueberzeugt war, dass
+es keiner weiteren Worte bedurfte.
+
+In Fichtenberg war die Lage dann schon vertrackter, aber auch hier
+gelang es mit viel Mundarbeit, das Signal freizubekommen. Die
+Betriebsleitung hat uebrigens das planmaessige Verkehren des Zuges
+bestaetigt .. etwa 3 Stunden nach dem Ende der Zugfahrt. Ja, da waren wir
+halt schon eine AG und Netz und Traktion sich manchmal etwas uneins.
+
+-----------------------------------------------------------------------------
+
+
+
+Bambi! (Ronda, 10. Jul 2007, 22:49:18):
+From: Andreas Kabel <andreas.kabel@gmail.com>
+Subject: Re: Googlioten
+Newsgroups: de.etc.sprache.deutsch
+Date:Sun, 08 Jul 2007 21:18:24 -0700
+Message-ID: <868x9qdxbj.fsf@penguin.slac.stanford.edu>
+
+> > Durchaus. Ich sehe im Supermarkt(!) [in Montreal] gelegentlich Hirsch, 
+> > Bison und Rentier ("caribou"). Wenn auch etwas seltener als Pferd.
+
+Gut, gut; denn ich bin nachtragend und hatte mal in British Columbia
+eine Meinungsverschiedenheit mit einem bruenftigen Karibu (das
+uebrigens deutlich groesser ist als ein europaeisches Rentier) sowie
+einen Zwischenfall mit einer Hirschfamilie. Ich finde, Bambis Mutter 
+hat gekriegt, was sie verdient hat.
+
+-----------------------------------------------------------------------------
+
+
+
+Nix fuer Siegener (Ronda, 12. Jul 2007, 23:27:25):
+Newsgroups: de.etc.bahn.tarif+service
+Subject: Re: Paradoxien der neuen Preisberechnung
+From: bartsc00@cs.uni-dortmund.de (Detlev Bartsch)
+Date: Tue, 19 Jun 2007 09:59:16 +0000 (UTC)
+Message-ID: <f589dk$h8o$1@janice.cs.uni-dortmund.de>
+
+Florian Unger <no@mail.invalid> writes:
+
+> > Der Hammer aber der Preis ueber die NBS: 82,00 EUR! Das sind 5,00 EUR
+> > _mehr_ als fuer denjenigen, der die Reise bereits in Siegen beginnt...
+
+
+Also kostet Siegen - Koeln -5 EUR. Nun, der Programmierer des
+Presimoduls kannte offenbar die beiden Orte und hatte Mitleid. ;-)
+
+
+Tschuess
+  db
+
+-----------------------------------------------------------------------------
+
+
+
+Umwerfend. (Ronda, 12. Jul 2007, 23:30:38):
+Also ich hab mich auf dem Rueckweg von der Fahrpruefung fuer "Umwerfen"
+entschieden. Scheiss Bahnschienen laengs in der Fahrbahn :-(
+
+Ronda
+
+From: Martin Schoenbeck <ms.usenet.nospam@schoenbeck.de>
+Newsgroups: de.rec.motorrad
+Subject: Re: Am ersten Tag ...
+Date: Mon, 9 Jul 2007 13:34:01 +0200
+Message-ID: <11fsn5kbwnmi0$.dlg@usenet.schoenbeck.de>
+
+Hallo Clemens,
+
+Clemens Gleich schrieb:
+
+> > Ich wage zu widersprechen: In diesem Fall sollte das BMW RASC 
+> > eingreifen (Reverse Active Stability Control), das stellt das 
+> > Hinterrad beim Verschalten wieder auf Kurs. Frag den Haendler nach 
+> > einer Freischaltung, das ist doch eh alles Software heut.
+
+     --------------------------------------
+     |    Wollen Sie wirklich einkuppeln  |
+     |   [ja]    [doch]  [umwerfen]       |
+     --------------------------------------
+
+ Gruss Martin
+
+-----------------------------------------------------------------------------
+
+
+
+Mal mal wer bitte alle Links durchschauen? (Ronda, 12. Jul 2007, 23:33:04):
+Danke!
+
+Ronda
+
+From: Juergen Gerkens <Gerkens@nurfuerspam.de>
+Newsgroups: de.rec.sport.fussball
+Subject: Re: Ich bin Schockiert
+Date: Tue, 10 Jul 2007 10:21:57 +0200
+Message-ID: <f6vfnu$3jb$02$1@news.t-online.com>
+
+Kevin Mueller haute in die Tasten:
+
+[Ende der Knut Show]
+
+> > was hat das in einem fussball-forum zu suchen??
+
+Ist doch klar: Knut ist diese Saison wohl der erfolgversprechendste
+Publikumsliebling, den die Bayern nicht gekauft haben. Und das nur,
+weil sich die die Schisser sich keinen potentiellen Problembaeren mehr
+einhandeln wollen. Dabei hat er seit Beginn seiner Karriere 
+international
+grossen Erfolg,
+http://select.nytimes.com/gst/abstract.html?res=F30F11FF3C5B0C758CDDAD0894DF40
+4482
+http://www.tagesspiegel.de/medien/fotostrecken/cme9492,129633.html?SORT=PRIO
+http://www.tagesspiegel.de/medien/fotostrecken/cme9492,129640.html?SORT=PRIO
+
+einen guten Trainer,
+http://www.tagesspiegel.de/medien/fotostrecken/cme9492,144620.html?SORT=PRIO
+
+wird mit jedem Gegner fertig,
+http://www.tagesspiegel.de/medien/fotostrecken/cme9492,129721.html?SORT=PRIO
+
+hat den noetigen Biss,
+http://www.tagesspiegel.de/medien/fotostrecken/cme9492,129602.html?SORT=PRIO
+
+ist teamfaehig,
+http://www.tagesspiegel.de/medien/fotostrecken/cme9492,129631.html?SORT=PRIO
+http://www.tagesspiegel.de/medien/fotostrecken/cme9492,129632.html?SORT=PRIO
+
+dribbelstark,
+http://www.tagesspiegel.de/medien/fotostrecken/cme9492,129629.html?SORT=PRIO
+
+beherrscht Manndeckung
+http://www.tagesspiegel.de/medien/fotostrecken/cme9492,152971.html?SORT=PRIO
+
+bei jedem Gegner,
+http://www.tagesspiegel.de/medien/fotostrecken/cme9492,129715.html?SORT=PRIO
+
+Raumdeckung,
+http://www.tagesspiegel.de/medien/fotostrecken/cme9492,129644.html?SORT=PRIO
+
+kurzum jede Form von Deckungsarbeit,
+http://www.tagesspiegel.de/medien/fotostrecken/cme9492,152971.html?SORT=PRIO
+http://www.tagesspiegel.de/medien/fotostrecken/cme9492,129702.html?SORT=PRIO
+
+hat Spieluebersicht,
+http://www.tagesspiegel.de/medien/fotostrecken/cme9492,129712.html?SORT=PRIO
+
+ist zweikampfstark,
+http://www.tagesspiegel.de/medien/fotostrecken/cme9492,129738.html?SORT=PRIO
+
+umgaenglicher und pflegeleichter als Olli Kahn,
+http://www.tagesspiegel.de/medien/fotostrecken/cme9492,144621.html?SORT=PRIO
+
+und am Ball gefaehrlicher als Klose und Toni zusammen:
+http://www.tagesspiegel.de/medien/fotostrecken/cme9492,129628.html?SORT=PRIO
+http://www.tagesspiegel.de/medien/fotostrecken/cme9492,129723.html?SORT=PRIO
+http://www.meinberlin.de/sixcms/media.php/85/070511_knut_ddp.jpg
+
+SCNR ;-)
+
+Juergen Gerkens
+
+-----------------------------------------------------------------------------
+
+
+
+DAMALS... (Ronda, 13. Jul 2007, 00:09:12):
+... hat unser Mathe-Lehrer gesagt "wenn Du das nicht lernen willst, werd doch
+Klofrau im Jahnplatz-Tunnel". Das hier ist also neumodisch.
+
+Ronda
+
+Newsgroups: de.rec.tv.misc
+Subject: Re: Das weiss doch jedes Kind
+From: Jan Hladik <hladik@web.de>
+Date: Tue, 10 Jul 2007 10:48:42 +0200
+Message-ID: <news:5fgvfaF3buse8U1@mid.dfncis.de>
+
+Patrick Vrenz wrote:
+
+> > Da kann ich Dir nur voll und ganz zustimmen. Gerade die Privaten
+> > produzieren einen solchen Muell. Die Stratmann-Geschichte habe ich
+> > nicht gesehen. Dafuer bringe ich 'Entern oder Kentern' ins Spiel. Fuenf
+> > Minuten reingeschaut und fast eine Nervenlaehmung bekommen. In diesem
+> > Augenblick habe ich mir 'Spiel ohne Grenzen' zurueck gewuenscht.
+
+Ich finde, diese Sendungen wie "Entern oder Kentern" und "Ich bin ein
+Star..." haben auch eine gute Seite, paedagogisch betrachtet.
+
+Wie war das denn frueher? Da haben die Kinder im Fernsehen irgendwelche
+"Stars" und Sternchen gesehen und dann gesagt: "Ich will auch Popstar
+werden!" Und die Eltern haben gesagt: "Versuch das nicht! Jetzt ist er
+beruehmt, aber in 2 Jahren kraeht kein Hahn mehr nach ihm, dann haben die
+Produzenten mit ihm viel Geld verdient, und er hat keine Berufsausbildung,
+ein verbrauchtes Gesicht und keine Ahnung, wie er Geld verdienen soll."
+Aber weil sie das nur so behaupten konnten, hat das die Kinder nie so
+richtig beeindruckt. 
+
+Und jetzt koennen die Eltern ihren Kindern sagen: "Wenn du
+Profisporter/Saenger/Schauspieler wirst, musst du 10 Jahre spaeter, um
+deine Miete zu bezahlen, Insekten fressen, dich in einen "Kakerlakensarg"
+legen und dich in einer rotierenden Tonne mit Plastikfischen bewerfen
+lassen." Paedagogisch sollte das um Groessenordnungen wirkungsvoller
+sein. 
+
+Ciao,
+
+        Jan
+
+-----------------------------------------------------------------------------
+
+
+
+Nix fuer Leute unter 18. (Ronda, 13. Jul 2007, 00:10:42):
+From: =?UTF-8?B?UmVuw6k=?= <Kar98@The-Coalition.US>
+Newsgroups: de.etc.sprache.deutsch
+Message-ID: <2007070508172575249-Kar98@TheCoalitionUS>
+Subject: Re: sprachliche Bedeutung von "Kinderschaender"
+Date: Thu, 05 Jul 2007 13:17:25 GMT
+
+On 2007-07-05 05:22:58 -0500, Gunhild Simon <famsim2000@yahoo.de> said:
+
+> > On 5 Jul., 11:43, Matthias Opatz <spamfa...@online.de> wrote:
+>> >> Gunhild Simon schrieb:
+>> >> 
+>>> >>> (Ich kenne keinen wirklich sachlich angemessenen Begriff fuer
+>>> >>> Geschlechtsverkehr, der mit "schlafen", "lieben", ein "Fleisch sein",
+>>> >>> "nehmen" oder wie an dieser Stelle kuerzlich gelesen: "voegeln", 
+keine
+>>> >>> Verschleierung darstellte.)
+>> >> 
+>> >> Erkennen?
+> > 
+> > Fein, aber das setzt schon ein erweitertes Bewusstsein, eine echte
+> > Beziehung zum >Du<, voraus, das den meisten Lebewesen in eben dieser
+> > bruenstigen Situation verlorengeht.
+
+Oder ganz einfach Kenntnis einschlaegiger Texte, in denen "erkennen" als 
+Euphemismus fuer "hopste auf sie und sie trieben es miteinander, dass es 
+eine Lust war; mal war er oben, mal sie, auch wurde geloeffelt und 
+dergleichen; und wahrlich selbst die Haeschen auf dem Felde und die 
+Voegelein in den Baeumen machten grosse Augen" verwendet wird.
+
+-----------------------------------------------------------------------------
+
+
+
+Nicht lustig. (Ronda, 14. Jul 2007, 00:01:37):
+Echt nicht.
+
+Ronda
+
+From: Walter Jann <jehova@weibsvolk.org>
+Newsgroups: de.rec.tv.misc
+Subject: Re: Das weiss doch jedes Kind
+Message-ID: <24p6931boj4krckrnu464hqc4qccdjl48c@4ax.com>
+
+Guenter Hackel schrieb:
+
+> >Andreas.Tombrink schrieb:
+>> >> Aber anscheinend hattest du ja die Lust....einen herzlichen Dank dafuer
+:)
+>> >> 
+>> >> Was die Promis betrifft: ob selbsternannt oder nicht....die Quizshow 
+>> >> schiessen ja wie Pilze aus dem Boden...
+> >
+> >Ich haette da noch eine Idee fuer ein Sendeformat auf das die Welt wartet: 
+> >Eine Quizshow waehrend der gekocht wird.
+> >(duck)
+
+Lagweilig. Zumindest in dieser reduzierten Form.
+
+Ich schlage eine Kochshow vor, bei der Quizfragen beantwortet werden
+muessen, waehrend gleichzeitig der Garten der Gastgeber umgebaut und die
+Wohnung renoviert wird. Gleichzeitig werden die missratenen Kinder samt
+unerzogenem Hund therapiert. Das ganze findet natuerlich im Ausland
+statt, da besagte Familie ausgewandert ist und  der Familienvater im
+Ausland einen Job sucht, der als Preis der Kochshow wartet. Alternativ
+waere auch ein Ausbildungsplatz fuer eines der Kinder denkbar. Bei falsch
+beantworteten Fragen hat die Familie die Moeglichkeit, durch von Experten
+bewerteten Tanzeinlagen doch noch zu punkten.
+
+Das ganze findet ueber drei Monate in einem Container statt und alle zwei
+Wochen wird ein Familienmitglied nominiert und von den Zuschauern
+entweder rausgewaehlt (nach Deutschland zurueck geschickt) oder muss eine
+besondere Herausforderung bestehen - z.B. bei einer Castingshow
+vorsprechen oder einen Modelvertrag ergattern.
+
+Walter
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Bambi! (Bambi, 14. Jul 2007, 23:00:56):
+~#! rn=Ronda rt=1184100558 rg=schmarrn.netdigest
+~#! tid=1184100558
+Redet der vom Buch oder vom Film?
+Und wo wohnt der Drecksack eigentlich, der hier ueber meine Mutter herzieht?
+
+-----------------------------------------------------------------------------
+
+
+
+Und wie ist das, wenn man farbenblind ist? (Ronda, 15. Jul 2007, 15:08:30):
+From: Thomas Mueller <newsgroupspam@elfstone.de>
+Subject: Re: Stromanbieter wechseln
+Newsgroups: de.rec.heimwerken
+Date: Wed, 11 Jul 2007 09:47:19 +0200
+Message-ID: <f721u7$geu$1@svr7.m-online.net>
+
+
+>> >> Mein neuer Stromanbieter hat bei mir am Tag des Wechsels einen
+>> >> Stromfilter installiert, der verhindern soll, dass noch Strom meines
+>> >> alten Anbieters durchkommt. Ansonsten koennte es passieren, dass ich
+zwei
+>> >> Rechnungen bekomme.
+ 
+> > Wenn du die gruen anmalst, filtern sie Atomstrom.
+
+Wenn man ein bisschen drueber nachdenkt, ist das natuerlich quatsch. Strom
+wechselwirkt ja elektromagnetisch ueber virtuelle Photonen. Wenn die
+Elektronen, die durch die Leitung kommen, gruen sind (also aus
+Solaranlagen etc.), wuerden sie mit der Farbe des Filters wechselwirken.
+Dadurch kommt es zu destruktiven Interferenzen, die gruenen Elektronen
+loeschen sich aus (Da kommt das Dualitaetsprinzip dazu, Elektronen koennen
+sich auch wie Wellen verhalten, und daher Interferieren). Du darfst den
+Filter also natuerlich nicht in Gruen anstreichen, sondern in der
+Komplementaerfarbe, also in Rot.
+Dadurch erzeugst du konstruktive Interferenzen, und verstaerkst den
+Oekostrom noch. Wenn du zuviel Farbe auftraegst, kann es aber zur
+Resonanzkatastrophe kommen. Geraete ohne CE-Zeichen koennen dann schonmal
+durchbrennen.
+
+Damits doch noch was mit Heimwerken zu tun hat: Unbedingt wasserloesliche
+Farbe verwenden, durch den Dipolcharakter vom Wasser ist der Effekt
+groesser.
+
+-----------------------------------------------------------------------------
+
+
+
+Voll die Verbannung, ej! (Ronda, 16. Jul 2007, 22:45:53):
+Nicht aus de.alt.netdigest, sondern grad in meiner Mailbox aufgeschlagen.
+
+Ronda
+
+Subject: Das neue Internet-Verzeichnis
+
+Geehrter Kunde!
+
+Wir vertreten Ihrer Aufmerksamkeit das neue Verzeichnis der europaischen
+Internete-Ressourcen.
+
+Um Ihre Web-Seite zu erganzen, kommen Sie nach dieser Verbannung:
+http://[geloescht].net/add/
+
+Hochachtungsvoll,
+[geloescht].net
+
+-----------------------------------------------------------------------------
+
+
+
+Local PR (Ronda, 17. Jul 2007, 23:15:20):
+Newsgroups: de.etc.bahn.eisenbahntechnik
+Subject: Re: Technik DB Nachtreisezug
+From: Helmut Barth <Helmut.Barth@arcor.de>
+Date: Fri, 06 Jul 2007 23:52:56 +0200
+Message-ID: <468eb8db$0$3828$9b4e6d93@newsspool4.arcor-online.net>
+
+Salut!
+
+Reinhard Greulich schrieb:
+> > 
+> > Ich dachte dabei mehr an die PR-Aktivitaeten. Ein wenig aufwaendiger als
+> > beispielsweise die Taurus-Fahrt sind die ja durchaus gestaltet. In
+> > Deutschland gilt ja schon als Geldverschwendung, wenn bei einem
+> > Roll-Out eine Styroporwand durchfahren wird oder vier kleine
+> > Feuerwerkskoerper abbrennen.
+
+Waehrend die Franzosen bei so einer Veranstaltung einen Rekord einfahren,
+das ganze mit Interviews und TV- Reportagen aus zig verschiedenen Orten 
+und Winkeln wuerdigen und das Bueffet leeren, ist man in Deutschland auch 
+noch mit der Organisation der Brandschutzmassnahmen bezueglich des 
+Abbrennens von Feuerwerkskoerpern innerhalb geschlossener Gebaeude bei 
+Anwesenheit von 100+x Personen gemaess der Bayer. Brandschutzrichtlinie 
+unter besonderer Beruecksichtigung der Anwesenheit groesserer 
+Menschenansammlungen ausserhalb eines (feuer-)polizeilich kontrollierten
+Veranstaltungsortes unter oder neben Hochspannungsfuehrenden Leitungen 
+ueber 1000V beschaeftigt. Oder vielmehr mit der Wahl des Vorsitzenden des 
+Ausschusses zur Organisation oben angefuehrter Massnahmen nach 36a Vers 
+22 derselben Brandschutzrichtlinie..
+
+Und dann wollen die etwa noch Champagner ausschenken? Alkohol? 
+Jugendschutz? Eine bewegte Lokomotive? Aber Hallo ..
+
+Gruessle, Helmut
+
+P.S.: Die oben genannte Bayer. Brandschutzrichtlinie ist fiktiv und 
+steht stellvertretend fuer die vielen kleinen buerokratischen Hindernisse 
+mit denen in unserem Nachbarland und in vielen suedlichen Laendern etwas 
+unbeschwerter umgegangen wird.
+
+Dieser Hinweis nur fuer die Pedanten, die meinen gemaess der 
+ungeschriebenen Usenetrichtlinie ueber Quellenangaben in Usenetartikeln 
+unter besonderer Beruecksichtigung der Beispielhaftigkeit und des 
+Satiregehalts eines Beitrages mehr ueber jene Brandschutzrichtlinie 
+recherchieren zu muessen.
+
+-----------------------------------------------------------------------------
+
+
+
+Sicherheit von KKW (Ronda, 22. Jul 2007, 23:19:09):
+Message-ID: <54j2n4-19q.ln1@zaphod.michaelkrauth.de>
+From: Michael Krauth <dropspamhere@gmx.net>
+Subject: Re: "Die Sicherheit von KKWs haengt nicht von derem Alter ab."
+Newsgroups: ger.ct
+Date: Thu, 19 Jul 2007 01:08:21 +0200
+
+Herwig Huener AQSR wrote:
+
+> > Wieviel Verleugnung von sogar trivialer
+> > LebensErfahrung braucht man fuer diese
+> > Aussage?
+
+Anders gesagt: "Auch neue Kraftwerke koennen hochgehen".
+Finde ich sehr ehrlich.
+
+-----------------------------------------------------------------------------
+
+
+
+Portativitaetskoeffizient (Ronda, 22. Jul 2007, 23:25:10):
+[ From: "Helmut P. Einfalt" <helmut.p.einfalt_NOSPAM@NOSPAM_aon.at>        ]
+[ Newsgroups: de.etc.sprache.deutsch                                       ]
+[ Message-ID: <4695bdf6$0$24601$91cee783@newsreader02.highway.telekom.at>  ]
+
+Matthias Opatz beliebte zu schreiben :
+
+> > Hab ich Dich schon aufs Repunsieren gestossen?
+> > => http://www.ilmferien.de/repunsel.gif
+
+Dazumal, im Studentenheim, da hatten wir einen, der hat *jedes*
+Fremdwort, das ihm unterkam, sofort in seinen Wortschatz (naja)
+integriert, so wie heute die Gastwirte, die nicht mehr von "Kwisien"
+reden, sondern von "Kulinarik", woil das ist foiner, net wahr.
+
+Da haben wir eines Abends im Buffet beim n-ten Bier (n>5 oder so) den
+Portativitaetskoeffizienten erfunden, den Bringungsfaktor.
+
+Im Oesterreichischen, wenn eine Sache erfolgreich oder auch nur
+erfolgversprechend ist, kann man sagen "das bringt's!", im gegenteiligen
+Fall hingegen "Das bringt's aber ueberhaupt net!". Im ersteren Fall ist
+dann der Bringungsfaktor 1 ("Diese Loesung ist maximal portativ"), im
+letzteren Fall ist der Portativitaetskoeffizient eben gleich null. Und
+bei allem dazwischen kann man von "restringiert portativ" und
+"limitierter Portativitaet" reden und von was einem sonst noch einfaellt.
+
+Die Wortfamilie wurde natuerlich *ohne* Erklaerung unters Volk gestreut,
+garniert mit ein bisserl Vapourtalk (damals noch unueblicher Begriff fuer
+"Dampfplaudern") -- es hat genau vier Tage gedauert, bis unser Freund es
+auch verwendet hat, und nach etwas ueber einer Woche hats schon die halbe
+SoWi-Fakultaet eingesetzt...
+
+Helmut
+
+-----------------------------------------------------------------------------
+
+
+
+Waschmaschinenfertigerkennungsloesungsversuche (Ronda, 12. Aug 2007, 14:55:35):
+From: Christian Mueller <spamalottomat@yahoo.de>
+Newsgroups: de.sci.ing.elektrotechnik
+Subject: Re: Wann ist die Waschmaschine fertig?
+Date: Sat, 11 Aug 2007 12:09:39 +0200
+Message-ID: <5i5g8rF3mu5qbU1@mid.individual.net>
+
+Matthias Hanft schrieb:
+
+> > wir moechten von unserer Waschmaschine gerne benachrichtigt
+> > werden, wenn sie fertig ist
+
+> > Die Waschmaschine selbst hat sogar eine gelbe Lampe, mit der
+> > sie den Zustand "fertig" anzeigt
+
+Bei einem Signal, was schon digital vorliegt, wuerde ich nicht
+lange ueberlegen und dieses direkt nach einer galvanischen
+Trennstufe in den PC leiten.
+Abhaengig von der Spannung, die fuer die Lampe verwndet wird,
+kannst du ein einfachst zu verschaltendes Relais oder einen
+etwas aufwaendigeren Optokoppler nehmen.
+Auf der Strecke Optokoppler/Relais nach PC kannst du ja eine
+so hohe Spannung verwenden, dass dein Mittelwellenempfang keine
+Fehlausloesung erzeugt.
+Alle anderen (*) Loesungen halte ich fuer zu unsicher (in der
+Erkennung) oder zu teuer.
+
+
+Gruss Christian
+
+
+(*)
+- die elektrische2: Ein Sensor misst den Stromverbrauch der Maschine
+- die optische: Fototransistor auf dem Gehaeuse
+- die akustische: Ein Mikro mit einem Schwellwertschalter
+- die mechanische: Ein Rumpelpumpelsensor erkennt das Endchleudern
+- die edv-ische: Eine WebCam filmt die Trommel/das Programmfeld
+- chemische: Ein Sensor misst im Abwasser die Konzentration vom
+              Weichspueler (oder einem anderen Indikator, falls du
+              keinen Weichspueler verwendest (zB Koenigswasser))
+- die rockefellerische: Neue Maschine mit Interface kaufen
+- die kapitalistische: "Sohn, hier sind 50 Cent fuers Nachsehen"
+- die paedodidaktische: "Sohn, du siehst jetzt nach!"
+- die WG-ische: "Ich faends echt dufte, wenn mal jemand nachsieht"
+- die hellseherische
+- die geduldische: Neben der Maschine warten, bis sie fertig hat
+
+-----------------------------------------------------------------------------
+
+
+
+Klavierbesitzer habens einfacher! (Ronda, 12. Aug 2007, 14:57:37):
+Ist so nen Fluegel nicht super-schwer zu spielen, wenn er hochkant ueberm
+Balkon steht beim Spielen?
+
+Ronda *rumfluegelnd... aeh... rumflegelnd*
+
+From: Volker Gringmuth <einklich@gmx.net>
+Newsgroups: de.rec.musik.machen
+Subject: Re: Fluegel zu verschenken ...
+Date: Wed, 8 Aug 2007 11:56:02 +0000 (UTC)
+Message-ID: <Xns99868DBB5C6F4bx@h2.einklich.net>
+
+
+Radbert Grimmig wrote:
+
+> > Aber Beine abbauen geht doch, oder? Dann stell ichs mir hochkant ueber
+> > den Balkon einfacher vor.
+
+Ja, Beine und Pedalerie lassen sich normalerweise abnehmen.
+
+Manchmal ist es aber einfacher, um den Fluegel herum ein neues Haus zu
+bauen.
+
+
+vG
+
+-----------------------------------------------------------------------------
+
+
+
+Hildegard spielt Bratsche (Ronda, 12. Aug 2007, 14:58:41):
+From: Oliver Jennrich <oliver.jennrich@gmx.net>
+Newsgroups: de.alt.talk.unmut
+Subject: Re: Hildegard hat Geburtstag
+Message-ID: <a1fhcnbggkq.fsf@ID-371.news.uni-berlin.de>
+
+spam.for.the@buerotiger.de (Peter Lemken) writes:
+
+> > Oliver Jennrich <oliver.jennrich@gmx.net> wrote:
+>> >> spam.for.the@buerotiger.de (Peter Lemken) writes:
+>> >> 
+>>> >>> Oliver Jennrich <oliver.jennrich@gmx.net> wrote:
+>>>> >>>> Eva Kornmann <eva.kornmann@gmx.de> writes:
+>>>> >>>> 
+>>>>> >>>>> Ich kenne diese Hildegard zwar nicht, aber in meiner Nachbarschaft
+>>>>> >>>>> hoeren sie nicht auf, ihr zu Ehren zu singen.  Beziehungsweise zu
+>>>>> >>>>> quieken. Warum halten sich Frauen eigentlich immer fuer Sopran?
+>>>> >>>> 
+>>>> >>>> Weil alle die, die im Chor schon mal im Alt gesungen haben, das nie,
+>>>> >>>> nie, nie wieder tun wollen. Dann schon lieber Bratsche spielen.
+>>> >>>
+>>> >>> Wo ist da der Unterschied?
+>> >> 
+>> >> Du weisst doch, im Falle eines Falles kann man sie nach hinten
+>> >> setzen...
+> >
+> > Dort wird sie vom Schlagzeuger erschlagen, so wie es sich gehoert.
+
+Bratscher setzt man ein Pult nach hinten, *nachdem* sie verstorben
+sind.
+
+-----------------------------------------------------------------------------
+
+
+
+Doom und kleine Bits (Ronda, 12. Aug 2007, 14:59:44):
+From:       Dirk Wolfgang Glomp <dirk@freecrac.dyndns.org>
+To:         de.rec.spiele.computer.action
+Date:       Mon, 6 Aug 2007 16:38:12 +0200
+Subject:    Re: RTCW - wo noch kaufen?
+Message-ID: <16g2lux82vwef.1g2c3qb97vbt9$.dlg@40tude.net>
+
+Am Mon, 06 Aug 2007 10:29:24 +0200 schrieb Klaus Fischer:
+
+> > Am 05.08.2007 14:55 schrieb Sebastian Adamczyk:
+> > -- 
+> > DOOM3: Aber warum laeuft das Spiel in 32 Bit, wenn 3 Bit reichen wuerden:
+> > Totalschwarz - Dunkelschwarz - Schattenschwarz - Normalschwarz - Nicht
+> > Ganz So Schwarz - Rot - Gruen - Blau
+
+Ein kleines Bit hat auch Gefuehle.
+Weil zwischen Dunkelschwarz und Normalschwarz die Schatten lauern und wenn
+man nicht aufpasst irgendetawas Totalschwarzes einen rot, gruen und blau
+beisst und "Nicht Ganz So Schwarz"  sich in den restlichen 29 Bit deswegen
+sicherer fuehlen.
+
+Dirk
+
+-----------------------------------------------------------------------------
+
+
+
+Nudelsalat ist XXX! (Ronda, 12. Aug 2007, 15:12:21):
+From: "Martin Draheim" <M.Draheim@directbox.de>
+Subject: Re: T-Online sperrt Ferkelseiten! :-)
+Newsgroups: de.comm.provider.misc
+Date: Wed, 1 Aug 2007 07:08:42 +0200
+Message-ID: <46b01550$0$3832$9b4e6d93@newsspool4.arcor-online.net>
+
+> > Probier mal aus, ob Du auf die Seiten
+
+> > http://de.wikipedia.org/wiki/Sussex
+                                  
+> > kommst. Dann wissen wir, wie doof der Filter ist. :-)
+
+Wuerde mich auch mal interessieren
+
+LG; Martin, der gerade die mitgelieferten Filter einer 
+"Jugendschutzsoftware" veraendern musste, weil das an Kochen 
+interessierte Kind voellig eingeschraenkt war. "Nude"lsalat war tabu, von 
+"heiss"em Fett ganz zu schweigen. Sehr erotisch. *autsch!*
+
+-----------------------------------------------------------------------------
+
+
+
+10 kleine Negerlein (Ronda, 12. Aug 2007, 15:16:02):
+From: Volker Gringmuth <einklich@gmx.net>
+Newsgroups: de.alt.arnooo
+Subject: Re: Tarnung
+Message-ID: <f8g62o.19c.1@h1.einklich.net>
+
+Wolfgang Jaeth <jawo.usenet.008@goldmail.de> wrote:
+
+>>>>> >>>>> In die Klinik unter Palmen?
+>>>> >>>>
+>>>> >>>> Hinter den sieben Buergen?
+>>> >>>
+>>> >>> Und dann neun Mal klug sein.
+>> >>
+>> >> Wie heisst eigentlich "10 kleine Negerlein" heute Politisch Korrekt?
+> >
+> > Selbsthilfegruppe fuer Kinder mit Migrationshintergrund.
+
+"Hilfe" klingt aber herablassend. Ich wuerde 
+"Selbstherausforderungsannahmegruppe" sagen. 
+
+Und das diskriminierende "Kinder" ist durch "MitbuergerInnen mit 
+latentem Volljaehrigkeitspotential" zu ersetzen. 
+
+Die steinzeitliche "Kranke-Kinder-Selbsthilfegruppe" wuerde so zu einer 
+zeitgemaessen "Selbstherausforderungsannahmegruppe fuer persoenlich 
+Betroffene von medizinisch bedingten Herausforderungen an 
+MitbuergerInnen mit latentem Volljaehrigkeitspotential". 
+
+Ist doch gleich viel uebersichtlicherInnen.
+
+
+vG
+
+-----------------------------------------------------------------------------
+
+
+
+Ist der Monitor grade aus? (Ronda, 12. Aug 2007, 15:28:47):
+[SN: gekuerzt auf das wesentliche]
+
+From: Lothar Kimmeringer <news200707@kimmeringer.de>
+Subject: Re: Abfrage ob Monitor angeschaltet?
+Message-ID: <1ro5ojcbjgaho.dlg@kimmeringer.de>
+Newsgroups: de.comp.lang.java
+Date: Thu, 26 Jul 2007 11:39:41 +0200
+
+Stefan Offermann wrote:
+
+> > kann man eigentlich (moeglichst mit Java) abfragen ob der Monitor am PC 
+> > an oder ausgeschaltet ist?
+
+    _____________________________________________________
+   |_____________________________________________________|
+   |                                                     |
+   | Druecken Sie den Button, wenn Sie das Lesen koennen |
+   |                                                     |
+   |                       [OK]                          |
+   |_____________________________________________________|
+
+[...]
+
+Gruesse, Lothar
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Ist der Monitor grade aus? (Darklor, 12. Aug 2007, 15:30:07):
+~#! rn=Ronda rt=1186925327 rg=schmarrn.netdigest
+~#! tid=1186925327
+War die Frage wirklich so offensichtlich, oder steckte da noch mehr dahinter?
+
+DArklor
+
+-----------------------------------------------------------------------------
+
+
+
+Local Habits. (Ronda, 19. Aug 2007, 21:48:22):
+Message-ID: <fa3hop$35u$4@piesbach.saarnet.de>
+From: Joerg Dorchain <joerg@dorchain.net>
+Newsgroups: de.alt.sysadmin.recovery
+Subject: Re: pure recovery
+Date: Fri, 17 Aug 2007 07:12:25 +0000 (UTC)
+
+Falk Willberg <Faweglassenlk@falk-willberg.de> wrote:
+
+> > Meine amerikanischen Verwandten schuetteln immer den Kopf, wenn ich
+> > erklaere, dass die vier Morde in Bochum nicht pro Woche stattfinden,
+> > sondern im Jahr.
+
+Hab ich mal in einem Touristenfuehrer fuer Europa gelesen unter local
+habits: "All murder cases are individually announced in the newspapers."
+
+Joerg
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Local Habits. (Darklor, 20. Aug 2007, 01:19:57):
+~#! rn=Ronda rt=1187552902 rg=schmarrn.netdigest
+~#! tid=1187552902
+Ah und dort stehen sie unter sonstiges?
+
+Darklor
+
+-----------------------------------------------------------------------------
+
+
+
+Tradition in der MPA? (Ronda, 25. Aug 2007, 20:27:30):
+From: Helmut Faugel <helmut.faugel@mnet-online.de>
+Newsgroups: de.rec.fotografie
+Subject: Re: Endlich Konkurrenz fuer Canon
+Date: Thu, 23 Aug 2007 17:25:03 +0200
+Message-ID: <fak8sf$25o2$2@gwdu112.gwdg.de>
+
+Gerrit Brodmann schrieb:
+> > "Erich A. Kremer" <ekhamlet@aol.com> wrote:
+>> >> Marco Grau <nekekami@on-luebeck.de> wrote:
+>>> >>> Sagt mal Leute, ist dieser Krieg, die Marke ist besser, die
+>>> >>> andere schlechter, nicht langsam Langweilig und Kindisch?
+>>> >>>
+>> >> Es ist TRADITION!
+> > 
+> > Tradition:
+> > 
+> > dumme und in der Regel unnuetze Handlung, welche man begeht, weil "sie
+> > schon immer so gemacht wurde" und von der keiner wirklich mehr  weiss,
+> > wo sie her kommt.
+
+Deine Postings haben auch schon Tradition ;-)
+
+-----------------------------------------------------------------------------
+
+
+
+Das klingt nach nem Landwirt-Consultant. (Ronda, 25. Aug 2007, 20:28:30):
+From: Wolfram Heinrich <theodor.rieh@freenet.de>
+Subject: Re: laufend oder laufenden
+Newsgroups: de.etc.sprache.deutsch
+Date:Fri, 24 Aug 2007 10:14:40 +0200
+Message-ID: <1bxtd9sdahma$.dlg@www.theodor-rieh.de>
+
+> > Mag sein, meine Erfahrung ist, dass die meisten Lehrer von LRS oder
+> > Legasthenie nicht den Hauch von Ahnung haben. O-Ton Oberstudiendirektor
+> > eines humanistischen Gymnasiums auf den Hinweis des relativ hohen IQ
+> > meines Sohnes: "Warum ist er dann Legastheniker?"
+
+Im Ernst? Obwohl - neulich in der Sendung stern-tv von Guenter Jauch haben
+sie Leuten auf der Strassen einige Fragen gestellt, u. a. die, an welchem
+Fluss wohl Frankfurt an der Oder liege. Die Befragte hatte keine Ahnung! Und
+ein junger Mann, der in Kuerze seinen Abschluss als Landwirt (!) machen
+wollte, wusste nicht, wie denn (so ungefaehr) Sauerkraut auf dem Feld
+aussehe. Hingemalt hat er ein Wuerzelchen, aus dem lauter duenne Faedchen nach
+oben wuchsen. Auf die irritierte Nachfrage der Reporterin meinte er, diese
+Faedchen wuerden dann erdnah abgeschnitten...
+
+Manchmal ist es beruhigend zu sehen, dass nicht nur Akademiker dumm sind.
+
+-----------------------------------------------------------------------------
+
+
+
+Echt hart, der Wiener Humor (Ronda, 25. Aug 2007, 20:29:52):
+From: Michael Pronay <me@privacy.net>
+Subject: Re: Werbesprueche
+Newsgroups: de.etc.sprache.deutsch
+Date:Fri, 24 Aug 2007 10:12:23 +0200
+Message-ID: <Xns999667D247FF0pronaygmxat@pronay.com>
+
+> > Online-Werbung fuer Viagra und Cialis:
+> > Man Lebt nur einmal - probiers aus !
+
+Apropos:
+
+Hier in Wien gibt's Fahrradstaender fuer gratis entleihbare 
+"City Bikes", versehen mit der Werbetafel eines Sponsors. 
+Eine sieht so aus (Mittelteil als blauen Rhombus denken):
+
+ ____________________________________
+|                                    |
+|     Diesen Staender widmet Ihnen    |
+|              ________              |
+|             /        \             |
+|            <  Pfizer  >            |
+|             \        /             |
+|                            |
+|         www.sexistgesund.at        |
+|____________________________________|
+
+Wie ich's das erste Mal gesehen habe, hab' ich schallend 
+gelacht.
+
+-----------------------------------------------------------------------------
+
+
+
+Schoen scharf! (Ronda, 25. Aug 2007, 20:30:45):
+From: Ralf Brinkmann <spam.ralf.brinkmann.wiesbaden@t-online.de>
+Subject: Re: Keramikmesser 29.8. AN
+Newsgroups: de.alt.fan.aldi
+Date: Fri, 24 Aug 2007 21:29:12 +0200
+Message-ID:
+<1i3skzr252yo8$.dlg@ralf.brinkmann.wiesbaden.dialin.t-online.de>
+
+Hallo *Dorothee Hermann*, Du meintest:
+
+> > Messer wie auch Pfannen werden grundsaetzlich mit der Hand abgewaschen,
+> > ich kann sie selbst schaerfen.
+
+Welchen Vorteil bringen scharfe Pfannen? Kann man dann die
+klodeckelgrossen Schnitzel gleich mit der Pfanne aus dem Vieh
+rausschlagen?
+
+Gruss, Ralf
+
+-----------------------------------------------------------------------------
+
+
+
+Weltmeisterschaft (Ronda, 28. Aug 2007, 20:32:07):
+From: Harald Boibe <h-boi@web.de>
+Subject: Weltmeisterschaft
+Newsgroups: de.talk.jokes
+Date: Fri, 24 Aug 2007 14:31:36 +0200
+Message-ID: <famj31$6k6$01$1@news.t-online.com>
+
+Verehrte Besucher dieser Newsgroup,
+
+ich erhalte seit einigen Monaten freundliche Mails von einem Herren, der
+mir bestimmte Pharmazeutika anbietet. Ich koennte damit, so seine 
+Ausfuehrungen, "ficken wie ein Weltmeister".
+
+Nun stellt sich mir die Frage, welcher Weltmeister gemeint ist. Ist es 
+der Weltmeister im Kirschkernspucken? Und woher weiss ich denn, ob es 
+anstrebenswert ist, beim Geschlechtsverkehr genauso wie eben dieser zu 
+verfahren? Ist der Weltmeister im Bullriding gemeint? Aber vielleicht 
+hat jener durch seine Sportart Schaedigungen im Genitalbereich, so dass 
+es gerade untunlich waere, ihm nachzueifern.
+
+Oder, dieser Gedanke kam mir jetzt, ist ggf. der Fick-Weltmeister 
+gemeint? Dies wuerde mich allerdings vor die Erkenntnis stellen, dass ich
+schlecht informiert bin. Denn Ort und Zeit der Fick-Weltmeisterschaft 
+sind mir komplett verborgen geblieben, geschweige denn die Termine der 
+Vorrunde. Auch ob es sich um ein K.o-Verfahren handelt oder eine 
+Punktewertung, weiss ich nicht. Eigentuemlich, denn die Bild-Zeitung haette
+ueber dieses internationale Top-Event doch sicher ausfuehrlich berichtet. 
+Daher frage ich Sie, meine verehrten Damen und Herren, wer denn der 
+amtierende Fick-Weltmeister ist und mit welchen konkreten Leistungen er 
+sich den Titel verdient hat.
+
+In der Hoffnung auf aufklaerende Erlaeuterungen verbleibe ich
+
+hochachtungsvoll
+
+HB
+
+-----------------------------------------------------------------------------
+
+
+
+Buerokratie. Boese. Konsequent. (Ronda, 28. Aug 2007, 20:33:08):
+Newsgroups: de.soc.recht.arbeit+soziales
+Subject: Buerokratiewahnsinn
+From: "John Gawe" <wegasoft@gmx.de>
+Date: Sun, 26 Aug 2007 09:31:10 +0200
+Message-ID: <fara4j$mo5$00$1@news.t-online.com>
+
+
+Leider gibt es keine Gruppe "de.buerokratie" oder "de.buerokratie.wahnsinn".
+Da wuerde folgender Text einen Spitzenplatz einnehmen:
+
+<ZITAT>
+"
+Als mein Vater starb, kam 2 Wochen spaeter ein Schreiben seiner privaten
+Krankenkasse:
+
+Sehr geehrter Herr xxx,
+
+da laut unserer Versicherungsbedingungen nur Leistungen, die der Gesundung
+dienen, erstattet werden, muessen wir Sie bitten, die Bescheinigung ueber
+Ihren Tod selbst mit dem betreffenden Arzt abzurechnen, da hier keine
+Gesundung mehr zu erwarten ist  .
+
+Mit freundlichen Gruessen und gute Besserung
+
+Ihre xxxVersicherung
+"
+</ZITAT>
+
+John
+(Quelle kann nachgereicht werden)
+
+-----------------------------------------------------------------------------
+
+
+
+Prozente (Ronda,  1. Sep 2007, 20:54:41):
+Hm. Ich hab zuerst gelesen "80% aller Soziologiestudenten sind veraltet"...
+
+Ronda
+
+From: Volker Gringmuth <einklich@gmx.net>
+Newsgroups: de.rec.musik.machen
+Subject: Re: Interesse fuer 'Musik machen' und andere Interessen
+Date: 31 Aug 2007 14:49:20 GMT
+Message-ID: <Xns999DAB1A447A2bx@h2.einklich.net>
+
+
+Benno Hartwig wrote:
+
+>>> >>> Und: 80% aller Soziologenstudien sind veraltet
+>> >>
+>> >> Vor allem sind 100% aller Pauschalaussagen falsch.
+> >
+> > und 37,3% alle Umfrageergebnisse sind frei erfunden!
+
+Zudem weisen 28,674738259136067235783942432151% aller Prozentangaben
+eine unrealistische Genauigkeit auf.
+
+
+vG
+
+-----------------------------------------------------------------------------
+
+
+
+Nie wieder Batman-Filme! (Ronda,  1. Sep 2007, 20:56:48):
+Irgendwie muss ich dabei an den Fasan denken, den ich auf der Autobahn direkt
+vom Elbtunnel "erlegt" habe. Sah echt aus wie beim Moorhuhn-Schiessen *seufz*.
+Und falls sich wer wundert, das es beim Elbtunnel Fasane gibt: jetzt nicht
+mehr :-(
+
+Ronda
+
+From: Josef Schabrotzki <schabrotzki@hotmail.de>
+Subject: Batman ends
+Newsgroups: de.rec.motorrad
+Date: Fri, 31 Aug 2007 09:30:19 +0000 (UTC)
+Message-ID: <Xns999D751BB1A8schabrotzki@139.23.33.23>
+
+Hi,
+
+wenn Ihr euch wundert warum es keine Batman Filme mehr geben wird, ich
+bin 
+schuld.
+
+Gestern abend habe ich Ihn gekillt.
+
+Was flattert der auch direkt vor meine Lampe und knallt dann gegen den
+Helm. Hab mir zwar fast in die Hosen gemacht, aber im Kino sieht der
+Kerl 
+echt groesser aus. Hollywood halt.
+
+-----------------------------------------------------------------------------
+
+
+
+Mumien (Ronda,  2. Sep 2007, 16:41:13):
+Subject: Re: Bandgruendung Ruhrgebiet
+Date: Fri, 31 Aug 2007 21:31:04 +0200
+From: Volker Gringmuth <einklich@gmx.net>
+Newsgroups: de.rec.musik.machen
+Message-ID: <fba1ao.qs.1@marvin.einklich.net>
+
+"GildaSR" <g.s-r@freenet.de> wrote:
+
+> > 2 Akkordeonistinnen (midifiziert) 
+
+Aus irnkwelchen Gruenden hab ich erst "mumifiziert" gelesen.
+
+
+vG
+
+-- Ceterum censeo Popocatepetlum non in Canada sed in Mexico situm esse.
+<http://einklich.net> 
+
+-----------------------------------------------------------------------------
+
+
+
+Office-Daus (Ronda,  4. Sep 2007, 21:53:42):
+... wer kennt noch "nettere" Geschichten?
+
+Ronda
+
+From: Karl Voit <devnull@Karl-Voit.at>
+Newsgroups: de.comp.sys.mac.misc
+Subject: Dumme Officeuser (was: [OT] Re: iWork08)
+Date: Thu, 23 Aug 2007 15:48:08 +0200
+Message-ID: <2007-08-23T15-46-47@devnull.Karl-Voit.at>
+
+This is getting funny :-)
+
+* Daniel Krebs <spam.astacus@t-online.de> wrote:
+> >
+> > Und ich kenne jemanden, der/die Excel- Tabellen sortiert, indem er/sie
+> > diese ausdruckt, in Streifen schneidet, und die Streifen sortiert auf
+> > ein leeres Blatt klebt.
+> > Daniel
+
+Ich kenne eine Sekretaerin, die ihre komplette Korrespondenz in Excel
+verfasst, denn sie bekam einen Excel-Kurs bezahlt aber keinen
+Word-Kurs. Und im Excel kann man "viel besser die seitlichen Raender
+mit der Maus verschieben" ...
+
+-----------------------------------------------------------------------------
+
+
+
+Kulturradio-Hoerer sind aber auch doooooof! (Ronda,  4. Sep 2007, 22:07:43):
+Subject: Re: Sie haben Post!
+Date: Wed, 29 Aug 2007 13:53:28 +0200
+From: Dieter 'dtj-Hausmeister' Bruegmann <nutznetz@bruhaha.de>
+Newsgroups: de.talk.jokes
+Message-ID: <fb3too.7s.1@funk.bruhaha.de>
+
+juergen e. jaekel (Wed, 29 Aug 2007 12:32:58 +0200):
+
+> > Leiden Sie unter Verfolgungswahn?
+> > Fuehlen Sie sich ueberwacht?
+> > Werden Sie ausgespaeht?
+
+Schon lange. Im Rundfunk sagen sie mir immer "Sie hoeren das
+Kulturradio vom RBB". WOHER WISSEN DIE DAS?
+
+
+Da Didi
+
+-----------------------------------------------------------------------------
+
+
+
+Mit Troy (-Quests) zur Erleuchtung? (Ronda,  4. Sep 2007, 22:20:10):
+Betreff: Re: LED Strahler vs Energiesparstrahler
+Absender: Rolf_Bombach <rolfnospambombach@bluewin.ch>
+Datum: Mon, 03 Sep 2007 19:58:34 +0200
+Newsgruppe: de.sci.ing.elektrotechnik
+Message-ID: <46dc4b4c$1_2@news.bluewin.ch>
+
+Martin Lenz schrieb:
+> > 
+> > So wie Phillips 23W CoolWhite in Spiralform auf der Packung als "Turbo
+> > Energysaver, entspricht 125W" bezeichnet wurden. Daneben standen
+> > offensichtlich neuere Packungen mit der gleichen Lampe, gleiche
+> > Leistungs- und Lichtstrom angabe, auf denen "Super Turbo Energysaver,
+> > entspricht 130W" stand. Also was jetzt?
+
+Altes Modell versus neues. Der noch neuere Super Turbo Euro Energysaver
+bringt das Licht von 135 W, der ganz neue Super Turbo Euro Bio
+Energysaver 140 W, der brandneue Super Turbo Euro Bio Nano
+Energysaver 145 W und der fuer Oktober angekuendigte Super Turbo
+Euro Bio Nano Eco Energysaver 150 W.
+Der naechstes Jahr herauskommende Super Turbo Euro Bio Nano Eco
+Energysaver extra plus (185 W) hat Solarzellen an der Fassung,
+welche mehr Strom produzieren, als die Lampe aufnimmt. Sie muss
+daher mit einer mindestens gleich starken Gluehlampe parallel
+betrieben werden, damit beim Ausschalten die Ultraviolett-
+Katastrophe nicht eintritt.
+Einen andern Weg beschreitet die Super Turbo Euro Bio Nano Eco
+Energysaver plus exra dot net (R) mit eingebauten PLC-Webinterface
+und Mailclient, welche ausschliesslich durch einen Spamtrap
+mit Strom versorgt wird.
+Eine weitere Version, welche ueberschuessigen Strom aus geheim
+gehaltenen Quellen ins Netz zurueckspeisen soll, wird angeblich
+unter dem Tarnnamen "Fedaral Lights of Troy" entwickelt.
+
+Back to facts:
+Sind das die absolut grellen hellblauen mit Gewalt Kranken-
+hausatmosphaere verstrahlenden Schrauben? Die sind wirklich heftig;
+ich habe mit mir gerungen, ob ich so ein Ding kaufe. Allein fuer
+das Kuriositaetenkabinett, zur Beleuchtung Zuhause ist das eher
+eine Zumutung. Eventuell fuer den Keller, allerdings fuerchte ich,
+dass dann die Kartoffeln innert Minuten keimen ;-).
+
+-----------------------------------------------------------------------------
+
+
+
+alt.aeffle.und.pferdle (Ronda, 10. Sep 2007, 21:07:31):
+Ich find den Namen der Newsgroup fast besser als den Artikel...
+
+Ronda'le *wer hat da grad "Randale" gesagt?!*
+
+From: Ulli Horlacher <framstag@tandem-fahren.de>
+Newsgroups: alt.aeffle.und.pferdle
+Subject: Dialekt
+Date: Thu, 6 Sep 2007 06:04:23 +0000 (UTC)
+Message-ID: <fbo597$s8p$1@news.bawue.net>
+
+... und am 8.Tag erschuf Gott die Dialekte.
+Alle Voelkchen waren gluecklich.
+Der Berliner sagte: "Icke hab nenn wahnsinns Dialekt, wa?"
+Der Hanseate sagte: "Moin Dialekt ist dufte, ne!"
+Der Koelner sagte: "Hey, du Jeck, mit Koelsch feiert man Karneval!"
+Der Hesse sagte: "Babbel net, di Hessa babbeln des best
+Hochdeutsch!"
+Der Sachse sagte: "Ja nu freilisch is aes Saechsisch klosse!"
+Nur fuer den Schwaben war kein Dialekt uebrig.
+Da wurde der Schwabe traurig......
+Irgendwann sagte dann Gott: "Was solls, no schwaedscht hald wi I,
+Kerle!"
+
+-----------------------------------------------------------------------------
+
+
+
+TORBEN! (Ronda, 10. Sep 2007, 21:16:05):
+... Du sollst doch Beate-Marie nicht immer das Gunnar-Schaeufelchen auf den
+Kopf schlagen!
+
+Ronda
+
+From: Klaus Littmann <klaus@littmann.de>
+Subject: Re: Smaland
+Newsgroups: de.alt.fan.aldi
+Message-ID: <fboqp9$hkg$1@newsserver.rrzn.uni-hannover.de>
+Date: Thu, 06 Sep 2007 14:11:21 +0200
+
+[SN: "Smaland" ist die Kinderaufbewahrung bei IKEA]
+
+Lothar Frings schrieb:
+> > Katharina Mayer tat kund:
+
+> >
+>>> >>> Also jetzt heisst die Durchsage: "Der kleine Maik-Kevin
+>> >> mit der Nummer 123
+> >
+> > Mal im Ernst: Die Blagen kriegen jetzt _Nummern_?
+> > Na ja, eigentlich nur konsequent, wenn da sechs Lukasse
+> > und acht Leonies rumturnen.
+> >
+
+Gestern im IKEA Hannover noch ohne Nummern.
+Kommentar zweier Leute, als "die kleine Maike-Christine" ausgerufen
+wurde: "Nee, die nehm' wir nich, der Name ist doof!"
+
+Klaus
+
+-----------------------------------------------------------------------------
+
+
+
+Re: alt.aeffle.und.pferdle (Eljo, 10. Sep 2007, 21:18:24):
+~#! rn=Ronda rt=1189451251 rg=schmarrn.netdigest
+~#! tid=1189451251
+Rondale ischd klasse, den muss ich mir merken. :-)
+
+-----------------------------------------------------------------------------
+
+
+
+Re: alt.aeffle.und.pferdle (Darklor, 11. Sep 2007, 02:48:30):
+~#! rn=Ronda rt=1189451251 rg=schmarrn.netdigest
+~#! tid=1189451251
+Und was is mit den Thueringer Dialekt?
+
+Darklor
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: alt.aeffle.und.pferdle (Humni, 12. Sep 2007, 17:09:09):
+~#! rn=Darklor rt=1189471710 rg=schmarrn.netdigest
+~#! tid=1189451251
+Oder dem Heidenhuser Dialekt
+
+Humni "ja, das Schild soll erbut heissen!" der Drache
+
+-----------------------------------------------------------------------------
+
+
+
+Clown gefruehstueckt. (Ronda, 15. Sep 2007, 15:24:39):
+Die Leipziger Polizei hat einen Pressemenschen, der regelmaessig Clowns
+fruehstueckt - unter u.a. Link findet man etliche Texte dieser Art...
+
+Ronda
+
+From: Klaus Herzberg <klausherzberg@gmail.com>
+Newsgroups: de.rec.fahrrad
+Subject: Polizeibericht aus Sachsen
+Message-ID: <46ea8206$0$31120$6e1ede2f@read.cnntp.org>
+
+Die Sachsen scheinen ein lustiges Volk zu sein, wenn sogar die Polizei 
+so schreibt:
+
+
+Ein 17-jaehriger Fahrradfahrer lenkte am heutigen Morgen (14.09.2007, 
+gegen 03:45 Uhr) durch seinen Stil die Aufmerksamkeit einer 
+Polizeistreife auf sich. Als die Beamten vom Georgiring in die 
+Brandenburger Strasse einbogen, wurden sie Zeugen einer Fahrweise, die 
+neben viel Zack leider zuviel Zick aufwies.
+
+
+http://www.polizei.sachsen.de/pd_leipzig/3669.htm
+
+mfg. klaus.
+
+-----------------------------------------------------------------------------
+
+
+
+Ein bisschen schwanger... (Ronda, 15. Sep 2007, 15:25:15):
+From: Hans-Juergen Meyer <spammermuell@gmx.de>
+Newsgroups: de.soc.recht.datennetze
+Subject: Re: Arcor: ploetzlich zensierter Internetzugang -> Kuendigungsrecht?
+Date: Wed, 12 Sep 2007 17:27:25 +0200
+Message-ID: <fc90gt$civ$1@news.albasani.net>
+
+Mathias Fuhrmann schrieb:
+> > Turan Fettahoglu schrieb:
+> >
+>> >> Moralische Bedenken braeuchte man in diesem Fall keine zu haben,
+>> >> aber...
+> >
+> > Entweder findet 'keine Zensur' statt, oder aber es gibt sie.
+> > Man kann auch nicht nur ein bisschen schwanger sein.
+> >
+Das habe ich frueher auch gedacht. Bis ich waehrend einer Zugfahrt
+unfreiwiller Zeuge eines Gespraeches wurde:
+
+A erzaehlte B, dass seine Frau schwanger waere. Er war dabei fuerchterlich
+am jammern wegen Geld knapp, viel Arbeit, Stress mit Frau usw.
+
+B grinste dabei die ganze Zeit und sagte dann:
+
+Stell Dich nicht so an. Das bischen schwanger ist doch nichts...
+
+Dies verwirrte A zusehends:
+Wieso ein bischen schwanger? Sie bekommt ein Kind das ist doch richtig
+schwanger. Ein bischen schwanger geht doch garnicht...
+
+Worauf B antwortete:
+Wir haben vor 2 Monaten Drillinge bekommen...
+
+Der Gesichtsausdruck von A war einfach goettlich.
+
+Hans-Juergen
+
+-----------------------------------------------------------------------------
+
+
+
+Giraffen und suesse Kaninchen (Ronda, 15. Sep 2007, 15:26:08):
+From: ram@zedat.fu-berlin.de (Stefan Ram)
+Subject: Gefaehrliche Woerter
+Newsgroups: de.etc.sprache.deutsch
+Date: 12 Sep 2007 10:00:35 GMT
+Message-ID: <Wortverbote-20070912115441@ram.dialup.fu-berlin.de>
+
+  Ein EU-Politiker will laut Heise pruefen
+
+      wie es moeglich ist, mit technischen Mitteln die Menschen
+      daran zu hindern, gefaehrliche Woerter wie , , oder zu
+      verwenden oder nach ihnen zu suchen
+
+http://www.heise.de/newsticker/meldung/print/95786
+
+  Das erinnert mich an
+
+      "We spent several weeks building a UI that used pop-downs
+      to construct sentences, and only had completely harmless
+      words - the standard parts of grammar and safe nouns like
+      cars, animals, and objects in the world." 
+
+      "We thought it was the perfect solution, until we set our
+      first 14-year old boy down in front of it. Within minutes
+      he'd created the following sentence: 
+
+            'I want to stick my long-necked Giraffe 
+            up your fluffy white bunny.'
+
+      KA-Worlds abandoned that approach.
+
+http://www.fudco.com/habitat/archives/000058.html
+
+-----------------------------------------------------------------------------
+
+
+
+Zahnfee runterhandeln?! (Ronda, 15. Sep 2007, 15:28:12):
+From: Ralf Kusmierz <me@privacy.invalid>
+Date: Tue, 11 Sep 2007 15:18:49 +0200
+Message-ID: <fc64jq$p50$1@online.de>
+
+[SN: Anstoss war die Wendung "Milchzaehne haltbar machen"]
+
+>> >> Wieso will man die haltbar machen? Ich dachte immer,
+>> >> die /sollen/ irnkwann rausfallen.
+> >
+> > Das schon, aber wenn man sie sammelt und wartet, bis die Zahnfee die
+> > Geschichte vergessen hat, kann man vielleicht noch einen weiteren Deal
+> > mit demselben Zahn machen; ist doch klar! Lernt man denn heutzutage
+> > gar nichts wichtiges mehr in der Schule?
+
+Das lernt man nicht in der Schule. Wobei es um die Zahnfee heutzutage
+schlecht bestellt ist: Unmittelbar nach obgemeldter Extraktion erhielt
+ich strikte kindliche Anweisung, mit meinen langen Erwachsenen-Armen
+stante pede ein bestimmtes Buch aus dem Buecherfach anzureichen, und
+gehorchte. Diesem Buch wurde dann ein Beutel aus feinem Stoff
+entnommen, in welchen der soeben verlorene Zahn gebettet und unter dem
+Kopfkissen deponiert wurde.
+
+Zwischenzeitlich hatte ich in dem Buch geblaettert und erfuhr den Sinn
+der Zeremonie: Das handelte naemlich von der Zahnfee, und mir wurde
+dann auch mdl. erlaeutert, wie eminent wichtig die Befolgung des Ritus
+sei, weil anders nicht naechstens das feenhafte Wesen kindlichen Zahn
+an sich nehmen und durch eine 1-Euro-Muenze ersetzen koenne ...
+
+Tja, und kurz darauf praesentierte das Kindchen dann stolz die
+Zahnluecke der Mama und berichtete von der feenbezogenen Verrichtung,
+und da fragt Frau Mama doch ganz harmlos, ob es denn an derlei
+feenhafte Handlungen glaube? Kleine Schrecksekunde, dann tapfer die
+ehrliche Antwort: "Das bist Du doch, Mama!" (Und Weihnachtsmann und
+Osterhasen hatte es schon in frueheren Jahren erwischt.)
+
+Mir wurde vom Feensekretariat zugetragen, dass die Zahnfee diesmal auf
+das Ansichnehmen des Opfers verzichten wird und knickerig, wie sie
+ist, die Glaeubigkeit nur durch das Hinzufuegen von fuenfzig Cents
+honorieren wird - kommt sie billiger, und gespart werden muss
+heutzutage ueberall ...
+
+
+Gruss aus Bremen
+Ralf
+
+-----------------------------------------------------------------------------
+
+
+
+Mnjam! (Ronda, 15. Sep 2007, 15:28:57):
+From: Alexander Bartolich <alexander.bartolich@gmx.at>
+Newsgroups: de.admin.news.groups
+Subject: Re: 1. RfD zur Einrichtung von de.rec.teich
+Date: Sun, 9 Sep 2007 10:30:35 +0000 (UTC)
+Message-ID: <fc0i0a$lcs$1@news.albasani.net>
+
+
+Jakob Creutzig schrieb:
+> > [...]
+> > Sind die Aquaristik-Fachleute wirklich der Ansicht, Aquarien
+> > waer alles, wo man Wasser und Fische reinwirft?
+
+Missgeschicke mit dem Thermostat kommen recht haeufig vor. Die Dunkel-
+ziffer ist hoch. Bekannt werden nur die wenigen, fuer den menschlichen
+Genuss geeigneten Unfallrueckstaende.
+
+http://de.wikipedia.org/wiki/Bouillabaisse
+
+-----------------------------------------------------------------------------
+
+
+
+Ampeln ampeln (Ronda, 15. Sep 2007, 15:32:36):
+... erinnert mich an den Artikel vor ewigen Jahren am 1. April in einer
+Bielefelder (sic!) Tageszeitung. Die haben geschrieben, dass man jede normale
+TV-Fernbedienung mit nem speziellen Chip umruesten kann, sodass man dann damit
+die Ampeln in BI schalten kann. Und das Polizeipraesidium wuerde eine
+Sonderaktion am 1.4. machen, dass man da fuer eine geringe Gebuehr den Chip
+eingebaut bekommt. Gab wohl ein bisschen Aerger mit der Polizei, weil so viele
+Dep... Buerger auf der Matte standen...
+
+Ronda
+
+From: lutz feustel <usenetmail@nurfuerspam.de>
+Newsgroups: de.alt.folklore.urban-legends
+Subject: Re: Baustellenampel mit CB-Funke umstellen
+Date: Sun, 09 Sep 2007 17:15:27 +0200
+Message-ID: <5kigboF3q0vsU1@mid.individual.net>
+
+
+ Claus Maedge <invalid@invalid.inv> wrote:
+
+> >Stand man an einer Baustellenampel, so konnte man diese durch geschicktes
+> >drucken mittels des "Triggers" auf Gruen umschalten. 
+
+> >Den Beweis blieben mir aber alle Schuldig ;-)
+
+Nicht ganz topic, aber wenn es schon mal um das Schalten von
+Gruenphasen geht:
+
+Ich hatte mal ne Funkuhr mit Sekundenanzeige im Auto und bemerkte
+irgendwann, dass die Ampeln auf meinem taeglichen Weg wirklich
+sekundengenau schalteten. Das konnte man auf verschiedenen Wegen
+nutzen. Zum einen war man immer als Erster ueber die Kreuzung hinweg,
+die Schrecksekunde ("Augen an Gehirn: es wird Gelb, Gehirn an Fuss:
+Auskuppeln) entfiel.  Auch wenn die zurueckbleibenden Karossenlenker
+ziemlich entgeistert meinen "Fruehstart" beobachteten. Ja ich weiss,
+gewisse Differenzen zwischen den Gruenphasen sind wichtig, um die
+"Hellrot"-Fahrer noch sicher rueberzubringen, aber um die Zeit kam da
+sowieso nie jemand*
+
+Zum Anderen konnte man aber auch uneingeweihte Beifahrern von der
+eigenen Wichtigkeit ueberzeugen. An die rote Ampel ranfahren, Handy
+zuecken, vorgeblich waehlen und dann "Ey, ich steh hier an der
+Kreuzung Soundso, schalt mal die Ampel auf gruen" ins Telefon
+befehlen. Prompt, gutes Timing vorausgesetzt, wurde die Ampel gruen.
+Weniger skeptische Zeitgenossen staunten nicht schlecht ueber meine
+"Verbindungen".
+
+* Ein Scherz....
+
+Lutz
+
+-----------------------------------------------------------------------------
+
+
+
+"Tatvorbereitungswaffe" und "Schnuller-Deal"? (Ronda, 16. Sep 2007, 19:11:52):
+... manchmal passen Thema und Inhalt nur bedingt zueinander. Oder?
+
+Ronda
+
+From: Astrid Schleicher <astrid.schleicher@gmx.de>
+Subject: Re: Tatvorbereitungswaffe
+Newsgroups: de.etc.sprache.deutsch
+Date:Fri, 14 Sep 2007 03:33:02 +0200
+Message-ID: <5ku6lkF5gsrfU1@mid.individual.net>
+
+>> >> Lernt man heutzutage in Deutschland etwas ueber die Zahnfee? Mir ist sie
+>> >> bisher nur in englischer Sprache begegnet.
+
+> >Man lernt es spaetestens, wenn es die eigenen Kinder aus der Schule
+> >mit nach Hause bringen.
+> >Da bei uns im Moment keine Zaehne ausfallen, sondern erst welche
+> >wachsen, durften wir erfahren, dass es auch eine Nuckelfee gibt,
+> >welchselbige naemlich den Nuckel wegnimmt und dafuer ein *cooles*
+> >Geschenk mitbringt.
+
+Seufz. Wie uncool, eine Nuckelfee ist doch reinstes Kinderverklapsen.
+Idealerweise geht das anders. Schliesslich nimmt man Kindern nichts
+einfach so weg, sondern nimmt sie in ihrer wachsenden Autonomie wahr
+und sehr ernst.
+
+Mein Vater hat einst im Garten gearbeitet, als sich das juengste der
+acht aeusserst wohlerzogenen Nachbarskinder am Zaun aufbaute und so
+freundlich wie hoeflich Konversation begann. Wie man halt so redet
+unter ganzen Maennern, blieb dann die Bemerkung des Aelteren nicht aus,
+der Zwerg -- vielleicht zwei -- sei doch schon viel zu gross fuer seinen
+Nuckel. Was er denn davon hielte, seinen Schnuller gegen einen schoenen
+grossen blanken Taler herzugeben. Kurzes Ueberlegen, wie es rationale
+Wesen wie Maenner nunmal an sich haben, und dann die entschiedene und
+kurze Zustimmung, um den Vertrag gueltig zu machen, so wie es unter
+Vollkaufleuten ueblich ist. Mein Vater also ins Haus, einen Heiermann
+geholt, dafuer den vollgesabberten Schnuller kassiert und den Hinweis
+mitgegeben, das Geld bitte nicht achtlos im Spiel wegzulegen, sondern
+auch brav ins Haus zu tragen. Abends, als der Kleine muede im Bett lag,
+fragte seine Mutter verwundert nach, wo er denn seinen Nuckel habe.
+Kurze Antwort: "$Nachbarname kauft hat." Das wars dann, er hat nie
+mehr einen gebraucht, der Handel war voellig ok fuer ihn. Fuer seine
+Mutter selbstverstaendlich auch. Und mein Vater bezeichnet das seither
+voll glucksenden Vergnuegens als das wohl schlechteste Geschaeft seines
+Lebens.
+
+-----------------------------------------------------------------------------
+
+
+
+Voegel und so (Ronda, 20. Sep 2007, 20:33:34):
+From: Thomas Schade <toscha@rrr.de>
+Date: Tue, 18 Sep 2007 18:16:49 +0200
+Message-ID: <46EFF9F1.3070909@news.toscha.de>
+
+
+>> >> Gerade las ich von einer entsprechenden Studie zu
+>> >> Sperlingen, die haben auch staendig neue Hitparaden.
+> > 
+> > Andere gelehrige Voegel imitieren Handy-Klingeltoene. Einer von der
+> > Sorte im Biergarten und alle wuehlen in ihren Taschen ;-)
+
+In der guten alten Zeit(tm) hatte ein Freund von mir einen privaten
+Hochleistungsnadeldrucker. Irgendwann ging ihm das tatternde Geraeusch so
+auf die Nerven, dass er sich zur Anschaffung einer Schallschutzhaube
+entschloss. Obwohl daraufhin der Drucker seinem Werk deutlich leiser
+nachkam, sank der Geraeuschpegel in der Wohnung an sich nur marginal.
+
+Sein Wellensittich naemlich hatte Freundschaft geschlossen mit dem
+froehlich ratternden Drucker und kommunizierte mit ihm trotz
+Schallschutzhaube in gleichen Geraeusch. Der Erwerb einer zweiten fuer den
+Vogelbauer wurde von der Lebensgefaehrtin untersagt.
+
+Leider habe sie aus den Augen verloren, so dass ich nicht weiss, ob er
+sich letztlich vom Vogel oder vom Voegeln, pardon, der Lebensgefaehrtin
+getrennt hat.
+
+
+Ciao
+Toscha
+-- Ambition is a poor excuse for not having enough sense to be lazy.
+
+-----------------------------------------------------------------------------
+
+
+
+Fleischwurstreifegradindikator (Ronda, 20. Sep 2007, 20:34:29):
+SN: Quoting ergaenzt.
+
+From: Andreas Urbanek <nospam@lecking.net>
+Subject: Re: Serioeses Geschaeftsgebaren (betr. "Fachsimpelei mit Profi")
+Newsgroups: de.rec.fotografie
+Date: Mon, 17 Sep 2007 12:21:12 +0200
+Message-ID: <tn4ity6ltxmy$.dlg@lecking.net>
+
+also schrieb Michael Jacobi...
+
+> >Dietmar Langenohl wrote:
+> >
+>> >> Michael Jacobi <Jacobi.Enterprises@t-online.de> schrieb:
+>> >> 
+>> >> 
+>>> >>>Erinnern wir uns: Der eine Auftraggeber verlangt nach einem TIFF und
+>>> >>>bekommt ein konvertiertes JPG,
+>> >> 
+>> >> Der eine Kunde verlangt eine Fleischwurst und bekommt ein
+>> >> konvertiertes Schwein...
+> >
+> > Ich wusste nicht, dass man beim Kauf von Fleischwurst auf die Farbtiefe
+> > achten sollte...
+
+Das sollte man ganz sicher. Spaetestens ab einem leuchtenden Gruen ist
+vom Verzehr energisch abzuraten.
+
+/urbi
+-- Ehe man den Kopf schuettelt, vergewissere man sich, ob man einen hat.
+Truman Capote
+
+-----------------------------------------------------------------------------
+
+
+
+Toeroeoe (Ronda, 20. Sep 2007, 20:35:39):
+From: Hartmut 'Hardy' Schiszler <schiszler@web.de>
+Subject: Re: Billiges Gemuese
+Newsgroups: de.alt.fan.aldi
+Date: Sun, 16 Sep 2007 07:03:57 +0200
+Message-ID: <5l3rq0F6artdU2@mid.individual.net>
+
+[SN: Quoting ergaenzt]
+
+
+Michael Landenberger schrieb:
+> > "Konrad Wilhelm" <konrad_wilhelm@web.de> schrieb:
+> > 
+>> >> Jetzt kommt die Zeit mit dem billigen Weisskohl
+>> >> 1 Kopf (so um die 2 kg) kostet momentan beim Aldi 89 Cent, also so
+>> >> ca 45 Cent das Kilo.
+>> >>
+>> >>Da kann man z. B. einen Kartoffel-Weisskohl-Hackfleisch-Auflauf machen:
+>> >>
+>> >>500 g Weisskohl klein schneiden, mit etwas OOel in einer grossen Pfanne
+>> >>kraeftig anbraten, mit Kuemmel, Pfeffer, Majoran und 2 TL Instantbruehe
+>> >>wuerzen.
+>> >>500 g Kartoffeln schaelen, wuerfeln und noch etwas mit dem Kohl
+>> >>mitbraten.
+>> >>
+>> >>Die Kohl-Kartoffelmischung in einer grossen Schuessel mit 500 g
+>> >>Hackfleich gut vermengen, noch mal abschmecken und in eine passende
+>> >>Auflaufform mit Deckel fuellen, festdruecken.
+>> >>20 Minuten in der Mikrowelle garen und dann in den Backofen nter den
+>> >>Grill, bis die Oberflaeche braun wird. Oder ca 60 Minuten im Backofen
+>> >>bei 190 C.
+>> >>
+>> >>Reicht fuer 2 bis 4 Personen (je nach Gefraessigkeit) und kostet 2,30 .
+> > 
+> > Du hast die Kosten fuers Klopapier vergessen ;-)
+
+Und vor allem die Entschuldigungsgeschenke bei den Freunden.
+
+Hardy, toeroeoe, ich bin gar kein Elefant
+
+-----------------------------------------------------------------------------
+
+
+
+Bohr'sche Unschaerferelation anschaulich erklaert (Ronda, 20. Sep 2007, 20:36:55):
+Von: "Christoph Schmitz" <christoph.schmitz2@post.rwth-aachen.de>
+Newsgroups: rwth.general
+Betreff: Re: Relativistisches Aepfeladditionstheorem
+Datum: Thu, 13 Sep 2007 16:00:20 +0200
+Message-ID: <5ksu3lF5a04nU1@mid.dfncis.de>
+
+Holger Jeromin wrote:
+> > Am 13.09.2007 15:42 schrieb Tobias Banaszak:
+> >
+>> >> On 2007-09-13 08:55:58 +0200, "Ingo Kaiser"  
+>> >> <Ingo.Kaiser@rwth-aachen.de> said:
+>> >>
+>>> >>> Wenn ich ein Loch mit 10mm Durchmesser bohren will, kann ich ja auch  
+>>> >>> nicht zunaechst einen 6er- und danach einen 4er-Bohrer nehmen, wenn
+ich  
+>>> >>> keinen grossen hab, frei nach der korrekten Rechnung 6+4=10!
+>> >>
+>> >> Hm, hab ich schon mal gemacht (ok, es war ein sechser-Bohrer und ich  
+>> >> wollte ein zehner-Loch). Der Duebel in der Decke haelt jetzt seit fast  
+>> >> einem Jahr...
+> >  Ok, du hast dann aber nicht noch mit einem 4er Bohrer hinterhergebohrt,  
+> > sondern das Loch ist wegen der Unschaerferelation groesser geworden als
+der  
+> > Bohrer, oder?
+
+Genau, da benutzt man die Bohr'sche Unschaerferelation:
+Ist der Bohrer schon relativ unscharf, wird das Loch
+schnell mal groesser als beabsichtigt...
+
+Christoph
+
+-----------------------------------------------------------------------------
+
+
+
+Bin Laden bezahlt? (Ronda, 28. Sep 2007, 22:59:51):
+Subject: Re: Spass mit der Tieh-Komm
+From: Lothar Frings <da_lodda@gmx.de>
+Date: Mon, 24 Sep 2007 05:15:13 -0700
+Message-ID: <1190636113.670099.125790@g4g2000hsf.googlegroups.com>
+Newsgroups: de.alt.talk.unmut
+
+Peter Lemken tat kund:
+
+> > Osama, wer denn sonst.
+> >
+> > Er hat es mit minimalem Aufwand geschafft, dass sich die zivilisierte Welt
+> > abschottet, sich vor Angst in die Hose scheisst, Fantastilliarden in die
+> > "Sicherheit" schiebt, vormals offene Gesellschaften sich in Bastionen des
+> > Untersichbleibens verwandeln und Politiker sich die bescheutersten
+> > Bedrohungen einfallen lassen, um sich die Kontrolle ueber ihr Wahlvolk
+noch
+> > mehr zu sichern, und nicht nur das, sich sogar das noch von ihnen
+> > finanzieren zu lassen.
+
+Was heisst hier "sogar"? Die Regierungen bezahlen Bin Laden
+dafuer, dass er ihnen Gesetze ermoeglicht, die sie ohne ihn in
+Jahrzehnten nicht durchgekriegt haetten. Ganz normales
+Outsourcing. Was meinst du, warum sie den "nicht finden"?
+Sie brauchen ihn schliesslich noch.
+
+-----------------------------------------------------------------------------
+
+
+
+Polo und Corsa besser giessen oder mit Milch aufpaeppeln? (Ronda, 28. Sep 2007, 23:01:20):
+Message-ID: <1i4m1q2.1vtxtz41s5ha84N%R.Kiefer.SPAM@gmx.de>
+Subject:     Re: Rondellplatz, mal wieder
+From:        Ralf Kiefer <R.Kiefer.SPAM@gmx.de>
+Newsgroups:  ka.verkehr
+Date:        Tue, 18 Sep 2007 00:46:13 +0200
+
+Daniel Weissen wrote:
+
+> > Ich weiss nicht, um welchen Kreisverkehr (?) es geht, aber ich fahre bei
+> > allen so geradlinig durch, wie moeglich. Ich kann die Dinger nicht 
+> > ausstehen, diese unnoetige materialmordende Kurverei...
+
+Naja, mit der Enduro haette ich nicht mal moralische Bedenken wg. dem
+ganzen Gruenzeug, was da unnoetigerweise mittig auf der Strasse herumsteht.
+Mit 'nem heute so modischen Suff geht das rein mechanisch vielleicht
+auch noch, aber ein tiefergelegter Polo/Corsa waer schon eine Augenweide
+fuer's Gartenbauamt, wenn sie den dann Angiessen, damit er zwischen den
+unueberwindbaren Stiefmuetterchen besser wurzelt.
+
+Gruss, Ralf, Trolle fuetternd :-)
+
+-----------------------------------------------------------------------------
+
+
+
+Subject ist schon wieder falsch. (Ronda, 28. Sep 2007, 23:13:22):
+Geht um Teemissbrauch, nicht um Alkoholmissbrauch.
+
+From: Oliver Cromm <lispamateur@yahoo.de>
+Subject: Re: Alkoholmissbrauch
+Newsgroups: de.etc.sprache.deutsch
+Date:Sat, 22 Sep 2007 17:05:15 -0400
+Message-ID: <a7dg98vmolts$.dlg@ocromm.my-fqdn.de>
+
+>> >> Ich trinke viel Tee, und nahezu jeder Sorte kann ich etwas abegewinnen,
+>> >> bis auf einige chinesische Gruentees, die schmecken nur nach Heu, aber
+>> >> bleib mir weg mit dem Earl Grey.
+...
+Fuer mich ist es der einzige akzeptable aromatisierte Tee. Wenn ich bei
+Freunden gefragt werde, ob ich lieber "Pfirsich-Maracuja-Schweinerippe"
+oder "Johannisbeer-Streublumen" moechte, dann neige ich zu Kaffee.
+
+-----------------------------------------------------------------------------
+
+
+
+Phishing mit der Maus (Ronda, 28. Sep 2007, 23:14:22):
+Message-ID:
+<slrndop13l.c5v.becka-news-nospam-2005-11@xeon.mcs.acs.uni-duesseldorf.de>
+Subject: Re: Phishing ...
+From: Andreas Beck <becka-news-nospam-2005-11@acs.uni-duesseldorf.de>
+Date: Tue, 29 Nov 2005 16:40:21 +0000 (UTC)
+Newsgroups: de.comp.security.misc
+
+Thomas Richter wrote:
+> > Juergen Nieveler <juergen.nieveler.nospam@arcor.de> schrieb:
+>> >>An den armen Idioten, dessen Webserver gehackt wurde.
+> > Ich habe das Problem jetzt verstanden.
+> > Aber wie kommen die Daten vom gehackten Webserver
+> > an den Mafiosi?
+
+Aemm - per Brieftaube?
+
+Hast Du Dir mal rudimentaer Gedanken darueber gemacht, wie Phishing
+funktioniert?
+
+Aber nuja - vielleicht bringt's ja was fuer's Archiv, wenn ich hier mal
+die Maus mache:
+
+Hallo, das ist der Peter. Der Peter ist ein boeser Mensch, der
+gutglaeubigen Tro^WLeuten das Geld vom Konto klauen will. Man nennt 
+sowas einen Phisher.
+
+Dazu sucht er sich erstmal eine Bank aus, deren Kunden er ausnehmen
+will. Am besten eine mit einer moeglichst bunten und unuebersichtlichen
+Website. 
+
+Diese Website baut er jetzt nach. Natuerlich nur fast. Er baut eine
+Seite, die genauso aussieht, die aber nach Kontonummer, PIN, TAN,
+Kreditkartendaten, Schuhgroesse der Ehefrau und sexuellen Vorlieben des
+Haustieres fragt.
+
+Die muss er jetzt irgendwie ins Internet stellen. Die Bank wird er wohl
+nicht dazu ueberredet kriegen. Also mietet er entweder irgendwo Webspace
+mit einer geklauten Kreditkarte an, verwendet einen Freehoster, oder
+er knackt einfach eine der vielen bunten, beschissen gewarteten
+Websites, auf denen irgendein PHP-Kot^WCode sein Unwesen treibt. 
+Bevorzugt in Asien, weil dort das Abusemanagement oft grauenhaft ist.
+
+So. Jetzt muss der Peter nur warten, dass genug Leute die Fragen auf
+seiner Seite ausfuellen. Wenn das einer tut, schickt ihm der Server 
+eine Mail, oder er holt die Dateien ab und zu, oder der Server
+forwarded das alles in irgendeinen IRC-Channel, oder ...
+hach - die Moeglichkeiten des Internet sind einfach herrlich ...
+
+
+Nur: Es kommt ja niemand. Das ist natuerlich schlecht. Also fragt er
+seinen Kumpel Stefan Spammer, ob er nicht ein paar Idio^WBesucher fuer
+seine Seite finden kann. "Nichts einfacher als das", sagt Stefan, "ich
+schicke einfach ein paar hundert Millionen Mails raus - da sind immer 
+ein paar Volltrottel dabei."
+
+Gesagt getan. Alsbald landet eine solche Mail in der Mailbox von Achim
+Ahnungslos. Sie verkuendet grosses Unheil - sein Konto wuerde gesperrt
+und die Katze wegen Steuerhinterziehung verklagt, wenn er nicht sofort
+seine Kontodaten bestaetige. Das alles mit der konkret sicheren neuen
+Spezialsicherungsmethode von die Bank gegen die Missetater.
+
+Entsetzt klickt Achim auf den Link und findet seine bunt blinkende
+Bankenseite vor - denkt er. Schliesslich guckt er nicht in die
+Adressleiste, in der http://192.168.45.87/phishing/enter.php steht
+und auch nicht auf das offen rumhaengende Schloss rechts unten, das
+anzeigt, dass die Verbindung nicht sicher ist. Und ausserdem nutzt er 
+eh den IE, der ja bekanntlich auch ohne so Zeug voll sicher ist.
+Besonders weil er auch die neueste Version von Schlangenoel 2006 auf
+seinem Rechner hat. Da kann im Internet eh gar nix mehr passieren.
+Sagt sein Kumpel, der Sackmann.
+
+Auf der Seite soll er sich erstmal einloggen - das ist schnell passiert - 
+warum hat eigentlich der Browser die Felder nicht selbst ausgefuellt wie 
+sonst immer? Muss wohl an der neuen Sicherheit liegen ... soo - naechste 
+Seite ... was wollen die wissen? Ach ja: den Namen, und dann soll man 
+3 bis 23 noch unverbrauchte TANs eintragen. Die Liste rausgekramt und 
+alles eingehackt - schnell, bevor der Katze was passiert.
+
+"Weiter" ... was denn jetzt noch? Kreditkarte? Aber die ist doch gar
+nicht von denen? Na, wenn's der Sicherheit dient, ... *klacker*
+*klacker*.
+
+"Weiter" - ah - Sicherheitsueberpruefung abgeschlossen. Sie werden zur
+Startseite der Bank weitergeleitet. *PUH* Da haben wir aber nochmal 
+Schwein gehabt.
+
+
+Auf der anderen Seite der Leitung freut sich Peter Phisher. Er hat
+gerade via IRC die verschluesselten Daten von Achim gekriegt. Jetzt mal
+schnell, bevor der noch auf die Idee kommt, mal die Bank zu fragen.
+
+
+Damit er nicht so leicht zu verfolgen ist, schnappt er sich schnell
+einen anonymen Proxy - die Liste hat er guenstig von Charlie Cracker
+gekauft - und macht eine Ueberweisung. Bloss an wen?
+
+Seine eigenen Konten waer irgendwie unpraktisch. Ausserdem sind
+Auslandueberweisungen den Banken eh suspekt ... nee, das muss anders
+gehen.
+
+Er fragt wieder seinen Kumpel Stefan Spammer. Und der weiss wieder Rat.
+Er schickt eine neue Mail. Mit einer ruehrseligen Geschichte von
+russischen Programmierern, die nur 40% von dem verdienen, was sie
+kriegen wuerden, wenn sie Deutsche waeren. Und ob der geneigte Empfaenger
+nicht fuer 15% bereit waere, ein bisschen Geld ueber sein Konto fliessen
+zu lassen. Er muesste ja nix tun und 15% waeren nicht schlecht und 85%
+besser als 40%. Das Geld wird dann am einfachsten per irgendwelchen
+postalischen Bargeldanweisungen weitergeleitet, weil das ja am
+schnellsten ginge.
+
+Auch dafuer finden sich schnell einige Gierschlue^Wnette Mitbuerger.
+Zum Beispiel Rudolph Raffzahn.
+
+Jetzt kann's losgehen. Peter besucht die Bankseite - diesmal die echte
+- wieder per anonymem Proxy und gibt brav alles ein, was ihm Achim ins
+Formular getippt hat. Hey - er hat sich nichtmal vertippt. Und auch
+keiner dieser asozialen Spielverderber, die Unsinn eingeben.
+
+Soo - schnell eine Ueberweisung von EUR 1000 an Rudolph Raffzahn. Und 
+morgen dann eines der Strassenkids kurz zur Post schicken, die 850 EUR
+von Rudolph abholen.
+
+
+In der Zwischenzeit hat aber auch Hans Helle so eine Mail gekriegt - und
+gemerkt, dass er da ueber's Ohr gehauen werden soll.
+
+Also leitet er sie an seine Bank weiter. Die versucht jetzt erstmal, die 
+andere Seite vom Netz zu kriegen. Theoretisch hat sie dazu sogar zumeist
+eine Handhabe - schliesslich wird dort ja mit deren Warenzeichen, Logos
+etc. rumgeaast. Bloss - bis Walter Webforum, der Betreiber des wegen
+antikem Patchstand des darauf abgeladenen PHP-Sondermuells gehackten 
+Webservers, gefunden und dazu veranlasst wurde, den Rechner abzuschalten,
+das dauert.
+
+Inzwischen finden sich froehlich weitere Achims.
+
+Einige Tage spaeter holt Achim seine Kontoauszuege - und staunt nicht
+schlecht: "Wer ist Rudolph Raffzahn, und warum soll ich dem 1000 EUR
+ueberwiesen haben?".
+
+Er fragt seine Bank und die erklaert ihm, er habe das Online veranlasst.
+"Quatsch - einen Scheiss hab ich! Betrueger! Ich geh zur Polizei!"
+
+Dort erklaert man ihm, dass seine Katze nie in Gefahr war, und er einem
+Betrueger seine Kontodaten gegeben hat.
+"Quatsch, das war die Seite meiner Bank! Da war ueberall das Logo, und
+ sogar die Warnung vor solchen Verbrechern, und ein dickes fettes Schloss
+ war da auch, und da stand alles waer jetzt noch sicherer! Und mein 
+ Schlangenoel 2006 hat auch nicht gemeckert."
+
+Und ueberhaupt, will er wissen, wer denn dieser Rudolph Raffzahn waere?
+Das, sagen ihm die Beamten, wuerde gerade ermittelt.
+
+Und in der Tat - schon am naechsten Tag stehen einige freundliche Beamte 
+vor Rudolph Raffzahns Tuer und eroeffnen ihm, dass sie wegen Verdacht auf
+Geldwaesche gegen ihn ermitteln. Rudolph faellt aus allen Wolken und zeigt
+den Herren seine Mailkorrespondenz und alle Belege seiner ordentlichen
+Weiterleitungen fuer die netten Programmierer aus Russland.
+
+"Schade", denkt sich Peter, als keine Anweisungen von Rudolph mehr kommen,
+"da muss ich mir wohl einen neuen Mitarbeiter suchen. Und eine neue
+ Webseite brauche ich auch, die letzte ist ja inzwischen offline."
+
+Aus, die Maus.
+
+
+> > "Irgendwie" muss er doch Rohtext mit meinen TAN?s 
+> > auslesen (kommt der Nachts in den Serverraum
+> > und druckt heimlich die Mails aus? LOL).
+
+s.o.
+
+CU, Andy
+
+-----------------------------------------------------------------------------
+
+
+
+Pizza Diavoli (Ronda, 28. Sep 2007, 23:15:08):
+Message-ID: <b71293-107.ln1@amy2.foxymophandlemama.de>
+Subject: Re: Ich =?ISO-8859-1?Q?k=F6nnt?= kotzen!
+From: Gabriele Conrad <nc-conradga@netcologne.de>
+Date: Fri, 06 Jan 2006 12:34:35 +0100
+Newsgroups: de.alt.sysadmin.recovery
+
+Nico Schumacher wrote:
+
+> > Gabriele Conrad schrieb:
+
+>> >> Super. Beim Weltjugendtag habe ich sogar in der aeusseren Schutzzone
+>> >> vom Marienfeld gewohnt.
+> > 
+> > Dann warst Du ja Naeher am Papst als ich. Wobei ich als Helfer dort
+> > war.
+
+Ich bin dann sogar spasseshalber mal zum Marienfeld ruebergelatscht.
+Gleich wenn man auf das Gelaende raufkam war da ein Pizza-Stand der
+Pizza diavoli verkaufte. Und als der Papst dann noch sagte "Jesus hat
+sich fuer uns zum Brot gemacht" war der Tag echt gerettet.
+
+
+-- Allein die Dunkelheit ist real, das Licht scheint nur so. 
+
+-----------------------------------------------------------------------------
+
+
+
+Afrikanischer Kaffee (Ronda, 28. Sep 2007, 23:15:39):
+[SN: Zitat ergaenzt]
+
+From: "Martin Udelhoven" <maetesudelhoven@googlemail.com>
+Newsgroups: de.etc.sprache.deutsch
+Subject: Re: "Sale"
+Date: Fri, 14 Sep 2007 09:38:46 +0200
+Message-ID: <fcddq8$r3b$1@newsreader2.netcologne.de>
+
+"Frank Hucklenbroich" schrieb:
+> > On Fri, 14 Sep 2007 08:24:07 +0200, Steffen Buehler
+<steffen.buehler@mailinator.com> wrote:
+> >
+>> >> Sonkwatsch. Sale ist der Name einer weltweit agierenden Firma mit einer
+>> >> sehr differenzierten Produktpalette. Mein Schwager ist allerdings
+>> >> neulich in der Maximilianstrasse aus einem Uhrenladen geschmissen
+worden,
+>> >> als er fragte, ob die auch Chronometer von Sale fuehren.
+
+> > So aehnlich wie die Cafs von Frau Tea Room?
+
+Oder eher wie dieser afrikanische Kaffee: KAFFEE TOGO
+
+Martin
+
+-----------------------------------------------------------------------------
+
+
+
+Mudder. Typisch! (Ronda, 29. Sep 2007, 21:51:40):
+Wer von Euch hat das geschrieben?
+
+Ronda
+
+From:        Oliver Brose <brose@despammed.com>
+Newsgroups:  de.alt.fan.ipod
+Subject:     Re: WMV- Video in iPod 80GB
+Date:        Wed, 26 Sep 2007 21:43:01 +0200
+Message-ID:  <fdeco4$8hc$03$1@news.t-online.com>
+
+Alf Geiger schrieb:
+> > Hallo,
+> >
+> > ich bekomme eine wmv-Datei nicht auf den iPod.
+> > Was muss ich machen?
+
+Nimm
+Nimm Anleitung
+Suche
+Suche "Technische Daten"
+Suche
+Suche "Video"
+Lies
+Lies Liste unterstuetzter Formate
+Benutze
+Benutze Google
+
+Oliver
+
+-----------------------------------------------------------------------------
+
+
+
+Sicherheitslandung (Ronda, 13. Okt 2007, 20:28:31):
+From: Ren <Kar98@The-Coalition.US>
+Subject: Re: Chlorunfall
+Newsgroups: de.etc.sprache.deutsch
+Date: Tue, 9 Oct 2007 14:25:36 -0500
+Message-ID: <2007100914253637709-Kar98@TheCoalitionUS>
+
+...
+> > Und jedes Flugzeug, dessen Pilot eine vorbildliche Sicherheitslandung
+> > durchgefuehrt hat, ist journalistisch abgestuerzt-und-wie-durch-ein-
+> > Wunder-haben-alle-Insassen-ueberlebt.
+
+Wie man hier in Aviatorenkreisen spricht:
+"Any landing you can walk away from is a good one. Bonus points if you 
+can re-use the plane."
+
+-----------------------------------------------------------------------------
+
+
+
+Feudelismus (Ronda, 13. Okt 2007, 20:28:53):
+From: "Helmut P. Einfalt" <helmut.p.einfalt_NOSPAM@NOSPAM_aon.at>
+Newsgroups: de.etc.sprache.deutsch
+Subject: Re: "Lebendiges Deutsch"
+Date: Wed, 10 Oct 2007 04:56:34 +0200
+Message-ID: <470c3de4$0$7086$91cee783@newsreader01.highway.telekom.at>
+
+Thomas Schade beliebte zu schreiben :
+
+>>> >>> Uebrigens finde ich, dass sich "Mobbing", und mehr noch das Verb
+>>> >>> "mobben", recht gut in die deutsche Sprache einfuegt.
+>> >>
+>> >> Naja, in die norddeutsche. Bei uns wird's ja eher zu "Mopping".
+> >
+> > Da daechte ich aber eher an eine Putztechnik.
+
+Das ist dann der Feudelismus!
+
+Helmut
+
+-----------------------------------------------------------------------------
+
+
+
+Studiengebuehren... (Ronda, 13. Okt 2007, 20:29:13):
+From: Felix Kronlage <fkr@hazardous.org>
+Subject: Re: Auch Thinkpads koennen sterben
+Newsgroups: de.alt.sysadmin.recovery
+Date: Sun, 7 Oct 2007 19:36:53 +0000 (UTC)
+Message-ID: <slrn4e29lajc00100.e0i.fkr@news.bytemine.net>
+
+Dietz Proepper <dietz-news@rotfl.franken.de> wrote: 
+
+> > Sagen wir es mal so - Studiengebuehren sind eine bodenlose Frechheit,
+keine
+> > Frage. Andererseits - wo waren denn die Studentenmassen die dagegen auf
+die
+> > Strasse gegangen waeren?
+
+In der neuen Kaffeebar, wo man Latte MachiDingsbums fuer 2.60 EUR trinkt.
+Zumindest habe ich in Oldenburg diesen Eindruck :(
+
+felix
+
+-----------------------------------------------------------------------------
+
+
+
+Matthias-Rust-Flughafen (Ronda, 13. Okt 2007, 20:30:25):
+From: Wolfram Heinrich <theodor.rieh@freenet.de>
+Newsgroups: de.etc.sprache.deutsch
+Subject: Re: Strassennamen
+Date: Sun, 30 Sep 2007 11:33:22 +0200
+Message-ID: <1h6vc51to76ys$.dlg@www.theodor-rieh.de>
+
+Am 28 Sep 2007 14:36:36 GMT schrieb Volker Gringmuth:
+
+> > Wolfram Heinrich wrote:
+> > 
+>>>>>> >>>>>> Nicht zu vergessen der Matthias-Rust-Flughafen.
+>>>>> >>>>>
+>>>>> >>>>> In Moskau?
+>>>> >>>>
+>>>> >>>> Nein, der Rote Platz ist noch nicht umbenannt worden.
+>>> >>>
+>>> >>> <klugscheiss> Da isser ja auch nicht gelandet. </klugscheiss>
+>> >>
+>> >> Aeh, sondern?
+> > 
+> > http://de.wikipedia.org/wiki/Mathias_Rust
+> > 
+> >| Rust erreichte schliesslich nach etwa fuenfeinhalbstuendigem Flug
+> >| Moskau, wo er gegen 18:15 Uhr mehrere Runden ueber dem Roten Platz
+> >| und dem Kreml drehte. Da auf dem Platz zu viele Menschen waren,
+> >| musste er dann gegen 18:40 Uhr auf der nahen Moskwa-Bruecke
+> >| (Moskworezkij most) landen. Er brachte das Flugzeug dann auf dem
+> >| Parkplatz fuer Reisebusse am Wassilij-Abhang (Wassilewski spusk)
+> >| neben der Basilius-Kathedrale direkt am Roten Platz zum Stehen. 
+> > 
+Mathias Rust kann froh sein, dass er damals im Herz des Boesen gelandet
+ist und nicht heute bei uns Guten.
+
+Ciao
+Wolfram
+
+-----------------------------------------------------------------------------
+
+
+
+Kirchencard: Shoppen fuer Gott. (Ronda, 18. Okt 2007, 21:25:41):
+Fuer Lug.
+
+Ronda
+
+From: Johannes Kuhn <johkuhn@web.de>
+Subject: Kirchencard: Shoppen fuer Gott
+Newsgroups: de.soc.weltanschauung.christentum
+Date: Sun, 14 Oct 2007 12:08:58 +0200
+Message-ID: <4711eabb$0$16102$9b4e6d93@newsspool1.arcor-online.net>
+
+http://www.spiegel.de/panorama/0,1518,510707,00.html
+
+"Geldbringende Innovationen muessen her. Und der Kirchenkreis
+Hattingen-Witten hat sich in dieser Hinsicht als besonders einfallsreich
+erwiesen. Der gruendete die "Stiftung Gemeindespendenwerk" und brachte die
+bundesweit erste Kirchencard auf den Weg."
+
+Interessantes Modell. 
+
+Ich haette da auch eine Idee: Die Ablassflatrate fuer nur 29,95 EUR im Monat
+z.B... muesste man halt richtig vermarkten. "Ablass - so einfach wie
+Fastfood". Aber bestimmt kommt dann wieder so ein Spielverderber und
+schmiert Kirchentueren voll...
+
+Joh
+
+-----------------------------------------------------------------------------
+
+
+
+Leoni? (Ronda, 18. Okt 2007, 21:26:41):
+... ich steh da wohl grad voll auf der Leitung: was sind bitte Leoni?
+
+Ronda
+
+From: Wolfram Heinrich <theodor.rieh@freenet.de>
+Newsgroups: de.rec.mampf
+Subject: Re: Sauce mit Becher Mehl
+Date: Sun, 14 Oct 2007 11:30:43 +0200
+Message-ID: <qtn22b20u795.dlg@www.theodor-rieh.de>
+
+Am Sun, 14 Oct 2007 11:22:25 +0200 schrieb Dirk Hogenkamp:
+
+> > Wirklich witzig!
+> > Erinnert mich an meinen Amrum-Urlaub vor zwei Jahres, dort gab es 
+> > Menutafel mit einer "Kirsche Loreen".
+
+Das hat eine Weile gedauert, bis ich dahinterkam - Quiche Lorraine. Am
+Regensburger Bahnhof wurde seinerzeit Caf Ol angeboten. Und ueber die
+Leoni in bayerischen Metzgereien wundert sich eh keiner mehr.
+
+Ciao
+Wolfram
+
+-----------------------------------------------------------------------------
+
+
+
+Frau Schmid (ehemals) gewidmet (Ronda, 20. Okt 2007, 19:10:35):
+gez. Ronda
+(Unterschrift unleserlich, nach Diktat breit grinsend abgehauen)
+
+From: Stefan Krieg <Stefan.Krieg@GMX.de>
+Subject: Re: Hypothek - Eigenkapital
+Newsgroups: de.etc.finanz.misc
+Date:Thu, 18 Oct 2007 17:21:41 +0200
+Message-ID: <5npc06FjdlbrU1@mid.individual.net>
+
+> > Soll man etwa heiraten um Steuern zu sparen? ;-)
+> > Dann kommt gleich das Finanzamt und unterstellt einem
+> > dass man den Gestaltungraum missbraucht haette.
+
+Sehr geehrter Herr Schmidt, sehr geehrte Frau Schmidt,
+
+bei der Pruefung Ihrer Einkommensteuererklaerung fuer 2006 ist uns 
+aufgefallen, dass Sie durch die Eheschliessung insgesamt weniger Steuern 
+zahlen muessten als wenn Sie weiterhin ledig geblieben waeren. Wir gehen 
+daher davon aus, dass Sie die Eheschliessung ausschliesslich zur Ausnutzung 
+steuerlicher Verguenstigungen durchgefuehrt haben. Dies erfuellt den 
+Tatbestand des Gestaltungsmissbrauches gem.  soundso Abgabenordnung. Die 
+von Ihnen abgegebenen Willenserklaerungen bei Eheschliessung sind daher 
+unwirksam und Ihre Ehe damit nichtig. Das fuer Sie zustaendige Standesamt 
+haben wir ueber die Ausserkraftsetzung Ihrer ehelichen Gemeinschaft 
+informiert.
+
+Sollten Sie, sehr geehrte Frau Meier, oder Sie, sehr geehrter Herr 
+Schmidt, noch Fragen haben, stehen wir Ihnen unter der o.a. 
+Telefonnnummer zu unseren Sprechzeiten von 14:00 bis 15:00 Uhr zur 
+Verfuegung.
+[insert Rechtsbehelfsbelehrung here]
+
+So etwa?
+
+-----------------------------------------------------------------------------
+
+
+
+PEBKAC? (Ronda,  6. Nov 2007, 20:07:03):
+From: Stefan Koenig <skoenig@web.de>
+Subject: Re: Drucker meldet faelschlicher Weise leeren Toner HP 2030
+Newsgroups: de.comp.hardware.drucker
+Date: Wed, 17 Oct 2007 13:39:45 +0200
+Message-Id: <ff4s9v$k79$1@newsreader2.netcologne.de>
+
+Hallo Norbert, danke fuer deinen Ratschlag - Ich Bloedmann habe bei dieser 
+     Aktion festgestellt, dass ich gar keinen HP Drucker sondern einen 
+von Brother habe.
+
+
+
+Norbert Hahn schrieb:
+> > Stefan Koenig <skoenig@web.de> wrote:
+> > 
+>> >> Hallo,
+>> >>
+>> >> seit einigen Tagen spinnt mein Drucker (HP 2030 Laser s/w) herum. Obwohl
+>> >> das mitgelieferte Testprogramm anzeigt, dass der Toner noch zu 4/5 voll 
+>> >> ist und ich nicht sonderlich viel gedruckt habe, blinkt die Toneranzeige
+>> >> und er weigert sich zu drucken.
+> > 
+> > Probier mal einen Kaltstart des Druckers.
+> > Ich kenne den 2030 nicht, bei den Groesseren geht es so:
+> > Geraet fuer mindestens 10 Sekunden ausschalten.
+> > Gruene Taste druecken, einschalten, gruene Taste weiter gedrueckt lassen
+> > bis Cold Reset angezeigt wird. Loslassen und warten bis Ready angezeigt
+> > wird. Fertig.
+> > 
+> > Norbert
+
+-----------------------------------------------------------------------------
+
+
+
+Zollstock, nicht jugendfrei (Ronda,  6. Nov 2007, 20:08:03):
+From: Arnulf Sopp <ar-nospam-nulf@maaaddin.de>
+Subject: Re: Hallo und was macht man mit bootbar?
+Newsgroups: de.etc.sprache.deutsch
+Date: Wed, 24 Oct 2007 01:07:43 +0200
+Message-ID: <bohi2mhpyhaj$.dlg@news.hacktory.de>
+
+> > Du sagt sicher auch Gliedermessstab, oder?
+
+Ich sage Meter. In meiner Heimat wuerde jeder unter einem
+Gliedermessstab ein Hilfsmittel zum Austoben maennlich-pubertaerer
+Konkurrenzriten verstehen.
+
+...
+
+-----------------------------------------------------------------------------
+
+
+
+Socially Aware (Ronda,  6. Nov 2007, 20:09:22):
+From: Martin Gerdes <martin.gerdes@gmx.de>
+Newsgroups: de.etc.finanz.banken+broker
+Subject: Re: DKB buhlt um Studenten
+Date: Sat, 27 Oct 2007 00:00:02 +0200
+Message-ID: <hq83i3ta2hripi9r911uc4h4qjqn93t9lp@4ax.com>
+
+Konrad Wilhelm <konrad_wilhelm@web.de> schrieb:
+
+> >... was ja so negativ auch nicht ist. Vermeidet, dass der Studierende
+> >(das ist die politisch korrekte Bezeichnung fuer StudentIn) mehr
+> >ausgibt als er hat und in die Schuldenfalle rennt.
+
+Ich darf Dich korrigieren: Die im Moment politisch korrekte Bezeichnung fuer
+ein studierendes menschliches Wesen lautet "die oder der Studierende". Du
+solltest diesbezueglich mal Deinen Sprachgebrauch anpassen. Ganz offenbar ist
+Dir noch nicht aufgegangen, dass Du durch ungeschickte Artikelwahl die
+bessere Haelfte der Menschheit unterschlaegst.
+
+Der Begriff "politisch korrekt" ist in einschlaegigen amerikanischen
+Gutmenschenkreisen uebrigens bereits wieder out, man spricht dort von
+"socially aware". Hierfuer gibt es noch keine deutsche Uebersetzung, was
+verdeutlicht, wie sehr die Deutschen bezueglich der social awareness hinter
+dem Mond sind.
+
+-----------------------------------------------------------------------------
+
+
+
+Mittelchen (Ronda,  6. Nov 2007, 20:46:16):
+Von: "Helmut Hullen" <helmut@hullen.de>
+Newsgroups: ger.ct
+Betreff: Re: Winterzeit....
+Datum: Mon, 29 Oct 2007 14:12:00 +0100
+URL: news://<ARnqHJvjSsB@helmuthullen.individual.de>
+
+Hallo, Markus,
+
+Du meintest am 29.10.07:
+
+> > Ein Vorteil faellt mir ein: einmal in Jahr hat man eine Ausrede, wenn
+> > man zu spaet kommt. ;)
+
+Ist doch nicht schlimm, wenn man spaet kommt - mir werden unentwegt
+Mittelchen gegen das zu-frueh-Kommen angeboten!
+
+Viele Gruesse
+Helmut
+BS
+
+-----------------------------------------------------------------------------
+
+
+
+Ich mag Katzen (Ronda,  6. Nov 2007, 20:46:40):
+From: Ren <Kar98@The-Coalition.US>
+Subject: Re: Geschlechtsspezifische und neutrale Formen
+Newsgroups: de.etc.sprache.deutsch
+Date:Tue, 30 Oct 2007 11:46:48 -0500
+Message-ID: <2007103011464843658-Kar98@TheCoalitionUS>
+
+>> >> Wo ich herkomme - Irland -, unterscheiden wir zwischgen pussycats and
+>> >> tomcats. Kitty its da eher ein Katzenname fuer Weibchen, da Kitty
+sowieso
+>> >> ein relatic haeufigger Frauenname ist - Koseform von Katherine.
+ 
+> > Interessant. Allerdings: "Kitty" oder im Deutschen "Mieze" als
+> > Katzennamen finde ich absurd, denn um sie so zu rufen, brauche ich ihr
+> > erst gar keinen Namen geben.
+
+Ist doch eh rille. Wenn du ihr nicht gerade einen Namen gibst, der wie 
+das Geraeusch des el. Dosenoeffners klingt, kannst du die Katze rufen, 
+wie du lustig bist. Die kommt nicht.
+
+-----------------------------------------------------------------------------
+
+
+
+Schneefraese (Ronda,  6. Nov 2007, 20:47:25):
+From: Hannes Birnbacher <hannes.birnbacher@gmx.de>
+Subject: Re: Schneefraese bei Hofer
+Newsgroups: de.alt.fan.aldi
+Date: Tue, 30 Oct 2007 22:32:03 +0100
+Message-ID: <4727a2d2$0$27135$9b4e6d93@newsspool1.arcor-online.net>
+
+
+[SN: Quoting ergaenzt]
+
+Ulf Gutschmidt schrieb:
+
+>> >> hat jemand schon Erfahrung mit sowas, oder ob die was taugt?
+> > 
+> > Ich kann es nicht, haette aber ein paar usenettypische Antworten.
+> >- kein Mensch braucht eine Schneefraese
+> >- bald gibt es sowieso keinen Schnee mehr in Mitteleuropa, und das nur, 
+> >weil nicht alle vegan leben!
+> >- Die Schneefraese von Aldi ist Kult, die von Lidl einfach nur billig
+> >- Dein Posting waere in de.rec.comp-schneefraesen angebracht
+> >- hier war die Schneefraese schon um 7:30 ausverkauft, obwohl Aldi erst 
+> >um 8:00 oeffnet!
+> >- Schneefraesen kauft man im Fachhandel!
+> >- vor 15 Jahren gab es mal Schneefraesen bei Plus, ich kenne aber 
+> >niemand, der eine gekauft hat
+> >- Schneefraesen von Aldi sind nicht umweltfreundlich, bei Manfactum 
+> >bekommst Du Geraete mit dem Oeko-Pruefsiegel
+> >- die Schneefraese ist fuer die Reise viel zu schwer, ausserdem ist die 
+> >Akkulaufzeit zu niedrig
+> >- wenn Du keine Ahnung von Schneefraesen hast, was Dein Posting beweist, 
+> >solltest Du Dich in de.alt.schneefraesen-newuser-questions informieren 
+> >und uns nicht mit Anfaengerfragen behelligen.
+> >- Die Schnefraese ist sowieso von Medion, und deren Service ist ja 
+> >bekanntlich ganz schlecht
+
+Lern' erst mal googlen ;-)
+
+  <gg>
+
+-----------------------------------------------------------------------------
+
+
+
+"Deine Zeit ist abgelaufen"-Bildschirmschoner (Ronda,  6. Nov 2007, 20:47:59):
+[SN: Hermann mag keine Bildschirmschoner]
+
+From: Herwig Huener AQSR <news20061103@Herwig-Huener.de>
+Subject: Re: ntp-Anekdote
+Newsgroups: ger.ct
+Date:Wed, 31 Oct 2007 13:11:59 +0100
+Message-ID: <fg9reg$adk$03$1@news.t-online.com>
+
+11 Brumaire an 216 de la Rvolution
+13:12:11 +0100
+
+Hermann Riemann wrote:
+
+ > ...
+
+> > Ich mag es nicht, wenn der Bildschirminhalt
+> > sich beim Betrachten aendert,
+> > weil irgendeiner meint, meine Zeit waere abgelaufen.
+
+Wenn irgendjemand meint, Deine Zeit sei abgelaufen,
+und tut darauf nichts weiter als den BildSchirmInhalt
+zu veraendern, dann kannst Du Dich eigentlich zu den
+begnadeten Sterblichen zaehlen!
+
+SCNR Herwig
+
+-----------------------------------------------------------------------------
+
+
+
+Schlagschrauberabschraubschaden (Ronda,  6. Nov 2007, 20:49:47):
+Newsgroups: de.rec.motorrad
+Subject: Re: Werkzeugsuche
+From: Christian Mende <320026600724@t-online.de>
+Date: Tue, 23 Oct 2007 20:23:01 +0200
+Message-ID: <bvesh3h3bojtsehq19b9n77285bpc1ffrl@4ax.com>
+
+On Tue, 23 Oct 2007 17:42:59 +0200, Olaf Kaluza <olaf@criseis.ruhr.de>
+wrote:
+
+> >Axel Bergander <a.berganderTRALALA@gmailspam.com> wrote:
+> >
+>> > >Das beste: Schlagschrauber, pneumatisch. Getestet an der Mutter der
+>> > >Schwungmasse - 220 Nm plus Loctite gehen so einfach und ohne blockieren
+>> > >auf.
+> >
+> >Das Problem mit Schlagschraubern ist nur das die wirklich alles auf
+> >bekommen, selbst Dinge die nicht dafuer gedacht sind auf zu gehen weil
+> >sie aus einem Stueck gefertigt sind. :-)
+> >
+
+Oder Schrauben mit Linksgewinde.
+
+Woher ich das weiss ...
+
+
+
+Hilfe! Suche Vergaser fuer XS360, 
+bei dem die Drosselklappenwellen 
+nicht merklich ausgeschlagen sind
+Kennbuchstabe 1U5-00  oder so Chr. Mende
+
+-----------------------------------------------------------------------------
+
+
+
+Scheiden tut weh... besonders 1989 (Ronda, 18. Nov 2007, 21:19:33):
+From: Gerald Endres <g.endres@gmx.de>
+Newsgroups: de.alt.folklore.ddr
+Subject: Re: Kredite und Waehrungsumstellung
+Date: Sun, 04 Nov 2007 12:21:12 +0100
+Message-ID: <5p5o94Fpriu6U1@mid.individual.net>
+
+kpo.usenet@gmx.de (Kai Poehlmann) schrieb:
+
+> >1 M entsprach etwa 0,14 DM, das sind ca. 0,07 Euro. Somit entsprachen
+> >600 "Ostmark" ca 56 Euro...
+
+Solche Umrechnungen sind immer irrefuehrend. Da gab es einmal die
+offiziellen Wechselkurse, dann die inoffiziellen. Die Kaufkraft kann
+man auch nicht in einem festen Kurs umrechnen. Was kostete ein Haus,
+ein Videorekorder, ein Laib Brot, ein Bier in der Kneipe, ein
+Schnitzel beim Metzger und in der Gaststaette.
+
+Mir faellt da immer eine Nachbarin in Kleinmachnow ein, die sich
+scheiden liess und dabei von ihrem Ehemann gnadenlos ueber den Tisch
+gezogen wurde:
+Sie bekam das Haus mit 1000 qm Garten (ca. 20 000 M wert), er den
+nagelneuen Wartburg (ca. 50 000). Das war im Fruehsommer 1989.
+
+Gruss
+Gerald
+
+-----------------------------------------------------------------------------
+
+
+
+Pflege von Speicherkarten tut Not (Ronda, 18. Nov 2007, 21:20:43):
+From: Toni Grass <toni@fotoni.at>
+Newsgroups: de.alt.rec.digitalfotografie
+Subject: Re: Pflege von Speicherkarten
+Date: 4 Nov 2007 19:29:09 GMT
+Message-ID: <1T4hnr8qI2iaN1s0m%toni@luke.lan.fotoni.at>
+
+Karsten Paulsen wrote:
+
+[....]
+> > In der Kamera solltest Du aber besser nicht formatieren, da die 
+> > ueberfluessigen Pixel (und das sind ja bei 10 Mio. Pix-Bildern eine ganze
+> > Menge) aus der Speicherkarte gefegt werden.
+
+> > Es gibt auch Speicherkarten, auf denen die Pixel nicht so gut haften,
+> > die nennt man dann "no-name". Das ist in der Regel nicht so schlimm, da
+> > es ja kaum auffaelt, wenn von 10 Millionen Pixel 22 Pixel rausfallen. Die
+> > billigen Speicherkarten sollte man aber nicht fallen lassen, da die 
+> > Bilder sonst verrutschen und schief sind, oder die Pixel der einzelnen
+> > Bilder sich vermischen, dann sind die Bilder meistens unscharf, 
+> > verwackelt und falsch belichtet.
+
+Gelegentlich den Kartenslot von den toten Pixels reinigen (Blasebalg
+udgl) haelt die verbleibenden Pixel frisch und farbenfroh.
+
+Toni
+
+-----------------------------------------------------------------------------
+
+
+
+Gunpowder -> Tee -> Bier -> Berliner Weisse (Ronda, 18. Nov 2007, 21:22:16):
+From: spam-or-nospam@gmx.de (Manfred Russ)
+Newsgroups: de.etc.sprache.deutsch
+Subject: Re: Artikel
+Date: Sun, 4 Nov 2007 20:29:30 +0100
+Message-ID: <MPG.2198313f730cdcf698b500@ID-30918.user.uni-berlin.de>
+
+Sun, 4 Nov 2007 15:26:46 +0100 Ruediger Silberer schrieb: 
+
+>> > > Es gibt einen chinesischen Tee, der durch Fermentierung oder
+>> > > Halbfermentierung sein unverwechselbares Aroma erlangt (Souchong,
+>> > > Gunpowder?)
+> > 
+> > Gunpowder ist ein Tee der mit Bergamottoel versetzt wird und anschliessend
+> > scheuslich schmeckt.
+
+Im Prinzip richtig.
+Allerdings handelt es sich nicht um Tee, sondern um Bier; zudem heisst 
+das nicht Gunpowder, sondern Berliner Weisse; und das wird auch nicht mit 
+Bergmottenoel versetzt, sondern mit Waldmeistersirup. Die Conclusio 
+weicht dann insofern ab, als sie wieder zutrifft.
+
+-----------------------------------------------------------------------------
+
+
+
+[www.forum] Aus 'www.triff-chemnitz.de' (Ronda, 18. Nov 2007, 21:25:19):
+*seufz* Pisa!
+
+Ronda
+
+Diskussion 'Oelpreise':
+
+jefray wrote:
+
+"ich hab zum glueck die woche den oelwechsel am auto machen lassen.
+
+sonst interessiert mich ja der oelpreis nicht. ich fahr ja mit benzin."
+
+-----------------------------------------------------------------------------
+
+
+
+Liebe Vegetarier: (Ronda, 18. Nov 2007, 21:26:21):
+AETSCH! :-)
+
+From: Peter Zander <HPeterZander@arcor.de>
+Newsgroups: de.soc.weltanschauung.christentum,de.talk.tagesgeschehen
+Subject: Re: das Christkind kommt bald und damit die  christliche
+Tierquaelerei
+Date: Thu, 08 Nov 2007 08:07:24 +0100
+Message-ID: <aeb5j31833dret1jn7mnk65nsfk2no6nae@4ax.com>
+
+"Josef" <j.ballago@tiscali.de> schrieb am Thu, 8 Nov 2007 04:44:08 +0100:
+
+> > und Gott sprach : Du darfst essen von allen Baeumen im Garten.
+> >
+> > Gott war Vegetarier ... Pech gehabt ;-)))
+
+So? 
+
+"Und es geschah nach einiger Zeit, da brachte Kain von den Fruechten
+des Ackerbodens dem HERRN eine Opfergabe. Und Abel, auch er brachte
+von den Erstlingen seiner Herde und von ihrem Fett. Und der HERR
+blickte auf Abel und auf seine Opfergabe; aber auf Kain und auf seine
+Opfergabe blickte er nicht." (1. Mos. 4, 3-5)
+
+Peter Zander 
+
+-----------------------------------------------------------------------------
+
+
+
+Fortissimo! (Ronda, 18. Nov 2007, 21:28:09):
+Message-ID: <Xns99E41AEC417EBostertaler@127.0.0.1>
+From: Erik Huether <nune@ostertaler.de>
+Newsgroups: de.rec.musik.machen
+Subject: Re: Hoerschutz fuer Drummer
+Date: 10 Nov 2007 01:39:38 GMT
+
+
+[Hinweise vom Einreicher: 2 Postings zusammengefuegt,
+fortissimo ist lauter als forte]
+
+Erhard Schwenk schrieb:
+
+> > Achim Goebel wrote:
+ 
+> > Es gab da mal die Big-Band, die kurz vor dem grossen Auftritt noch ne 
+> > Probe einlegte.
+
+> > Der Leader gibt nen Cue, die Band legt los... nach 8 Takten winkt 
+> > $Cheffe ab: "Das Schlagzeug ist zu laut. Bitte nochmal."
+
+> > Ok, neuer Versuch, nach 4 Takten winkt er wieder ab. "Hey, ich hab 
+> > gesagt, das Schlagzeug ist zu laut!" - der Bassist versucht 
+> > einzuschreiten: "Aber Chef..." - "Das Schlagzeug ist _ZU _LAUT_!" 
+> > schneidet ihm der Maestro das Wort ab. Betretenes Schweigen.
+
+> > Neuer Einsatz. Die Truppe kommt keine 2 Takte weit, da wird sie schon 
+> > wieder abgewunken. Standpaunke "Ich hab doch grad gesagt, das Schlagzeug 
+> > ist zu laut!"  - "Aber Chef, hoert mal" - "Red ich chinesisch? Das 
+> > Schlagzeug ist zu laut, sagte ich" - "Hm der Drummer ist doch aber noch 
+> > gar nicht da, der kommt erst in ner halben Stunde weil er noch nen 
+> > Auftritt mit seiner Band hat". - "Na gut, dann sag ihm bitte Bescheid, 
+> > wenn er kommt, dass das Schlagzeug zu laut ist."
+
+Kenn ich andersrum. Orchesterprobe, Blechblaesereinsatz, der Dirigent
+bricht ab: "Meine Herren Trompeter, forte bitte!"
+Selbe Stelle nochmal, die Trompeter geben alles, aber der Dirigent
+bricht nochmal ab: "Forte, meine Herren, Forte!"
+Die Trompeter gluehen schon rot, als der Dirigent zum dritten Mal
+abbricht: "Forte, meine Herren,  nicht  Fortissimo!"
+
+Gruss E"ich war's nicht!"rik
+
+-----------------------------------------------------------------------------
+
+
+
+Bohnen? (Ronda, 18. Nov 2007, 21:28:58):
+[Submitter's note: Umlaut im Subject geaendert]
+
+From: Tilman Schmidt <ts-usenet0711@pxnet.com>
+Subject: Re: Hoerschutz fuer Drummer
+Newsgroups: de.rec.musik.machen
+Date: Sat, 10 Nov 2007 01:32:58 +0100
+Message-ID: <fh2u6c$uag$01$2@news.t-online.com>
+
+Am 09.11.2007 23:26 schrieb Steff Boeckler:
+> > Was fuer ein Gehoerschutz koennt ihr empfehlen, bisher benutze ich so
+uralt 
+> > Ohrstoepselteile die auch beim Scheissen benutzt werden, [...]
+
+Was hast Du gegessen, dass Du dabei Gehoerschutz brauchst???
+
+-----------------------------------------------------------------------------
+
+
+
+Was heisst Eselsbruecke auf franzoesisch? (Ronda, 25. Nov 2007, 11:42:23):
+From: Ignatios Souvatzis <u502sou@beverly.kleinbus.org>
+Newsgroups: de.alt.sysadmin.recovery
+Subject: Re: Und ihr beschwert euch ueber User...
+Date: Thu, 8 Nov 2007 12:46:50 +0100
+Message-ID: <slrnfj5tpa.onr.u502sou@marie.beverly.kleinbus.org>
+
+Joerg Dorchain wrote:
+
+> > Ich habe mehr Schwierigkeiten damit, mir die Geschlechter franzoesischer
+> > Woerter zu merken als die Deklinationen auf Latein. System finde ich da
+> > aber in keinem von beiden (auch auf Deutsch nicht)
+
+Mitschuelerin: "Frau name(Lehrerin), warum ist "le parfum" maskulin?
+Das wird doch hauptsaechlich von Frauen benutzt?"
+
+Lehrerin: "Ja und? Maenner werden auch hauptsaechlich von Frauen benutzt."
+
+Klasse: "Groehl!"
+
+Ich kann mich nicht mehr an die Namen der Beteiligten erinnern, aber die
+Szene selbst und das grammatikalische Geschlecht du parfum bleiben mir
+lebenslaenglich im Gedaechtnis.
+
+-is
+
+-----------------------------------------------------------------------------
+
+
+
+Bratenthermometer und Sex (Ronda, 25. Nov 2007, 11:43:37):
+From: Cornelius Rosenschon <crosenschon@arcor.de>
+Subject: Bratthermometer und Sex
+Newsgroups: de.rec.mampf
+Date: Wed, 21 Nov 2007 12:10:26 +0100
+Message-ID: <fi13n2$qur$00$1@news.t-online.com>
+
+Hi,
+
+ich hab eins! Seit heute 10 Uhr! Nur, was fang ich damit an? Benutzt 
+das hier jemand und hat Erfahrungen? Dem 4-zeiligen Aufdruck auf der 
+Verpackung entnehme ich, dass ich es an der dicksten Stelle des 
+Bratens einstechen soll. Gut! Und wenn ich den wenden will, muss ich 
+es wohl raus ziehen und auf der anderen Seite einstechen. Dabei 
+hinterlasse ich eine Drainage fuer Bratensaefte. Und das mehrmals, bei 
+mehrmaligem Wenden. Ist das irgendwie bei Fisch verwendbar? Gestern 
+habe ich Makrelen filetiert und in der Pfanne gebraten. Gruendlich! 
+Entsprechend schmeckten sie. Der Uebergang zwischen roh und saftig 
+liegt im 1-Minutenbereich!
+
+Mit Sex hat das natuerlich nichts zu tun. Ich wollte nur, dass ihr 
+meine Frage lest.
+
+Gruss Conny
+
+-----------------------------------------------------------------------------
+
+
+
+Grrrrrrrrrrrr! (Ronda, 25. Nov 2007, 11:44:29):
+From: Thorsten Dahm <usenet_muelleimer@gmx.net>
+Newsgroups: de.alt.sysadmin.recovery
+Subject: Re: Und ihr beschwert euch ueber User...
+Date: Fri, 16 Nov 2007 17:58:25 +0000
+Message-ID: <5q6421Fu167kU1@mid.individual.net>
+
+Roger Schwentker wrote:
+> > Thorsten Dahm <usenet_muelleimer@gmx.net> wrote:
+>>> >>> Spielst Du jetzt auf Hexenverbrennungen an?
+>> >> Hey, coole Idee! Wo und wann?
+> > 
+> > Aber bitte nur mit oekologisch angebautem Holz, welches mindestens
+> > drei Jahre abgelagert wurde. Streng nach der vierten Verordnung zur
+> > Aenderung der Kleinfeuerstaettenverordnung.
+
+Ja ja, und wir nutzen auch nur vollstaendig biologisch abbaubare Hexen.
+
+Gruss,
+Thor"scheiss Umweltschutz"sten
+
+-----------------------------------------------------------------------------
+
+
+
+Alt, aber trotzdem... (Ronda,  2. Dez 2007, 21:07:44):
+Newsgroups: de.rec.fahrrad
+From: rundablage@goehrde.net (Robert Bar)
+Subject: Re: Diebstahl sicherung
+Date: Thu, 29 Nov 2007 22:58:00 +0100
+Message-ID: <1i8d3ng.gamjh4nk51fvN%rundablage@goehrde.net>
+
+Peter de Leuw <wirdnichtgelesen@deleuw.net> wrote:
+
+> > Hans <birdy@usenet.cnntp.org> wrote:
+> > 
+>> > > ...
+>> > > Oder das Rad versichern (Hausrat?).
+> > 
+> > Seit wann hilft eine Versicherung gegen Diebstahl? Ich habe eine
+> > Wohngebaeudeversicherung. Brennt die Huette jetzt nie ab?
+
+Treffen sich zwei Bauern; sagt der eine: "Ich hab jetzt 'ne Feuer- und
+'ne Hagelversicherung." Sagt der andere: "Wie man Feuer macht, weiss ich;
+aber wie laesst man's hageln?"
+
+-----------------------------------------------------------------------------
+
+
+
+Zwerge. TYPISCH! (Ronda, 19. Dez 2007, 22:35:45):
+From: Dirk Moebius <dirk.nospam.moebius@gmx.de>
+Newsgroups: de.soc.familie.kinder
+Subject: Re: Niedliches vom Sprechenlernen
+Message-ID: <jjve75fuik.fsf@virtual.pudel.in-berlin.de>
+
+Boris Glawe writes:
+
+> > Michaela Schnarr schrieb:
+>> >> Hallo,
+
+
+>> >> Habt Ihr auch so nette Anekdoten?
+>> >> Gruss Michaela
+
+
+> > Keine eigenen, aber im Magazin der Sueddeutschen Zeitung habe ich vor
+kurzem
+> > folgende gelesen:
+
+> > Das Kind fragt die Mutter, was denn in der Fabrik da hinten so laut sei,
+> > woraufhin die Mutter meinte, dass sein ein "Walzwerk", was so viel Laerm
+machte.
+
+> > Zwei Tag spaeter fragt das Kind, was denn der "Waldzwerg" eigentlich genau
+mache
+> > in der Fabrik :-)
+
+Tja, es gibt eben Waldzwerge und Walzwerke. 
+Und es gibt Waldzwerge, die in Walzwerken arbeiten, die sogenannten
+Walzwerkwaldzwerge. Die sollte man aber nicht mit den Walzwerken verwechseln,
+die wiederum anderen Waldzwergen gehoeren, also mit den Waldzwergwalzwerken. 
+Wenn es allerdings so weit kommt, dass Walzwerkwaldzwerge in
+Waldzwergwalzwerken arbeiten, wir uns also gewissermassen mit 
+Waldzwergwalzwerkwaldzwergen beschaeftigen, dann wird es kompliziert.
+
+
+Dirk
+-- Wir produzieren Sicherheit 
+
+-----------------------------------------------------------------------------
+
+
+
+Ebay banishen! Komplettloesung!!! (Ronda, 19. Dez 2007, 22:36:49):
+From: Christian Gruenwaldner <christian.gruenwaldner@gmx.at>
+Newsgroups: de.etc.handel.auktionshaeuser
+Subject: Re: Also ich weiss nicht...
+Date: Mon, 10 Dec 2007 09:00:19 +0100
+Message-ID: <5s4a0sF17i64sU2@mid.individual.net>
+
+
+[SN: Quoting ergaenzt]
+
+Daniel Fuchs schrieb:
+
+ > Habe heute einen Artikel ersteigert. Zuletzt hiess es da ja noch
+ > "Herzlichen Glueckwunsch, Sie haben den Artike ersteigert" oder
+ > sowas in der Art. Heute kriegte ich folgende um die Ohren
+ > gehauen: "Sie haben in den letzten Minuten das hoechste Gebot
+ > abgegeben. Herzlichen Glueckwunsch, Sie haben die Konkurrenz
+ > geschlagen!"
+
+Ebay: Das laengste Onlinespiel der Welt.
+
+Hat mal wer 'ne Komplettloesung?
+
+-----------------------------------------------------------------------------
+
+
+
+Post-Pin? (Ronda, 19. Dez 2007, 22:38:26):
+From: Martin Kissel <martinkissel@sharing.de>
+Subject: Re: PIN Briefservice will Geschaeft einstellen!
+Newsgroups: de.comm.anbieter.mobil
+Date: Sun, 09 Dec 2007 11:20:11 +0100
+Message-ID: <5s1tqbF175khuU1@mid.individual.net>
+
+Markus Gohl wrote:
+> > Die Post will bis 2009 Packstationen, also die Paket-Postfaecher, ueber
+die
+> > man auch Pakete aufgeben kann, flaechendeckend anbieten. Das passt zu
+deren
+> > Strategie im Frachtbereich: Bezirke vergroessern, Bezirke an Fremdfirmen
+> > abgeben, Zusteller mit nem Stadtplan und > 300 Sendungen in grosse und
+fuer
+> > sie unbekannte Bezirke schicken.
+
+Das passt zu meinen Erfahrungen im letzten Jahr. Ich habe bei DHL
+angerufen um mich nach dem Verbleib eines Pakets zu erkundigen.
+
+- Hier steht, das Paket ging wieder an den Absender zurueck, weil sie
+nicht angetroffen wurden.
+- Wie bitte? Das kann eigentlich gar nicht sein.
+- Doch, sowas kommt haeufig vor.
+- Schauen Sie sich bitte die Empfaenger-Adresse an.
+- Oh, ne Packstation. <Stille> Ja aeh das versteh ich nun auch nicht.
+
+Wusste der Zusteller nicht wie ne Packstation funktioniert?
+
+Gruss,
+Martin
+
+-----------------------------------------------------------------------------
+
+
+
+Und nochmal: Ex-Post (Ronda, 19. Dez 2007, 22:38:42):
+From: Dirk Schneider <spam_scd603@gmx.de>
+Newsgroups: de.etc.handel.auktionshaeuser
+Subject: Re: Endlich Kuehlschrankmagnete...
+Date: Wed, 05 Dec 2007 21:05:26 +0100
+Message-ID: <fj70a6$pt$01$1@news.t-online.com>
+
+Dirk Schneider <spam_scd603@gmx.de> wrote:
+
+> >Lothar Frings schrieb am 05.12.2007 15:32:
+> >
+>>> >>> Nun liegen hier 6 Magenten.
+>> >> ....................^^^^^^^^
+> >
+>> >> Du hast sechs Telekom-Mitarbeiter umgebracht?
+> >
+> >Nein, die hatten Cyanose.
+> >
+> >Gruss Dirk.
+
+-----------------------------------------------------------------------------
+
+
+
+Und was ist "mudisiert"? (Ronda, 19. Dez 2007, 22:39:24):
+From: Hans-Georg Bickel <hgbusenetmuell@gmx.de>
+Newsgroups: de.rec.mampf
+Subject: Re: "Speisekartenterminologie" - seit wann?
+Date: Mon, 03 Dec 2007 18:19:12 +0100
+Message-ID: <fj1hb0.rg.1@ID-108823.user.uni-berlin.de>
+
+Sebastian Karkus <karkus@spamcop.net> wrote:
+
+> >Oder ist das nur hier so in der Mensa oder habe ich unwissend im Koma
+> >gelegen und habe etwas verpasst, was die "Speiskartenterminologie" angeht?
+
+Warum soll das sprachliche Schoensaufen der Welt gerade bei
+Speisekarten haltmachen?
+
+Wir haben doch auch so wunderhuebsche Entsorgungsparks, jeder
+Fahrkartenschalter ist mittlerweile ein ReiseZentrum und in
+Firmen meldet sich auch laengst keiner mehr mit dem Namen. Da
+heisst es nicht mehr $FIRMA, Mueller, guten Tag!" sondern "$FIRMA,
+Ihr Haus fuer intelligente Geschaeftsabschluesse, Servicezentrum fuer
+VIP-Kunden, mein Name ist Karl-Otto Mueller, wie kann ich ihnen
+helfen?" In der Zeit, in der der arme Mann den ganzen Sermon
+runterbeten muss, haette ich mein Anliegen laengst vortragen
+koennen.
+
+Es gibt ja auch keine Koeche mehr. Und wenn, dann werden sie vor
+der Oeffentlichkeit sorgfaeltig verborgen und fristen wohl in
+finsteren Kuechenecken ihr klaegliches Dasein. 'Chefkoch' ist das
+mindeste. Besser noch 'Sternekoch' oder (falls kein Stern
+vorhanden) 'Starkoch', 'Gourmetkoch' oder 'Spitzenkoch'. Der darf
+auch gerne noch verfeinert werden. 'Oeko-Spitzenkoch' las ich
+neulich irgendwo. Wer das erste Haus am Platze fuehrt, ist
+mindestens 'Regionaler Spitzenkoch'. Neulich wurde jemand in
+irgendeiner Fernsehsendung als 'Gesundheitskoch' vorgestellt. Was
+zum Geier ist das schon wieder?
+
+Selbst vor der Kuechensprache machen die Sprachblaehungen keinen
+Halt. Da werden Saucen zuerst 'durch ein Sieb abpassiert' (Schoen
+zu wissen, dass sie nicht aufpassiert oder gar bypassiert werden.)
+bevor sie dann 'einreduziert' werden (Wie reduziert man eine
+Sauce aus? Oder vielleicht auf? Oder ab?)
+
+Gewuerzt wird auch nicht mehr. 'Anwuerzen' klingt ja viel cooler!
+Oder es wird gleich -isiert. 'Safranisiert' ist mir da als
+besonders abschreckendes Beispiel in Erinnerung. Bestimmt wird
+bald auch 'sternanisiert', 'galgantisiert', 'vanillisiert' und
+'majoranisiert'. Leider klingt 'zimtisiert' und 'minzisiert'
+etwas bloed. Aber dann heisst es halt 'mit ... aromatisiert' und
+das ist ja gleich eine ganz andere Klasse als 'mit Zimt' oder
+'mit Minze'.
+
+
+Also: Cool bleiben und nicht aufregen!;-)
+
+HG
+
+-----------------------------------------------------------------------------
+
+
+
+Speisekartenterminologie - logisch (Ronda, 19. Dez 2007, 22:40:50):
+From: kscheller@ochs.franken.de (Konni Scheller)
+Newsgroups: de.rec.mampf
+Subject: Re: "Speisekartenterminologie" - seit wann?
+Date: Fri, 30 Nov 2007 21:06:57 +0100
+Message-ID: <1i8et7b.akxgopmacvmbN%kscheller@ochs.franken.de>
+
+Sebastian Karkus <karkus@spamcop.net> wrote:
+
+> > "Bratwurst mit Zwiebeljus" 
+> > - Zwiebeljus ist doch normale Zwiebelsosse oder nicht?
+
+jus = woertl. "Saft". 
+
+> > "Haehnchenbrustfilet "Diana""
+> > - Was soll der Namen denn einem sagen? Koechin? In Memoriam Princess
+Diana?
+
+Diana ist die Goettin der Jagd. Also moeglicherweise was mit Pilzen oder
+etwas anderem, was man im Wald gefunden hat. 
+ 
+> > "Altenburger Sahnegeschnetzeltes
+> > ( mit magerem Speck und frischen Champignons)
+> > abgerundet mit Cognac und Senf)"
+> > 
+> > Ist es vorher eckig oder warum rundet man es? Hiess das nicht frueher 
+> > "mit einem Schuss ...", was nun als "abgerundet mit" praesentiert wird?
+
+Also lieber abgerundet als mit Schrotkoernern vom Schuss... 
+ 
+> > "Thueringer Rostbratwurst an deftiger Biersauce" 
+
+Das ist ein sogenannter Anitiv. Blutwurst *an* Sauerkraut. 
+
+
+> > oder "Gefuellte
+> > Paprikaschote mit Weizenproteinen an fruchtiger Tomatensauce" 
+> > oder "Gefuellte Paprikaschote mit Weizenproteinen an fruchtiger
+> > Tomatensauce" oder "Weisswuerstchen mit suessem Senf an Weinsauerkraut".
+
+Dito. 
+ 
+> > Warum ist denn das nun alles an den Speisen, wo es IIRC frueher mit
+> > hiess? 
+
+"an" heisst es liegt daneben, waehrend "mit" auch reingeruehrt heissen
+koennte. Anitivus ruehrenus. 
+
+> > Jeden Tag auf jeder Karte ist nun etwas "an" etwas anderem und sogar
+> > die Farfalle bekommt man mittlerweile nicht mit einer Kaesesosse, sondern
+"an
+> > Kaesesauce" :(
+
+Grammatikfehler. 
+
+...und nun giessen wir das Ganze unter staendigem Ruehren in den Ausguss. 
+
+Servus,
+Konni
+
+-----------------------------------------------------------------------------
+
+
+
+Koennte aus der MPA sein. Oder? (Ronda, 19. Dez 2007, 22:42:16):
+From: "Karsten Paulsen" <Paulsen@allesgelogen.de>
+Newsgroups: de.rec.fotografie
+Subject: Re: [F] Einbein
+Date: Sat, 1 Dec 2007 15:21:44 +0100
+Message-ID: <firqme$5l2$1@news1.ewetel.de>
+
+"Sebastian Loewenhag" <sebastian.loewenhag@rwth-aachen.de> schrieb im 
+Newsbeitrag news:5rd4opF141t0pU1@mid.dfncis.de...
+> > Hallo zusammen,
+> >
+> > ich besitze zur Zeit eine Sony Alpha 100 mit ein paar Linsen. Da ich
+> > sehr viel in Zoos fotografiere und wahrscheinlich naechstes Fruehjahr 
+> > ein
+> > Tamron 200-500 dazu kommen wird draengte sich mir der Wunsch nach einem
+> > Einbein auf. Ich habe allerdings ueberhaupt keine Ahnung was man bei
+> > Stativen grundsaetzlich beachten muss.
+
+Wichtig! Es faellt um wenn man es loslaesst!
+
+Karsten 
+
+
+[Ronda] ... ok, es IST jetzt in der MPA. Aber es KOENNTE auch so in der MPA
+sein, wenn es nicht so in der MPA waere. Oder? Hmmmm...
+
+-----------------------------------------------------------------------------
+
+
+
+Ich-AG - Prost! (Ronda, 19. Dez 2007, 22:42:41):
+Date: Sat, 01 Dec 2007 22:59:59 +0100
+From: Michael Kutscher <spam.ignore@pc-coach.de>
+Newsgroups: de.etc.beruf.selbstaendig
+Subject: Re: Freiberufler und Weihnachtsfeiern
+Message-ID: <4751d992$0$13114$9b4e6d93@newsspool2.arcor-online.net>
+
+Hi,
+> > Die Zeit der Weihnachtsfeiern ist mal wieder gekommen. Staendig hoert
+> > man von den Leuten, dass sie auf irgendwelche Weihnachtsfeiern gehen.
+
+Vor einiger Zeit las ich eine Zeitungsnotiz in der Rubrik 
+"Polizeibericht". Da hiess es sinngemaess:
+
+Im Park traf eine Fussstreife einen einsamen Zecher an, der es sich mit 
+mehreren Weinflaschen auf einer Bank gemuetlich gemacht hatte. Auf die 
+Frage, was er da denn taete, antwortete er: "Das ist die 
+Weihnachtsfeier... meiner Ich-AG".
+
+Gruss
+Michael Kutscher
+
+-----------------------------------------------------------------------------
+
+
+
+Di Beterey hilft da nit vil (Ronda, 21. Dez 2007, 22:06:55):
+Newsgroups: de.rec.musik.klassik
+Subject: Re: Kann Bruckner so wertvoll sein???
+From: Oliver Scholz <alkibiades@gmx.de>
+Date: Wed, 19 Dec 2007 11:48:04 +0100
+Message-ID: <4768f6e8$0$13121$9b4e6d93@newsspool2.arcor-online.net>
+
+Daniel Fuchs <dfuchs8stud.uni-goettingen.de@web.de> writes:
+
+> > Oliver Scholz wrote:
+>> >> Naja, das Argument, dass diese spezifischen Auslassungszeichen etwas
+>> >> anderes seien, als die vom Duden vorgesehenen, ist ein bisserl
+>> >> fragwuerdig.
+> >
+> > <Gebetsmuehle>Ich sehe diese drei Punkte hier _nicht_ als
+> > Auslassungszeichen. Was soll da ausgelassen sein?
+
+Di Beterey hilft da nit vil / denn ich seh dich nit in der
+orthographia von 1668 scribiren / und darumb ist / sovil es mein
+Achten ahngeht / dasz alles eh falsch. Denn rechtes Schreiben heist auch /
+die  k o m m a t a  recht zu appliciren / und so kan ich es nur uebel zu
+frieden seyn / blos kleine Muckenkuesze an dasz letzte Wort zu kleistern /
+sondern man mus hertzhaffte Strich mit rechtem Abstandt machen.
+Sintemal ohne diss ist dasz Reden ueber orthographia eh umbsonst und
+eitel Plapperey.
+
+
+    Oliver, 29 Frimaire 216
+-- Nur der Kunstliebhaber liebt wirklich die Kunst, der auf eineige seiner
+Wuensche voellig Verzicht tun kann, wo er andre ganz unbefriedigt finde, der
+auch das Liebste noch streng wuerdigen mag, der sich im Notfall Erklaerungen
+gefallen laesst, und Sinn fuer Kunstgeschichte hat. --- Friedrich Schlegel:
+"Athenaeums Fragmente" (1798) 
+
+-----------------------------------------------------------------------------
+
+
+
+Transvomatoren *brrrrr!* (Ronda, 21. Dez 2007, 22:09:15):
+[SN Note:  Quoting ergaenzt]
+
+From: Enrik Berkhan <enrik@akk.org>
+Newsgroups: ka.misc
+Subject: Re: Bastelladen
+Message-ID: <fjuft1$vc9$1@chekov.starfleet.inka.de>
+Date: Fri, 14 Dec 2007 17:52:33 +0000 (UTC)
+
+Reinhard Forster <rf@micro-forster.de> wrote:
+> > Vor zwei(?) Wochen wollte ich eine kleinen Travo, so ca. 1 VA. Auf 
+> > Nachfrage hiess es "sowas haben wir leider nicht mehr"  :-(
+
+Ich fuerchte Umkotzer (Transvomatoren) hatten die noch nie.
+
+Enrik
+
+-----------------------------------------------------------------------------
+
+
+
+Mag ihn eine der anwesenden RA'innen vertreten? (Ronda, 21. Dez 2007, 22:11:06):
+From: Frank Arnim <me@privacy.net>
+Newsgroups: oecher.talk
+Subject: Re: Was ist das Schloss in der Kongressstrasse?
+Date: Thu, 20 Dec 2007 14:08:51 +0100
+Reply-To: rics @ gmx net
+Message-ID: <r9qkm39udgdlm61u4c0nqt4sjce1bab1f8@4ax.com>
+
+
+Ali <dipl.kfm.yildirim@googlemail.com>
+
+> >Hallo zusammen,
+> >weiss jemand, was das Gebaeude in der Kongressstrasse ist, das wie ein
+> >Schloss aussieht?
+
+Landgericht Aachen
+
+> >Kann man da rein?
+
+Klar: Straftat begehen! :-)
+
+-----------------------------------------------------------------------------
+
+
+
+Vaeter bei der Geburt... (Ronda, 21. Dez 2007, 22:12:08):
+From: Oliver Jennrich <oliver.jennrich@gmx.net>
+Subject: Re: Was ist Zivilcourage?
+Newsgroups: de.etc.sprache.deutsch
+Date:Tue, 18 Dec 2007 23:55:58 +0100
+Message-ID: <a1f3atzhatd.fsf@ID-371.news.uni-berlin.de>
+
+>>> >>> Das ist gar nicht mal so bloed, wie es sich anhoert. Ich war bass
+erstaunt,
+>>> >>> wie fest und kompakt so eine Nabelschnur ist. Ich dachte vorher, da
+machst
+>>> >>> "schnipp", und dann ist das Ding durch. Von wegen.
+
+>> >> Die Hebamme schaute etwas schraeg, als ich mich erbot, die
+>> >> Gefluegelschere aus der Kueche zu holen, um nicht noch weiter mit der
+>> >> Verbandschere an der Nabelschnur rumnagen zu muessen.
+
+> > Haettest halt dazu sagen muessen, dass die Gefluegelschere fuer die
+> > Nabelschnur ist und nicht fuer den Kaiserschnitt.
+
+Wenn man erstmal dabei ist, die Nabelschnur zu durchtrennen, ist es
+fuer den Kaiserschnitt zu spaet.
+
+-----------------------------------------------------------------------------
+
+
+
+Rumms. (Ronda, 21. Dez 2007, 22:15:39):
+[Moderator's Note: Lst = Leitstelle, KTW = Krankentransportwagen]
+
+From: Udo Burkhard <u.burkhard@gmx.de>
+Newsgroups: de.etc.notfallrettung
+Subject: Re: VoIP-Lokalisierung
+Date: Mon, 17 Dec 2007 07:39:43 +0100
+
+Bernhard Nowotny schrieb:
+> > Erich Kirchmayer schrieb:
+>>> >>> Kein Mensch kennt den Vorort. Die Karte auch nicht. Die Leitstelle?
+>>> >>> Reagiert nicht auf Funkruf. 
+>> >> Na, du bist aber einfallslos - da faehrt man zur naechsten Kirche, 
+>> >> Tankstelle, Polizeiwache, Dorfladen etc. und fragt nach. Wenn es den 
+>> >> Ort gibt, dann weis das irgendwer.
+
+> > Flasch: echte[TM] Retter fragen NIEMALS nach dem Weg! Sie wissen
+> > intuitiv, wo der Einsatz ist...
+
+> > Beweis: ich bin noch immer an einem Einsatzort angekommen, wenn er
+> > noch da war. Notfalls muss man sich halt einen selbst machen, aber
+> > das ist wieder eine andere Geschichte.
+
+
+Bernhard,
+
+echte Retter sind vor dem Einsatz zur Stelle!
+
+Passierte 1982 in einem sauerlaendischen Landkreis:
+KTW steht an einer als Unfallschwerpunkt bekannten Einmuendung.
+Von rechts kam ein Fahrzeug, von links ebenso.
+
+Fzg: "Leitstelle vom 0/85-1"
+Lst: "kommen"
+Fzg: "Standort XYZ" krach-schepper im Hintergund
+Lst: "Verstanden, Polizei und Feuerwehr sind unterwegs!"
+
+;D
+
+Best Gruesse, Udo.
+
+-----------------------------------------------------------------------------
+
+
+
+Amen. (Ronda, 21. Dez 2007, 22:15:57):
+[S/N: Man beachte den Namen des OP, den Betreff und die eigentliche Frage
+(Fullquote)]
+
+From: Reiner Schischke <reiner.schischke@free.fr>
+Newsgroups: de.alt.rec.digitalfotografie
+Subject: Re: Jesus hat euch lieb
+Date: Sun, 16 Dec 2007 13:31:43 +0100
+Message-ID: <47651aaf$0$31442$426a74cc@news.free.fr>
+
+
+Jesus Christus schrieb:
+> > Nebenbei:
+> > 
+> > Welche Software benuetzt ihr fuer eure Bildverwaltungen?
+
+Als Angehoeriger einer Religionsgemeinschaft, die ein schweres 
+Folterinstrument als ihr Symbol verehrt lehnst du sicher bildliche 
+Darstellungen von Folter und Inquisition ab, sonst koennte man euch zu 
+viel nachweisen. Also wozu Bilder verwalten?
+
+-----------------------------------------------------------------------------
+
+
+
+Lilli ist geladen. Oder: Wunderkatze (Ronda, 22. Dez 2007, 18:09:55):
+From: Burkhard Mueller <wurstwasser@gmx.org>
+Subject: Re: Lilli ist geladen
+Newsgroups: de.rec.tiere.katzen
+Date: Tue, 18 Dec 2007 21:32:52 +0100
+Message-ID: <47682E74.1020101@extrapunk.de>
+
+*Gerd Schweizer* wrote:
+> >Arno Schuh schrieb:
+>> >>Hi,
+>> >>
+>> >>da jetzt hier seit ein paar Stunden die Luftfeuchtigkeit gegen 0
+tendiert,
+>> >>ist Lilli beim Streicheln schon nach kurzem ganz schoen geladen. ;-)
+> >Arno, ob das durch die Miez bedingt ist?
+> >Wo sitzt sie beim Streicheln und wo Du?
+> >Vielleicht ist eher Deine Kleidung die Ursache? Beim Streicheln faehrst
+> >Du bestimmt auch mit dem Arm ueber Deine Kleidung/ Hose?
+
+Jau, ganz beliebt: Kunstfaser!
+Einen Poly*(amid, acryl, ester, styrol, etc.)-Pullover anziehen, die
+Katze
+gemuetlich umarmen und kraeftig *schrubbeln*. Wenn man dabei das Licht
+ausmacht hat man eine huebsche Wunderkerze. :-D
+Jeder, der schon mal einen PC umgebaut und dabei den Beipackzettel
+einer neu gekauften PC-Komponente gelesen hat, weiss wie man das
+vermeidet; Stichwort: Erdung! Also die Katze nach ein wenig Streicheln
+kurz
+zum erden mit der Nasenspitze z.B. an ein Heizungsrohr druecken. Nach
+dem ersten Funkenflug kann man die Katze gefahrlos ein wenig
+weiterstreicheln
+- oder nach dem Erste-Hilfe-Kasten suchen. ;-)
+
+Da faellt mir eine Anekdote aus meiner Jugend ein: einer meiner besten
+Jugendfreunde hat sich ein paar mal einen Spass mit seiner Mutter
+gegoennt.
+Er ist in der Wohnung ein wenig mit seinen Rollerskates (Plastikrollen!)
+auf
+dem Teppichboden (Kunstfaser!) herumgefahren. Wenn sie dann von der
+Arbeit kam hat er sie mit Handschlag begruesst. Das Gefluche konnte ich
+noch ein paar Zimmer weiter hoeren.
+
+Tschuess, BM
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Rumms. (Bambi, 23. Dez 2007, 14:59:10):
+~#! rn=Ronda rt=1198271739 rg=schmarrn.netdigest
+~#! tid=1198271739
+Fzg: Leitstelle fuer XXX/XX/X, kommen.
+Lst: Hoert
+Fzg: Wir sind an der Adresse ABC angekommen. Hier sind zwei Klingelschilder,
+"Meyer" und "Heinzel". Wir sollen zu "Meyer". Frage: An welcher Klingel sollen
+wir klingeln?
+
+Da kam ihr Spruch "Wer lesen kann, ist klar im Vorteil." nicht ganz unpassend,
+auch wenn es eigentlich haette heissen muessen: "Wer (mit)denken kann, ..."
+
+-----------------------------------------------------------------------------
+
+
+
+Immer diese Chaoten! (Ronda, 26. Dez 2007, 01:01:46):
+From: "Michael Landenberger" <spameimer052006@arcor.de>
+Subject: Re: Chaos bei Real
+Newsgroups: de.alt.fan.aldi
+Date: Sun, 23 Dec 2007 19:58:51 +0100
+Message-ID: <5t7pfjF1ch0p9U1@mid.uni-berlin.de>
+
+"Laura Ohrndorf" <laura.ohrndorf@gmail.com> schrieb:
+
+> > Neulich gehoerten zwei Dosen Pfirsiche zu meinem Einkauf, die sich
+> > nicht einscannen liessen. Die Kassiererin stritt sich solange mit
+> > der Nachbarkassiererin bis man sich auf 29 Cent geeinigt hatte -
+> > mein Vorschlag "79 Cent", der sich beim naechsten Einkauf als
+> > korrekt herausstellte, blieb unbeachtet.
+
+Ich kaufe des oefteren in einem Supermarkt ein, bei dem Obst und Gemuese
+an der Kasse abgewogen werden. Die Waage ist in den Scanner
+integriert. Beim Abwiegen von Porree und anderem Gemuese, das laenger ist als
+die 
+Wiegeplatte breit, stellen die Kassiererinnen ueblicherweise eine ca. 
+3cm hohe Styroporschale umgedreht auf die Waage und legen das Gemuese 
+quer darueber. Dadurch wird verhindert, dass die Enden des Wiegeguts
+auf dem Tisch aufliegen und die Waage ein falsches Gewicht ermittelt. Die 
+Schale wiegt selbst fast nix und ihr Gewicht duerfte auch taramaessig in 
+der Waage gespeichert sein.
+
+Neulich kam ich mit einer durchaus ansehnlichen Stange Porree zur
+Kasse und die Kassiererin legte sie auf die Waage, aber ohne die 
+Styroporschale. Ich wies sie darauf hin, dass sie die Schale vergessen
+habe und die Waage daher hoechstwahrscheinlich ein zu niedriges Gewicht
+ermitteln wird (der Porree lag mit beiden Enden rechts und links der 
+Wiegeplatte auf). Die Kassiererin ignorierte diesen Hinweis, wunderte 
+sich aber darueber, dass die Waage einen Wiegefehler meldete. 
+Schliesslich tippte sie das auf dem Display angezeigte Gewicht manuell 
+in die Kasse. Nachdem ich meinen Einkauf bezahlt und die Kasse 
+verlassen hatte, schaute ich auf den Kassenzettel. Darauf fand ich 
+einen Posten "Porree: 2g". Der Preis dafuer betrug genau 1 Cent, was
+mit Abstand der niedrigste Preis war, den ich jemals fuer ca. 400g Porree 
+bezahlt habe. Naja, wenn man die Physik so dreist ignoriert und dann 
+auch noch auf eine Plausibilitaetspruefung verzichtet, kann so was schon
+mal passieren ;-)
+
+Gruss
+
+Michael 
+
+-----------------------------------------------------------------------------
+
+
+
+Passende Signatur: Trust in me and fall as well (Ronda, 26. Dez 2007, 01:10:00):
+From: Karl 'Gambrinus' Valentin <tonne@karlvalentin.de>
+Subject: Vom Aufschwung
+Newsgroups: de.talk.bizarre
+Date: Mon, 24 Dec 2007 15:26:33 +0000 (UTC)
+Message-ID: <slrnfmvcnr.12f.tonne@toxoplasmose.karlvalentin.de>
+
+
+Kalt wars. Und dunkel. Und verdammt glatt. Man musste aufpassen,
+dass man nicht ausrutscht. Es war besser, wenn man sich nur
+langsam und vorsichtig vorwaerts bewegte. An ein zuegiges Laufen
+oder gar Rennen war gar nicht zu denken. Nur die Schneeflocken
+waren so unvernuenftig und konnten das Tanzen nicht sein lassen.
+Aber Schneeflocken jammern auch nicht, wenn sie auf dem Eis zum
+Liegen kommen. Das sind schon lustige Zeitgenossen.
+
+Im Buero brannte noch Licht. Durch die Rauchwolken, die der
+Weihnachtsmann in die Luft pustete, konnte man erkennen, dass
+sich der Rauschebart, Rudi und einige Kernpostenwichtel zum
+strategischen Gluehweintrinken versammelt hatten.
+
+"Die Leute sind doch alle bekloppt." schimpfte der
+Auftragserfassungswichtel August-Eugen. "Frueher haben sie uns
+einfach ihren Wunschzettel geschickt, wir haben die Geschenke
+eingepackt und verteilt. Naja, und reichlich Gluehwein getrunken.
+Und heute? Heute kommen zwar auch Wunschzettel, aber dann kommen
+dazu von anderen Leute Kommentare, Dritte sagen, die Verpackung
+gestreift sein, ..." "Ja", unterbrach ihn da Packwichtel Paul
+beipflichtend, "kaum hat man etwas eingepackt und moechte kurz
+am Gluehwein nippen, da muss man das Geschenk schon wieder
+auspacken und wieder neu einpacken.
+
+"Und warum das alles?" zeterte August-Eugen weiter. "Weil die
+Abteilung Oeffentlichkeitsarbeit behauptet, dass komme beim
+Kunden gut an. ZweiNull nennen sie den Unfug. Demnaechst soll
+das Rentier auch noch mit blinkender Nase unterwegs sein. Pah!"
+Der Wichtel zeterte weiter und weiter und schien gar nicht
+damit aufhoeren zu wollen und nach und nach stiegen die anderen
+Wichtel mit ein.
+
+Unbeachtet vom sich Luft machenden Wichtelmob beseitigte der
+Weihnachtsmann den Gluehwein von seinem Schreibtisch, den er
+zusammenzuckenderweise verschuettete, als er vernahm, dass es
+mittlerweile eine Abteilung Oeffentlichkeitsarbeit gab. 
+
+Er war auch schon letztens sehr verwirrt, weil die Abteilung
+Personalwesen, von der er vorher auch noch nichts gehoert hatte,
+sich angeblich weigert, Lehrstellen fuer Fachwichtel zu schaffen,
+weil Praktikanten guenstiger kaemen. Das wollte der Rauschebart
+ja so ganz und gar nicht verstehen. Er ging immer davon aus,
+dass alle ehrenamtlich arbeiten.
+
+"Weihnachtsmann," fragte Rudi verschuechtert, "muss meine Nase
+morgen wirklich blinken?" "Nein!" Der Weihnachtsmann schlug
+mit der Hand auf den Tisch. Ploetzlich war alles still und
+schaute zum Rotkittel. "Alles bleibt beim alten. Wir sind ein
+Traditionsunternehmen."
+
+Rudi war erlichtert und trottete aus dem Buero in den Stall,
+wo schon die Gluehweintraenke auf ihn wartete. Vom Hof her
+konnte man ein "Trink, Rudilein, trink, faerb deine Nase
+rot ein!" vernehmen, spaeter auch noch andere, eher seltsame
+Gesaenge. Noch spaeter war nur noch ein Schnarchen zu hoeren.
+
+Rein theoretisch waren da zwei Schnarcher, aber der
+Weihnachtsmann hatte im Sommer neue Fenster einbauen lassen,
+so dass die Schallwellen nur gegen die Scheibe klatschten und
+an dieser herunterrutschten.
+
+Und es ward Abend, und es ward Morgen: Heiligabend. Und wie
+sollte es auch anders sein, es war ein herrlicher Tag. Eine
+Alternative waere zum Beispiel ein Schneesturm gewesen. Nach
+einem kraeftigen Fruehstueck - Gluehwein mit Schuss - bestieg der
+Weihnachtsmann den bepackten Schlitten und die Fahrt ging
+los.
+
+Die Fahrt verlief soweit ganz gut, lediglich das rote
+Heissgetraenk war deutlich untertemperiert. "Rudi, kann es sein,
+dass wir heute etwas schnell unterwegs sind?" "Wieso fragst Du,
+Weihnachtsmann?" "Naja, der Gluehwein in meinem Becher ist
+gefroren und in diesem Zustand bekomme ich ihn einfach nicht
+da raus." Das Rentier wurde langsamer und der Weihnachtsmann
+goss Schluck fuer Schluck aus der Thermoskanne nach, um sein
+geliebtes Getraenk wieder auf Trinktemperatur zu bringen, was
+ihm dann auch gelang. Allerdings liess dann, erfreut ueber den
+gelungenen Gluehweinrettungsversuch, seine Sorgfalt und
+Aufmerksamkeit nach, die Geschwindigkeit des Gefaehrts nahm
+hingegen wieder zu.
+
+"Rudi!" schrie der Weihnachtsmann. "Ich habe schon wieder
+Gluehweineis in meinem Becher! Warum sind wir denn heute so
+schnell unterwegs?" "Naja, Weihnachtsmann," antwortete das
+Rentier, "die Strecke ist frei." "Die Strecke ist frei?
+Das Rentier beliebt heut wohl zu scherzen? Die Strecke ist
+immer frei!" "Hmm, stimmt auffaellig. Ich glaube, der Schlitten
+ist heute nicht so schwer. Wir muessen nicht so viele
+Geschenke verteilen." "Weniger Geschenke? Das ist doch aber
+voellig gegen den Trend. Die Wunschzettel sind von Jahr zu
+Jahr laenger geworden." "Ja, aber jetzt ist der Aufschwung bei
+der Bevoelkerung angekommen. Sie haben es einfach nicht mehr
+noetig, sich etwas schenken zu lassen."
+
+Einige Becher Gluehweineis spaeter kam der Schlitten in der
+Zivilisation an. Der Weihnachtsmann leckte den Loeffel ab,
+schnappte sich einen Sack und stapfte zum ersten Haus,
+er klingelte und ward eingelassen. Die kleine Carina wusste
+auch ein kleines Gedicht aufzusagen:
+
+Der Weihnachtsmann, wie jeder weiss,
+hat einen roten Mantel an,
+sein Rauschebart ist weiss und lang,
+sein Gluehwein in der Tasse heiss.
+
+Der Rauschebart freute sich sehr ueber das Gedichtchen und lobte
+das Maedchen. "So, Carina, da wollen wir mal schauen, was
+ich so fuer Dich habe. Schau mal, ein Malbuch und Buntstifte!"
+Die kleine Carina wollte schon anfangen, mit den Buntstiften
+das Malbuch auszumalen, doch der Weihnachtsmann wuehlte weiter
+in seinem Sack und holte wieder etwas heraus. "Schokolade!"
+rief die Kleine uebergluecklich und liess Buntstifte und Malbuch
+fallen, um die Schokolade in Empfang zu nehmen. Der Rotkittel
+kramte weiter in seinem Sack, waehrend die Schokolade geoeffnet
+wurde, und holte ein Plueschtier hervor. "Ein Teddy!" Auch die
+Schokolade wurde fallengelassen und dafuer der Plueschbaer fest
+umarmt.
+
+Das Maedchen wartete gespannt, was der Weihnachtsmann als
+naechstes aus dem Sack holen wuerde. Irgendetwas musste ja noch
+kommen, schliesslich kramt er noch in seinem Sack rum. "Und
+zum Schluss", sprach der Weihnachtsmann stolz, fast feierlich,
+"noch eine Tube Anti-Falten-Creme." Anti-Falten-Creme? Fuer
+eine Fuenfjaehrige? Ist diese Form der Altervorsorge nicht doch
+etwas uebertrieben? Der Weihnachtsmann beschloss, mit dieser
+Abteilung Personalwesen mal ein ernsthaftes Wort zu reden.
+Einem gelernten Packfachwichtel waere so ein Fehler sicher
+nicht unterlaufen.
+
+Jetzt galt es allerdings eine Situation zu retten. Das Maedchen
+umklammerte ihren Teddy und schaute verstoert drein. Der Rest
+der Familie hatte leider keinen Teddy zur Hand, verstoert
+dreinschauen konnten sie trotzdem recht gut. "Entschuldigung,"
+sprach der Weihnachtsmann, "da ist dem Packwichtel wohl ein
+kleiner Fehler unterlaufen." Der Weihnachtsmann durchforstete
+seine Manteltasche und holte schliesslich eine kleine Spieluhr
+hervor.
+
+Er zog sie auf und die Figuren begannen zu einer Melodie zu
+tanzen. Sogar ein paar tanzende Schneeflocken waren dabei.
+Die ganze Familie war entzueckt. Tanzende Schneeflocken! Sowas
+kannte man doch sonst nur noch aus Unwetterszenarien. Die kleine
+Carina nahm die Spieluhr vorsichtig entgegen und verlor sich
+in den tanzenden Figuren, nachdem sich der Rauschebart
+nochmals entschuldigt und dann verabschiedet hatte.
+
+Der Weihnachtsmann setzte sich wieder in den Schlitten und die
+Fahrt ging weiter. "Ach, Rudi, die Zeiten sind merkwuerdig. Ich
+glaube, ich bin zu alt fuer diesen Job." seufzte der Rotkittel
+und nahm einen Schluck von seinem Gluehwein. Aber wer sollte
+diesen Job uebernehmen?
+-- Trust in me and fall as well. 
+
+-----------------------------------------------------------------------------
+
+
+
+No Christmas Carol (Ronda, 28. Dez 2007, 16:48:45):
+From: Schaulustiger
+Date: 27.12.2007 11:17
+Subject: No Christmas Carol
+Zur Meldung: Koehler unterzeichnet Gesetz zur Vorratsdatenspeicherung
+URL: 
+http://www.heise.de/newsticker/foren/go.shtml?read=1&msg_id=14127804&forum_id=
+129458
+
+Es begab sich aber zu der Zeit, dass ein Gebot von der
+Bundesregierung ausging, dass alle Welt gespeichert wuerde. Und diese
+Speicherung war die allererste und geschah zur Zeit, da Koehler
+Bundespraesident in Germanien war. Und jedermann der da verkehrte mit
+seinem Nachbarn wurde gespeichert in den elektronischen Bibliotheken
+seiner Stadt.
+
+Da machte sich auf auch Josef aus Treptow, aus der Stadt Berlin, in
+das Internet, das da ward genannt Suendenbabel zu dieser Zeit, weil er
+nicht aus dem Hause wollte im dezemberlichen Volkestrubel, zumal
+nicht mit Maria, seinem vertrauten Weibe, die schwanger darniederlag.
+
+Und als er da kam auf die Seite des Arbeitsamtes, wurd ihm kundgetan,
+dass fuer ihn als Zimmermann geschlagen mit schwerem Rueckenleiden und
+dem Leide des Zuckers der Vorvaeter, wie den Akten zu entnehmen, keine
+Taetigkeit zu finden sei.
+
+Und als er da kam auf die Seite des Sozialamts, wurd ihm kundgetan,
+dass Ochs und Esel, die er sein Eigentum nannte, im Namen des Volkes
+Herren zu opfern seien, bevor er da Berechtigung erhalte, das Heilige
+Harz zu empfangen. Zu opulent sei der Stall fuer der Personen an ihrer
+Zahl zwei; es geboete sich nach Marzahn zu ziehen bis denn geboren sei
+das Kindlein, dann koenne man weitersehen.
+
+Und als er seinem Unmute Luft gelassen hatte auf einer Seite, die da
+beherbergte viele, denen es da aehnlich ergangen war, bekam er Besuch
+von drei Weisen aus dem Land von Morgen, die da gefolgt dem Protokoll
+welches aufgezeichnet seine Untaten; denn so geboten alleroberstens
+die Herren, dass diejenigen, die nichts zu verbergen haetten vor ihres
+Nachbarn Augen, nicht zu befuerchten haetten ihren Zorn.
+
+Und beamtete Engel geleiteten die Eltern nach Karlsruhe, wo Maria
+darnieder kam und das Kindlein gebar in eine BILD gewickelt und
+gebettet bei der Kripo; derweil Josef befragt wurde von Allwissenden
+Herrn, die da bereits wussten alle seine Frevel und Recht ueber ihn
+sprachen. Und eine grosse Ohnmacht ueberkam Josef als er die Macht der
+Herrn erblickte und er gelobte Besserung bis an das Ende seiner Tage.
+Und als sie gelaeutert waren nach dem Gesetz der Herren, kehrten sie
+wieder zurueck nach Treptow in ihre Stadt Berlin. Das Kind aber wuchs
+und wurde stark, voller Weisheit, und die staatliche Fuersorge war
+allezeit bei ihm.
+
+-----------------------------------------------------------------------------
+
+
+
+Re: No Christmas Carol (Bambi, 29. Dez 2007, 16:38:15):
+~#! rn=Ronda rt=1198856925 rg=schmarrn.netdigest
+~#! tid=1198856925
+Irgendwie sind mir die Pointen der letzten beiden Artikel entgangen. Kann mir
+die wer zeigen? Ausserdem vermisse ich irgendwie den Bezug zwischen "Koehler
+unterzeichnet Gesetz zur Vorratsdatenspeicherung" und dem Text mit der Geburt.
+Erleuchte mich bitte jemand.
+
+-----------------------------------------------------------------------------
+
+
+
+31.12.9999 - und: schoene Signatur (Ronda, 30. Dez 2007, 22:45:32):
+From: Andreas Prilop <aprilop2007@trashmail.net>
+Subject: Re: ISO 8601 International Date Format
+Newsgroups: de.etc.sprache.misc
+Date: Thu, 20 Dec 2007 16:21:24 +0100
+Message-ID:
+<Pine.GSO.4.63.0712201615330.4205@s5b004.rrzn.uni-hannover.de>
+
+On Thu, 20 Dec 2007, Georg Kottrup wrote:
+
+> >Noch besser waere JJJJ-MM-TT, sonst landen die Fotos dieses Jahrtausends
+> >vor denen des letzten.
+
+Alle, die ihre Software damals auf vierstellige Jahreszahlen
+umgestellt haben, werden sich am 31. Dezember 9999 noch
+die Augen reiben!
+-- I used to believe in reincarnation in a former life. 
+
+-----------------------------------------------------------------------------
+
+
+
+Toilettenpapier (Ronda, 30. Dez 2007, 22:47:00):
+Oder: Kann man Toilettenpapier, wenn man es ueber das Internet bestellt hat,
+auch nach 14 Tagen zurueckgeben?
+
+From: Sebastian Luettich <gegenpapst@ratzy.de>
+Subject: Re: AN: Single-Zwiebeln?
+Newsgroups: de.alt.fan.aldi
+Date: Fri, 28 Dec 2007 02:05:45 +0100
+Message-ID: <0T4m471cI7c4Nkq%selu@latour.mediman.org>
+
+
+Thorsten Boettcher <thorsten_nospam@gmx.net> schrob:
+> >Julia Liebetrau wrote:
+>> >>Ulrich F. Heidenreich wrote:
+>>> >>>Julia Liebetrau in <news:5t47jcF1afpohU1@mid.individual.net>:
+
+>> >>Ich habe es jedenfalls noch nie gesehen (und kaeme auch nicht auf die 
+>> >>Idee, Packungen auseinanderzupfluecken).
+
+> >Nur weil Du etwas noch nicht gesehen hast, heisst das nicht dass es da 
+> >snicht gibt. Bei AN, un um den gehts ja, schau mal in den Betreff, ist 
+> >es vollkommen normal, dass einzelne Flaschen verkauft werden. Sie werden 
+> >ja auch mit dem Prei pro Flasche ausgezeichnet. Genauso wie Obst 
+> >abgewogen wird.
+
+Und daraus schliesst Du, dass Du Dir vom 4-lagigen Toilettenpapier 3 Lagen
+abpulen kannst?
+
+S
+
+-----------------------------------------------------------------------------
+
+
+
+Oder wars nicht doch Reinhard May? (Ronda,  6. Jan 2008, 14:37:10):
+From: Wolfram Heinrich <theodor.rieh@freenet.de>
+Subject: Re: Karl May
+Newsgroups: de.rec.buecher
+Date:Thu, 3 Jan 2008 14:57:05 +0100
+Message-ID: <e59svp6b9c.dlg@www.theodor-rieh.de>
+
+>>>>> >>>>> Welches ist das beste Buch von Karl May??
+
+>>>> >>>> Das Kapital.
+
+>>> >>> Gibt es das Buch ueberhaubt???
+
+>> >> Sowieso. Sonst koennte es ja nicht sein bestes sein.
+
+> > Das gibst nicht!!!!!
+
+Du hast recht. Ich habe nachgeschaut, "Das Kapital" ist von Karl Marx. (Ich
+bin jetzt schon auf Seite 360 und wundere mich die ganze Zeit, warum noch
+kein einziger Indianer aufgetaucht ist...)
+
+-----------------------------------------------------------------------------
+
+
+
+Wer hat wohl DAS Nummernschild ausgesucht? (Ronda,  6. Jan 2008, 14:38:24):
+From: Joerg Digmayer <joergs.spamkuebel@gmx.de>
+Subject: Re: Seltsame Sprache
+Newsgroups: de.etc.sprache.deutsch
+Date:Tue, 01 Jan 2008 14:30:46 +0100
+Message-ID: <fldfa2$7o9$1@online.de>
+
+>> >> Ob der normale Biker-Satanist so beschlagen in hebraeischer
+>> >> Religionsgeschichte ist? "AN-AL 666" versteht nahezu jeder Depp.
+
+> >Um ueber "AN-AL" zu lachen, braucht der Depp die Zahl des Tiers nicht
+> >mehr.
+
+Wohingegen der Starnberger Porschefahrer, der sich im Nummernschild
+fuer "TT" in Verbindung mit einer einzigen "6" entschieden hat, mich
+sehr amuesiert hat.
+
+-----------------------------------------------------------------------------
+
+
+
+Das nennt man dann wohl "Dumm gelaufen" (Ronda, 11. Jan 2008, 21:06:08):
+From: Georg Kottrup <usenet.kottrup@gmx.de>
+Subject: Re: Obsd
+Newsgroups: de.etc.sprache.deutsch
+Date:Tue, 8 Jan 2008 18:11:20 +0100
+Message-ID: <ora0mf.6s6.ln@kottrup.de>
+
+Dieter Bruegmann <nutznetz@bruhaha.de> schrieb:
+
+> > Ihr wisst ja alle nicht, wie man den Fernseher benutzt! (Siehe
+> > Sig.) 
+
+> >| Bewusst ein- und wieder ausschalten statt bewusstlos zappen!
+
+Durch einen von mir verursachten Konstruktionsfehler in den Antennen- 
+und Satellitenkabeln und -verteilungen bei der Renovierung unserer  
+jetzigen Wohnung musste der Satellitenempfaenger in ein Zimmer der 
+ersten Etage. Der Fernseher steht im WoZi im Erdgeschoss. Zur 
+Senderwahl muss man also immer die Treppe rauf, umschalten und dann 
+wieder runter. Bei uns zappte als Folge dessen (bis zur Einfuehrung des 
+digitalen terrestrischen Fernsehens) viele Jahre lang keiner :-)
+
+-----------------------------------------------------------------------------
+
+
+
+Ob die Attentaeter das mit den Schwiegermuettern wissen? (Ronda, 11. Jan 2008, 21:07:18):
+From: Monika Gutbrodt <mgutbrodt@gmx.de>
+Newsgroups: de.soc.recht.misc
+Subject: Re: Selbstmord
+Date: Tue, 08 Jan 2008 16:50:11 +0100
+Message-ID: <5uhkdjF1hmjd3U2@mid.uni-berlin.de>
+
+Hallo,
+
+Am 07.01.2008 21:01 schrieb Chris:
+>> >> Der Begriff Selbstmord ist religioes motiviert und tradiert, 
+>> >> und die Strafe dafuer ist ewiges unermessliches Leiden in der Hoelle.
+> > Oder mit Jungfrauen und Milch und Honig ;-)
+
+...und den dazugehoerigen Schwiegermuettern?
+Wo also ist da der Unterschied?
+
+-----------------------------------------------------------------------------
+
+
+
+Glaub das gilt auch fuer manche MPA-Artikel, oder? (Ronda, 11. Jan 2008, 21:09:39):
+[SN: Nicht wirklich lustig, aber in 'geisteswissenschaftlichen' Gruppen
+oft zutreffend]
+
+From: Wolfram Heinrich <theodor.rieh@freenet.de>
+Subject: Re: Auf Sonntag folgt Samstag?
+Newsgroups: de.etc.sprache.deutsch
+Date: Tue, 8 Jan 2008 16:31:23 +0100
+Message-ID: <2vsbafsoddof$.dlg@www.theodor-rieh.de>
+
+Am Tue, 8 Jan 2008 03:27:47 -0800 (PST) schrieb Christine Kremsmayr:
+
+> >Uebrigens kann man sich so ziemlich bzgl. jeder Frage, die hier
+> >gestellt wird, vorher schlau machen. Dennoch sind Diskussionen hier
+> >oft sehr interessant.
+> >
+Und sie sind es deswegen, weil sich die meisten vor einer Frage eben
+nicht schlau machen. Das ist gerade das Schoene am Usenet: Dir schiesst
+ein Gedanke durchs Hirn und du schreibst ihn in ein Posting. Darauf
+erntest du tadelnde Worte, es entspinnt sich eine Diskussion und am Ende
+bist du viel, viel schlauer, als wenn du dich vorher informiert haettest
+und deswegen vielleicht das Posting unterlassen haettest.
+Der Austausch wohldurchdachter, ausgefeilter Diskussionsbeitraege waere
+nicht halb so anregend wie das Palaver ueber irgend einen Fehler, den
+sich einer geleistet hat.
+
+Ciao
+Wolfram
+
+-----------------------------------------------------------------------------
+
+
+
+Hat jemand ne Idee... (Ronda, 15. Jan 2008, 20:45:04):
+... wie man das "genussfaehig" kriegt?
+
+Ronda
+
+From: David Kastrup <dak@gnu.org>
+Subject: Pickled catfish -- der ultimative Scherzartikel
+Newsgroups: de.rec.mampf
+Date:Sat, 12 Jan 2008 20:08:50 +0100
+Message-ID: <85tzli3lq5.fsf@lola.goethe.zz>
+
+
+Bei meinen gelegentlichen Experimenten im Asiashop habe ich jetzt den
+ultimativen Kick gefunden: pickled catfish.  Zutaten: catfish (47%),
+rice flour, water, salt.  Kann ja so verkehrt nicht sein.
+
+An der Kasse, offensichtlich aus der Bahn geworfen, fragt mich der
+Kassierer, woher ich das denn kenne?  Ich sage, dass ich es mal probieren
+wollte.  Anstatt es mir anstaendigerweise aus den Haenden zu reissen und
+wieder im Regal zu verstauen, meint er, dass das in Vietnam haeufiger
+gefragt werde.
+
+Dieser Satz hat sich in mein Gedaechtnis gebrannt.
+
+Der erste Versuch war roh.  Schlechte Idee, da dreht sich einem der
+Magen um (eigentlich auch bei allen anderen Zubereitungen, aber dazu
+spaeter).  Eigentlich schon beim Oeffnen, aber man will ja Haerte zeigen.
+Wir haben es hier mit schleimigen und graetendurchsetzten Fischstuecken zu
+tun, die in einer vollkommen ungeniessbar versalzenen Reismehlpampe (der
+Fisch ist aber auch versalzen) Jahrhunderte gealtert sind und dabei das
+Mehl so grundsaetzlich ruiniert haben, dass einem schon davon schlecht wird.
+
+Eine Herausforderung.  Das Problem ist, dass die Verteilungsmoeglichkeiten
+des Fisches durch den festen Zusammenhalt und die Graeten Grenzen gesetzt
+sind, eine durchgehende Erhitzung ob der schleimig-klumpigen Konsistenz
+unumgaenglich ist und nicht klar ist, ob nun das durchgegammelte Reismehl
+oder aber der Fisch oder beides die Nutzlast darstellen soll.
+
+Nun, Auswaschen langt nicht, um den Salzgehalt der Fischstuecke unter ein
+genussfaehiges Mass zu senken.  Ein Braten danach fuehrt zu keinen
+genussfaehigen Ergebnissen und die Wohnung stinkt noch Tage (ausserdem ist
+es eine Zumutung, was die sofort zu entsorgenden Reste mit der Muelltonne
+anstellen).  Suppe ist als Verduennungsidee ganz nett, aber die lange
+Kochzeit fuehrt wieder zum Verstaenkern der Bude, die Klumpen werden nicht
+sinnvoll weich und die Graetenmasse bleibt ungeniessbar.
+
+Usw usf.  Das heutige Experiment bestand darin, ein paar Teeloeffel in
+ein paar Tassen Wasser zu zerstampfen, mit Dinkelvollkornmehl, Curry und
+einigen anderen Gewuerzen aufzufuellen und in der geschlossenen Pfanne als
+eine Art Fladen zu braten.
+
+Tatsaechlich fast das ertraeglichste bisher.  Wenn man den pickled catfish
+weggelassen haette, fast schon gut.  Aber das ist ja nicht Sinn der
+Uebung.  Aber dort, wo noch ein groesseres Stueck im Teig hing, war wieder
+Entsorgung angesagt -- das ging dann wirklich nicht (und ich bin jemand,
+der Habanero-Chilis pur isst).  Jetzt muss ich wieder den Muell rausbringen
+und meine Bude stinkt wieder in allen Zimmern unertraeglich.
+
+Und da ist bestimmt noch ein Drittel im Glas.  Die Muellabfuhr kommt erst
+in zwei Wochen.  Solange bleibt das Glas noch im Kuehlschrank: ich kann
+es der Nachbarschaft nicht zumuten, den Inhalt bereits jetzt in die
+Tonne zu kippen.  Und hoffentlich faellt mir nichts mehr ein, was man
+vielleicht noch damit machen koennte.
+
+Ich glaube, ich schenke meiner Mutter ein Glas.  Sie hat mir die
+Unsitte, kein Essen verkommen zu lassen, beigebracht.  Nur habe ich
+Angst, dass mich der Mensch im Asiashop in die Klapse bringen laesst, wenn
+ich noch ein Glas kaufe.
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Hat jemand ne Idee... (Ronda, 19. Jan 2008, 22:23:47):
+~#! rn=Ronda rt=1200426304 rg=schmarrn.netdigest
+~#! tid=1200426304
+Noch mehr fuer Standard-Deutsche ungeniessbares...
+
+From: Dirk Schneider <spam_scd603@gmx.de>
+Newsgroups: de.rec.mampf
+Subject: Re: Pickled catfish -- der ultimative Scherzartikel
+Date: Sat, 12 Jan 2008 21:38:14 +0100
+Message-ID: <fmb8fo$542$02$2@news.t-online.com>
+...
+
+Ralf Schmode schrieb am 12.01.2008 21:20:
+
+> > nicht nur dort. Ich meine, dass es in Island(?) sowas aehnliches gibt, mir
+> > geistert gerade die Bezeichnung "Surstroemling" im Kopf rum, aber ich bin
+> > nicht sicher, ob es das ist. Ich weiss nur, dass man die Dose(?) erst
+oeffnen
+> > darf, wenn sich aufgrund des Faulgas^WAromas der Boden/Deckel nach aussen
+> > woelbt...
+
+Surstroemming, Schweden. Es heisst, die Kuendigung eines Mieters, der in
+einem Mehrfamilienhaus so eine Dose geoeffnet hat, sei vor Gericht
+bestaetigt worden.
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Hat jemand ne Idee... (Grimmborn, 19. Jan 2008, 22:35:11):
+~#! rn=Ronda rt=1200777827 rg=schmarrn.netdigest
+~#! tid=1200426304
+Was die in Island haben ist Hakarl. Und das ist wesentlich, wesentlich
+schlimmer als Surstroemming (der gar nicht so schlimm ist).
+
+Grimmborn der Atheist
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Hat jemand ne Idee... (Rumata, 21. Jan 2008, 10:03:23):
+~#! rn=Grimmborn rt=1200778511 rg=schmarrn.netdigest
+~#! tid=1200426304
+Ist das sowas wie Durian?
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: Hat jemand ne Idee... (Grimmborn, 21. Jan 2008, 10:10:14):
+~#! rn=Rumata rt=1200906203 rg=schmarrn.netdigest
+~#! tid=1200426304
+Nein, das ist keine Frucht die lediglich schlecht riecht. Das ist Hai ohne
+Nieren. Daher kann der nicht Pipi machen, sondern lagert den Harnstoff im
+Gewebe ab. Nachdem man den gefangen hat graebt man den Hai in Sand ein und
+laesst ihn verrotten, bis der Harnstoff zu Ammoniak zerfaellt der dann auch
+das Fleisch... sagen wir: reifen laesst. Ich habs leider nie probieren
+koennen, aber es hoert sich schon vom Prozess her schlimmer an als Durian
+(Frucht halt) oder Surstroemming (Gaerung).
+
+GdA
+
+-----------------------------------------------------------------------------
+
+
+
+Re^5: Hat jemand ne Idee... (Rumata, 21. Jan 2008, 10:15:41):
+~#! rn=Grimmborn rt=1200906614 rg=schmarrn.netdigest
+~#! tid=1200426304
+Da faellt mir gleich eine Frage an die Biologen ein, die sich am WE ergab:
+(Muesste man eigentlich an die Sendung mit der Maus schicken :-)
+
+  Trinken Fische?
+
+-----------------------------------------------------------------------------
+
+
+
+Re^6: Hat jemand ne Idee... (Grimmborn, 21. Jan 2008, 10:42:13):
+~#! rn=Rumata rt=1200906941 rg=schmarrn.netdigest
+~#! tid=1200426304
+Natuerlich. Oder glaubst Du die decken ihren Fluessigkeitsbedarf durch
+Resorption ueber die Haut?
+
+GdA
+
+-----------------------------------------------------------------------------
+
+
+
+Re^7: Hat jemand ne Idee... (Anthea, 21. Jan 2008, 10:55:43):
+~#! rn=Grimmborn rt=1200908533 rg=schmarrn.netdigest
+~#! tid=1200426304
+Suesswasserfische tun das. Salzwasserfische nicht. Osmotischer Druck sorgt
+dafuer, dass Salzwasserfische verdursten wuerden, wenn sie nicht trinken
+wuerden.
+Sowas lernt man bei Clever ;)
+
+-----------------------------------------------------------------------------
+
+
+
+Re^8: Hat jemand ne Idee... (Rumata, 21. Jan 2008, 11:45:40):
+~#! rn=Anthea rt=1200909343 rg=schmarrn.netdigest
+~#! tid=1200426304
+Soweit ich weiss, haben Wirbeltiere im koerperinneren den selben
+Salzgehalt wie Meerwasser. Wieso gibt es dann osmotischen Druck?
+
+-----------------------------------------------------------------------------
+
+
+
+Re^9: Hat jemand ne Idee... (Orktoeter, 21. Jan 2008, 13:51:47):
+~#! rn=Rumata rt=1200912340 rg=schmarrn.netdigest
+~#! tid=1200426304
+Leg dich mal ein paar Stunden in die Badewanne und schau dir mal deine Haut
+an, dann siehst du die Folgen des osmotischen Drucks.
+
+OrkT.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^10: Hat jemand ne Idee... (Gloinson, 21. Jan 2008, 14:05:26):
+~#! rn=Orktoeter rt=1200919907 rg=schmarrn.netdigest
+~#! tid=1200426304
+Wenn das was Rumata annimmt korrekt waere, dann hilft die Erklaerung "so sieht
+osmotischer Druck aus" nicht. Ich glaube aber, dass Rumata falsch liegt. So
+versalzen habe ich Seefisch nicht in Erinnerung :)
+
+Aber Osmose ist ein netter Stichpunkt - Suesswasserfische sollten nicht durch
+den Mund trinken muessen. Die platzen eh gleich.
+
+
+-----------------------------------------------------------------------------
+
+
+
+Tauchverbot in Kneipen. SOFORT! (Ronda, 22. Jan 2008, 21:02:57):
+From: Peter Bruells <usernet@rogue.de>
+Newsgroups: de.soc.recht.misc
+Subject: Re: Rauchverbot in Kneipen
+Date: Fri, 18 Jan 2008 11:28:41 +0100
+Message-ID: <m2ve5r8m1y.fsf@rogue.de>
+
+
+"John Gawe" <wegasoft@gmx.de> writes:
+
+> > "Peter Bruells" <usernet@rogue.de> schrieb
+>> >> G-H-L <G-H-L@fen-net.de> writes:
+> >
+>>> >>> Es gab lange Zeit Filialen, die getrennte
+>>> >>> Raucher-/Nichtraucherbereiche hatten.
+>> >>
+>> >> Eben. Und das wurde erst letztes Jahr abgeschafft, als schon laengst
+>> >> klar war, dass das tauchverbot in der Gastronomie kommen word.
+> >
+> > Wann wurde das denn schon wieder beschlossen?
+> >
+> > Darf man denn jetzt garnichts mehr?
+
+Das Problem war, dass Taucher ueberall tauchen wollte und viele
+Nichttaucher es nciht mehr hinnehmen wollten, jede Nacht ihre Kleidung
+zu trocknen zu muessen und die vielen Ertrunkenen durch Passivtauchen
+waren auch nicht mehr hinnehmbar.
+
+-----------------------------------------------------------------------------
+
+
+
+Installationsanleitung fuer was Groesseres... (Ronda, 22. Jan 2008, 21:05:01):
+... ich ueberlege grade, wie eine IKEA-Anleitung zum Aufbau einer Armee fuer
+eine Bananenrepublik so aussehen mag. Und wie die dann hiesse - Rummsoe?
+Nixwidaschiessoe?
+
+Ronda
+
+From: Lothar Frings <da_lodda@gmx.de>
+Newsgroups: de.alt.talk.unmut
+Subject: Re: Installationsanleitungen
+Date: Thu, 17 Jan 2008 04:51:15 -0800 (PST)
+Message-ID:
+<1022f325-1583-4c8b-bc09-6375c9988147@c23g2000hsa.googlegroups.com>
+
+G.O.Tuhls tat kund:
+
+> > Ich habe hier gerade eine Installationsanleitung fuer einen Blauzahn-
+> > Stick vorzuliegen, der in Begeisterung versetzen kann:
+> >
+> > Zitat von Seite 3:
+> > | Plug the USB-Adapter into the USB port on your PC
+> >
+> > Zitat von Seite 4:
+> > | Do not plug the Adapter into your PC until the software has been
+> > installed.
+> >
+> > Das muss jemand geschrieben haben, der Anleitungen von hinten nach
+> > vorn liest.
+
+Ich habe hier auch sowas. Weiss nicht mehr woher, ist aber
+aus der Installationsanleitung fuer irgendwas Groesseres:
+
+Zitat von Seite 1:
+"Niemand darf wegen seines Geschlechtes, seiner Abstammung,
+seiner Rasse, seiner Sprache, seiner Heimat und Herkunft,
+seines Glaubens, seiner religioesen oder politischen Anschauungen
+benachteiligt oder bevorzugt werden. Niemand darf wegen
+seiner Behinderung benachteiligt werden."
+
+Zitat von Seite 2:
+"Maenner koennen vom vollendeten achtzehnten Lebensjahr
+an zum Dienst in den Streitkraeften, im Bundesgrenzschutz
+oder in einem Zivilschutzverband verpflichtet werden."
+
+-----------------------------------------------------------------------------
+
+
+
+Was haben Wucherpreise bei Schokolade mit Vegetariern zu tun? (Ronda, 23. Jan 2008, 22:08:25):
+From: "Stefan Nowak" <minhas.terra@freenet.de>
+Subject: Re: Wucherpreis bei Schokolade
+Newsgroups: de.alt.fan.aldi
+Date: Sun, 20 Jan 2008 12:00:51 +0100
+Message-ID: <fmv9l6$873$1@newsreader1.xoc.utanet.at>
+
+
+Thomas Grueske <les_ich_nicht@freenet.de> wrote:
+
+>> >>Ich lege noch einen drauf: Vegetarier essen kein Fleisch weil sie
+>> >>Tiere hassen.
+> >
+> >Na logisch. Stammt doch der Begriff aus dem indianischen und bedeutet
+> >"derjenige, der nach der Jagd mit leeren Haenden nach Hause kommt"*.
+
+Wenn Gott nicht gwollt haette, dass man Tiere isst, haette er sie nicht
+aus Fleisch gemacht.*
+
+Stefan
+
+*Geklaut bei einem Kabarattisten, dessen Name mir entfallen ist.
+
+-----------------------------------------------------------------------------
+
+
+
+Manche Linuxer haben besondere Vorlieben (Ronda, 27. Jan 2008, 20:10:58):
+From: "Peter Riedel"<riedel@arcor.de>
+Newsgroups: de.comp.os.unix.linux.misc
+Subject: Re: Aufblasbarer Gummi-Tux gesucht
+Date: Mon, 21 Jan 2008 12:13:50 +0100
+Message-ID: <47947e7e$0$9106$9b4e6d93@newsspool2.arcor-online.net>
+
+> > ich suche einen moeglichst grossen, aufblasbaren Gummi-Tux. Meine Suche in
+> > diversen Linux-Zeugs-Shops hat nur einen 23 cm grossen Bade-Tux
+> > hervorgebracht, den man zum planschen mit ins Schwimmbad nehmen kann.
+> >
+> > Minimal waere aber ungefaehr ein Meter, ich nehme den auch gern in 2 oder
+> > gar 3 Meter Hoehe.
+
+Ekelhaft, was manche Leute fuer sexuelle Vorlieben haben...
+
+-----------------------------------------------------------------------------
+
+
+
+So geht das mit dem Design (Ronda, 27. Jan 2008, 20:11:24):
+Message-ID: <t387p3pv26belch9sbph75j5f7e8e7bt2q@4ax.com>
+From: Ulrich G. Kliegis <Ulli.usenet@kliegis.de>
+Newsgroups: de.rec.sport.segeln
+Subject: Re: Evtl. OT: Wer kennt die Luxusyacht im Dock 7 (HDW, Kiel)?
+Date: Sun, 20 Jan 2008 20:50:08 +0100
+
+On Sun, 20 Jan 2008 18:05:51 +0100, Thak.hinnerk@web.de (Thak Hinnerk,
+Niebuell (Nordfriesland, Erde)) wrote in de.rec.sport.segeln:
+
+
+> >Ich war letzte Woche bei HDW Kiel im Dock 7. Da wird so eine weisse
+> >Luxusmotoryacht gebaut mit einem fuer meine Begriffe ungewoehnlichem
+> >Rumpf:
+
+Also, ein bisschen verbaut sieht das ja schon aus. Werfen wir einen
+Blick ins Designbuero...
+
+Unser Edeldesigner hat schon einige Kopfhaare weggekratzt. Die schoene
+teure neue Software (let your wildest dreams cum trew... ) macht
+alles, nur keine Waild Driehms, eher Albtraeume. 
+
+Edeldesignerehefrau war vorhin da, hat den Sproessling abgeliefert, weil
+sie noch auf ne Wer-nies-ahsch muss, und seit Edeldesignerjunior bei
+solcher Gelegenheit mit einem aus seiner unergruendlichen Hosentasche
+gezauberten Edding (die Gene sind halt staerker) ein Kunstwerk
+zerschoent hat, ist er unausgesprochen persona non grata bei solchen
+Ab-, aehm, Anlaessen. 
+
+Nun gut, er hat seine Malecke im Buero, linst neugierig zu Papas PC
+rueber, Papa, ich moecht auch mal wieder! Jajajaja, aber erst muss ich
+diesen Kahn, weisst Du, der nette Onkel neulich, der will darauf schon
+bald rumfahren... - Papa, wie kann man denn auf Deinem Schreibtisch in
+so einem Boot rumfahren? - (Papa hoert nichts mehr, gruebelt vor sich
+hin) - (Sproessling, gemurmelt:) Bloeder Onkel, soll der doch sehen...
+
+Zuruf aus dem Vorzimmer: Dein Kunde ist am Telefon! Ich glaub, heute
+musst Du selbst mit ihm reden! - (Ploetzlich zeigt das vegetative
+Nervensystem, was es kann, alle Schweissporen gemeinsam: AUF!
+Blutdruck: RUNTER! Magen: auf GELAeNDEGANG SCHALTEN!)
+
+Edeldesigner am Telefon: Ja haallllloooooo!, (Blablablabla, geht, das
+schnurlose Geraet am Ohr durchs Buero, Richtung Ecke, die er beim
+minutenlangen Vieraugenmonolog seines Kunden genau fixiert, Zustand
+eben...) - 
+
+Derweil bewegt sich der Nachwuchsdesigner, der zu Hause schon immer
+mit PhotoShop der Oma lustige GlubschAugen gezaubert hat und der Mama
+einen grossen B- auch, und gaanz dicke Fuesse, rutscht auf Papas Sessel,
+klickt und mausschiebt ein bisschen rum, wirklich sehr intuitiv, diese
+Software, bis er zufrieden ist. Bloeder Onkel, das hat er nun davon! 
+
+Gerade jetzt kommt sein Vater wieder, janeinjaneinjajajajaja (dem
+Kunden niemals nein sagen!), sieht das Machwerk auf dem Bildschirm,
+stutzt, guckt sich um, sein Sohn sitzt still in der Ecke und malt ein
+schoenes Boot, da sagt er mit ploetzlich sehr fester Stimme: Also, ich
+hab da einen Entwurf, der ist ein bisschen ungewoehnlich, aber ich kann
+Ihnen den ja eben mal ruebermailen. 
+
+Der Rest ist bekannt. Und Sohnemann bekam einen eigenen Computer. Den
+nannte er "Bloeder Onkel"!
+
+Gruss,
+U.
+
+-----------------------------------------------------------------------------
+
+
+
+Manha, Manha! (Ronda, 29. Jan 2008, 23:52:56):
+[SN: Mal von ganz woanders. Ich fands lustig. Der Text entspringt dem  
+Loeschntrag zu dem Artikel Siegfried I
+  QS: Qualitaetssicherung, LA: Loeschantrag]
+
+URL: http://de.wikipedia.org/wiki/Wikipedia:L%C3%B6schkandidaten/26._Januar_20
+08#Siegfried_I._.28Anhalt.29
+
+Siegfried I. (Anhalt) ? [Bearbeiten]
+
+Ich habe jetzt lange ueberlegt, was ich mit dem Artikel mache (war in  
+der QS), ich stelle jetzt doch LA. Folgendes gibt es zu sagen: Am 5.  
+Januar von einem anonymen Benutzer ohne Quellen erstellt. Den Mann gab  
+es ohne Zweifel, der Artikelinhalt ist aber in grossen Teilen einfach  
+falsch. Laut dem Artikel war er mit Katharina von Schweden  
+verheiratet. Die war aber erstens Nonne und zweitens bei Siegfrieds  
+Tod noch nicht mal geboren, was eine Heirat der beiden doch deutlich  
+erschwert. Weiter soll diese ominoese Katharina von Schweden die  
+Tochter von Erik XI. (Schweden) gewesen sein: Der war aber laut  
+unserem Artikel kinderlos. In der Ursprungsversion war Siegfried auch  
+der Sohn des Heinrich I. "dem Fetten", den es aber gar nicht gibt, es  
+gibt nur einen Heinrich II. (Anhalt), genannt der Fette, der war aber  
+der Bruder und nicht der Vater von unserem Siegfried hier.
+Entweder grundlegend mit Quellen ueberarbeiten oder vorsichtshalber mit  
+der Begruendung "aeusserst zweifelhafter Inhalt (Fake?)" loeschen. -- 
+Troete Manha, manha? 13:47, 26. Jan. 2008 (CET)
+
+-----------------------------------------------------------------------------
+
+
+
+Mnjam! (Ronda, 30. Jan 2008, 22:24:00):
+From: Astrid Schleicher <astrid.schleicher@gmx.de>
+Newsgroups: de.talk.liebesakt
+Subject: Re: Wer kennt geile Animal web Seiten?
+Date: Fri, 25 Jan 2008 13:24:29 +0100
+Message-ID: <5vu2noF1o880aU1@mid.individual.net>
+
+D. Meissner schrieb:
+> >Anja schrieb:
+
+>> >> Wer kennt geile Animal Web Adressen?
+
+> >Ich lade mir die geilen Tierbilder immer von
+> >alt.binaries.pictures.animals runter.
+
+Neulich hat mein Mann unsere Tochter gefragt, was sie gern im
+Fernsehen anschauen moechte. "Einen Tierfilm!" Er zappt so durch,
+bleibt bei einer Kochsendung haengen: "Hier, bitte, Ente im Ofen."
+
+Liebe Gruesse
+           Astrid
+
+-----------------------------------------------------------------------------
+
+
+
+Ja, ja... (Ronda, 30. Jan 2008, 22:27:08):
+... nen Typ, der sich "Drew" nennt, nen anderer dessen Mailadresse
+jehova@weibsvolk.org ist, diskutieren in der Aldi-Newsgroup ueber Frauen. Kein
+Wunder dass da so was dabei rauskommt...
+
+Ronda
+
+From: rocknrollpunk@yahoo.de (Andreas 'Drew' Goeltl)
+Newsgroups: de.alt.fan.aldi
+Subject: Re: OT Was Frauen meinen
+Date: Sat, 26 Jan 2008 17:16:26 +0100
+Message-ID: <1ibc29c.18phaj6bqzmlsN%rocknrollpunk@yahoo.de>
+
+Walter Jann <jehova@weibsvolk.org> wrote:
+
+> > Ooch...das war ja nur ein Auszug. Ich haette da noch ein paar mehr zu
+> > bieten.
+> > 
+> > Was Frauen meinen, wenn sie sagen:
+> > "Ja"
+> > -> Nein 
+> > %
+> > Was Frauen meinen, wenn sie sagen:
+> > "Nein"
+> > -> Ja
+
+"Euer Ja bedeutet ja, euer Nein nein; was darueber hinausgeht, stammt von
+dem, der boese ist." (Jesus Christus, [Matthaeus 5:37]) ;-)
+
+Drew
+
+-----------------------------------------------------------------------------
+
+
+
+Hat das hier schon mal wer ausgetestet? ;-) (Ronda, 30. Jan 2008, 22:28:00):
+From: Holger TUZ <tuz@arcor.de>
+Newsgroups: de.soc.familie.kinder
+Subject: Re: Alternative zu Halskette mit Namensschild
+Date: Sat, 26 Jan 2008 20:41:15 +0100
+Message-ID: <479b8cf6$0$9106$9b4e6d93@newsspool2.arcor-online.net>
+
+Hi,
+Beichte: ich habe bei unserem Juengsten schlicht unseren Stempel
+(inkl. Handynr.) missbraucht.
+Hautfreundliche und dokumentenechte Stempelfarbe gibt es im Buerobedarf.
+Dauert nur Sekunden und haelt den ganzen Tag. Das Ritual und der
+Beruehrungseffekt sorgt fuer Merkfaehigkeitbei den Kids.
+(bitte nicht auf die Stirn)
+Bei neurodermitis-kids nehmt den Nacken.
+Bilanz: 2x verloren, 2x sehr schnell (Anruf) wieder gefunden, 2x ohne 
+Traenen und viel Gelaechter bei den Findern ob der kuriosen
+Idee. Danach nie wieder notwendig, trotzdem musste weiterhin
+abgestempelt werden.
+Kein Witz.
+Das Stempelkissen als temporaeres Ruhekissen fuer nervoese Eltern.
+
+;-)  Holger
+
+-----------------------------------------------------------------------------
+
+
+
+Quatsch! (Ronda, 30. Jan 2008, 22:28:57):
+Die wollen nach schmarrn.netdigest!
+
+From: "Michael Landenberger" <spameimer052006@arcor.de>
+Newsgroups: de.soc.recht.strassenverkehr
+Subject: Re: Fahrstreifen?
+Date: Mon, 28 Jan 2008 11:44:43 +0100
+Message-ID: <605q12F1opsu1U1@mid.uni-berlin.de>
+
+"Henning Weede" <hweede@snafu.de> schrieb:
+
+> > Wenn Dir zweierlei Streifen zur Auswahl standen, um sie zu
+> > ueberqueren, naemlich
+> > - der Fahrstreifen
+> > - der Zivilstreifen
+> > und Du hast Dich fuer ersteren entschieden, dann erwartet Dich
+> > mit Sicherheit viel weniger, als wenn Du Dich fuer zweiteren
+> > entschieden haettest.
+
+*Pruust*.
+
+Aber eigentlich finde ich es ekelhaft, wie die Leute immer krampfhaft 
+versuchen, Beitraege in de.alt.netdigest unterzubringen ;-)
+
+Gruss
+
+Michael 
+
+-----------------------------------------------------------------------------
+
+
+
+Steckenpferde im Prater (Ronda,  3. Feb 2008, 16:52:36):
+From:Fredy Barth <fbarth@spamfence.de>
+Subject: Re: Befoerderungsbedingungen :-))
+Newsgroups: de.etc.bahn.tarif+service
+Date: Mon, 28 Jan 2008 12:50:51 +0100
+Message-ID: <7514336.PJjPH19r9L@fmx-online.de>
+
+Ingo Stiller schrieb:
+
+> > Sind nun Elefanten zugelassen oder nicht ? ;-)))
+> > Wenn ich einen geeigneten Behaelter mitbringen musste es doch gehen. Es
+> > wird ja nicht verlangt, dass ich diesen Behaelter tragen kann. Ein
+> > Gabelstapler an der Haltestelle sollte doch erlaubt sein, oder? :-)))
+
+Da hab ich doch erst neulich was Passendes dazu gelesen.
+Aus news:at.verkehr.bahn:
+
+| E-mail an die Wiener Linien: 
+|  
+| Ich moechte mit meinem Pferd einen Ausflug in den Prater machen und muesste
+| dazu die U1 benutzen. Bitte teilen Sie mir mit, welchen Fahrschein ich fuer 
+| das Pferd loesen muss und ob es waehrend der Fahrt einen Maulkorb benoetigt.
+| Mit freundlichen Gruessen 
+| Iris Joseph-Pallauf 
+| ------------------------------------------------------------- 
+|  
+| Sehr geehrte Frau Joseph-Pallauf, 
+| zuerst moechten wir Sie mit der in unseren Befoerderungsbedingungen 
+| enthaltenen Regelung fuer die Befoerderung von Tieren vertraut machen, die
+| da lautet: 
+| "Der Fahrgast ist berechtigt, kleine lebende Tiere, sofern es nicht 
+| gefaehrliche Tiere sind, unentgeltlich in die Anlagen und
+| Befoerderungsmittel mitzunehmen, wenn diese Tiere in Behaeltnissen
+| untergebracht sind. Diese Behaeltnisse muessen so beschaffen sein, dass
+| Verletzungen und Verunreinigungen von Personen sowie Beschaedigungen und
+| Verunreinigungen von Anlagen und Befoerderungsmitteln ausgeschlossen sind". 
+|  
+| Leider gehen aus Ihrer e-mail keine detaillierten Informationen zu Ihrem 
+| Pferd hervor, wir erlauben uns daher, einige Moeglichkeiten aufzulisten. 
+| Wenn es sich um ein grosses Pferd (z.B. Lippizaner, Haflinger, Mustang, 
+| Flusspferd usw.) handelt ist eine Befoerderung nicht zulaessig. 
+|  
+| Handelt es sich um ein neugeborenes Shetland-Pony oder Islaender und passt 
+| jenes in ein Behaeltnis, z.B. Reisetasche, ist eine Befoerderung
+| grundsaetzlich moeglich. 
+| Ein Maulkorb muss nicht angelegt werden, beachten Sie jedoch die 
+| Bestimmungen des neuen Tiertransport-Gesetzes. Seepferdchen koennen -
+| ebenfalls ohne Maulkorbpflicht - mitgenommen werden, das Aquarium muss 
+| jedoch aus bruchsicherem Glas (Panzerglas) bestehen. 
+|  
+| Die Mitnahme von Schaukelpferden ist erlaubt, wenn sie leicht tragbar sind 
+| und so abgestellt werden, dass keine Gefaehrdung zu erwarten ist. Fuer
+| Steckenpferde im physischen Sinn gilt ebenfalls o.a. Regelung, sonstige 
+| Steckenpferde koennen Sie in unbegrenzter Anzahl im Geiste mitfuehren.
+|  
+| In allen Faellen erfolgt die Befoerderung kostenlos! Wir hoffen, Ihnen
+| hiermit gedient zu haben, wuenschen Ihnen noch eine angenehme Reise und
+| verbleiben mit freundlichen Gruessen 
+|  
+| Ihre 
+| Wiener Linien 
+
+
+Pfueagott, Fredy ;-)
+
+-----------------------------------------------------------------------------
+
+
+
+Helloween. Rechtsstaatlich betrachtet. (Ronda,  3. Feb 2008, 16:55:13):
+From: Hans-Georg Bickel <hgbusenetmuell@gmx.de>
+Newsgroups: de.alt.soc.knigge
+Subject: Re: Anti-Helloween
+Date: Wed, 30 Jan 2008 18:55:51 +0100
+Message-ID: <fnqh7n.3j0.1@ID-108823.user.uni-berlin.de>
+
+Thomas Hochstein <thh@inter.net> wrote:
+
+> >Tatbestandlich stellt die Forderung nach "Suessem" unter Drohung mit
+> >"Saurem" fuer den Fall der Nichtleistung eine Erpressung ( 253 Abs. 1
+> >StGB) dar.
+
+Warum den Ball flachhalten? Wenn schon, denn schon:
+
+Es koennte auch ein besonders schwerer Fall nach Abs. 4 vorliegen.
+Schliesslich treten die lieben Kleinen als Mitglieder einer Bande
+auf, die sich zum fortgesetzten Erpressen von Suesskram verbunden
+hat.
+
+Und da das alles einer vorherigen Verabredung bedarf stellt sich
+die Frage, ob man die Rangen nebst Eltern nicht schon vorher
+wegen Bildung bzw. Unterstuetzung einer kriminellen Vereinigung
+nach  129 Abs. 1 StGB drankriegen kann.
+
+Mit dem Problem, ob jeder, der mit Halloween-Artikeln handelt,
+nach derselben Vorschrift als Unterstuetzer verfolgt werden kann,
+soll sich dann der Referendar befassen.
+
+> >Da "Halloween" alles moegliche, aber keine im deutschen oder
+> >kontinentaleuropaeischen Kulturraum verwurzelte Tradition darstellt,
+> >koennen sich die Taeter auch nicht auf eine Sozialadaequanz ihrer
+> >Handlungen berufen (wie das beim Abschneiden der Krawatten an
+> >"Weiberfastnacht" (mundartliche Bezeichnungen wechselnd) oder beim
+> >Entwenden eines Maibaumes in Betracht kommt).
+
+Das ist bestimmt Musik in den Ohren der Verteidigung. Eine
+bessere Vorlage fuer ein ergreifendes Plaedoyer gibt es nicht.;-)
+
+HG
+
+-----------------------------------------------------------------------------
+
+
+
+Passt hier grad rein. (Ronda,  4. Feb 2008, 21:08:39):
+SN: Gekuerzt
+
+Message-ID: <47a45809@news.ish.de>
+From: Klaus von der Heyde <uzs95e@uni-bonn.de>
+Newsgroups: de.rec.spiele.rpg.misc
+Subject: Re: Rollenspiele haben mich zum Ork gemacht!
+Date: Sat, 02 Feb 2008 12:46:14 +0100
+
+Thilo Falder wrote:
+
+> > Ich bin seit 2 Jahren ein Ork,
+> > weil ich soviele Pen&Paper Rollenspiele gespielt habe.
+> > Ich toete regelmaessig Menschen und esse Menschenfleisch und wohne
+> > in einer Hoehle im Wald, wo ich mir Gegenstaende aus Menschenhaut und
+> > Menschenknochen baue.
+
+Bist du sicher, dass du kein Troll bist? Ich meine, *alle* Symptome
+weisen darauf hin[4].
+
+> > Rollenspiele haben mich verrueckt gemacht, ich werde fuer immer ein
+> > Ork bleiben und vielleicht auch dich essen.
+> > Spiele diese Spiele lieber nicht, wenn du nicht eines Tages eine
+> > Fantasiefigur sein willst. Wenn du Pech hast, bist du dann
+> > ein Kobold mit nur 1 Schadenspunkt und dann kann dich selbst
+> > eine Miezekatze totbeissen!
+
+Da hast du es ja noch richtig gut getroffen.
+
+[4] <http://www.glyphweb.com/ARDA/t/trolls.html>
+
+K. :)
+
+-----------------------------------------------------------------------------
+
+
+
+Mein damals ist frueher als Dein damals! (Ronda,  9. Feb 2008, 23:50:57):
+[ This is a repost of the following article:                               ]
+[ From: "Jakob Krieger" <jk@dashdotcom.de>                                 ]
+[ Subject: Re: Telefonanschluss mit Impulswaehlverfahren                    ]
+[ Newsgroups: de.alt.technik.misc                                          ]
+[ Message-ID: <op.t59ueycxhz6ioy@linux-vpjq.site>                          ]
+
+- Bernd Stolle
+
+
+>>> >>> Splitter = DSL oder?
+>> >>
+>> >> Also, wenn ich mich recht erinnere, verstand man damals bei der
+Deutschen
+>> >> Bundespost / Fernmeldeamt unter dem Begriff  "Splitter" etwas anderes
+als
+>> >> heute.
+>> >> ein Splitter damals war, meine ich, diese Umschaltdose an der man zwei
+>> >> Fernsprechapparate an eine Amtsleitung anschliessen  konnte.
+> >
+> > Nie gehoert. Was Du beschreibst kenne ich unter dem Begriff AWADo.
+"Damals"
+> > konnte man bei der Post naemlich noch Deutsch und es gab denglische
+Begriffe
+> > wie Splitter erst gar nicht.
+
+Splitter nannte man das, was aus zu Boden gefallenen
+Bakelitgehaeusen herausbrach.
+
+-----------------------------------------------------------------------------
+
+
+
+Irgendwie erinner ich mich da an Vier Hochzeiten und ein Todesfall und die Schafe... (Ronda,  9. Feb 2008, 23:55:36):
+[SN: Ein schoener Fipptehler]
+
+From: Uwe Schickedanz <Uwe_usenet.spam@war-im-urlaub.de>
+Subject: Re: Caucus und Caucusse
+Newsgroups: de.etc.sprache.deutsch
+Date: Fri, 08 Feb 2008 23:29:18 +0100
+Message-ID: <nslpq3h79vfids0k7su3bu91qsj8ieql8k@4ax.com>
+
+On Fri, 8 Feb 2008 13:54:02 -0600, Ren <Kar98@The-Coalition.US>
+wrote:
+
+> >Schweine werden im allgemeinen explizit fuer den menschlichen Verkehr 
+> >gezuechtet und sind auch keineswegs vom Aussterben bedroht.
+
+Das koennt ihr in Texas so machen, wie ihr wollt: bei uns werden die
+Schweine gegessen.
+
+Gruss Uwe
+
+-----------------------------------------------------------------------------
+
+
+
+Bisschen flach, aber warum nicht. (Ronda, 11. Feb 2008, 00:10:42):
+From: Daniel Fett <news_@fragcom.de>
+Newsgroups: de.sci.electronics
+Subject: Re: Gefaedelte Platine schuetzen
+Message-ID: <47aee5f7$0$2304$9b4e6d93@newsspool4.arcor-online.net>
+
+Joerg schrieb:
+> > Henry Kiefer wrote:
+>> >> Joerg schrieb:
+>>> >>> Johannes Bauer wrote:
+>>>> >>>> MaWin schrieb:
+>>>>> >>>>> "Johannes Bauer" <dfnsonfsduifb@gmx.de> schrieb im Newsbeitrag 
+>>>>> >>>>> news:jhj185x1m7.ln2@joeserver.homelan.net...
+>>>>>> >>>>>> Das ist ein super Tipp! Danke!
+>>>>>> >>>>>>
+>>>>> >>>>> Du hattest doch gar nicht gefragt...
+>>>> >>>>
+>>>> >>>> Stimmt, aber ich hab dasselbe Problem. Habe bisher auch den Kontakt
+>>>> >>>> Loetlack hergenommen, der klebt aber wie die Sau. Wachs ist
+eigentlich
+>>>> >>>> optimal.
+>>>> >>>>
+>>> >>>
+>>> >>> Nur nicht, wenn's zu warm wird. Dann klebt aber auch alles in der 
+>>> >>> Kiste. Auf Wachs angesammelter Staub und Siff ist auch nicht gerade 
+>>> >>> angenehm anzusehen und man muss aufpassen, dass sich keine 
+>>> >>> "Einwohner" einnisten.
+>>> >>>
+>> >>
+>> >> Welches Tier frisst Wachs?
+>> >>
+> > 
+> > Also hier zum Beispiel Ameisen. Ob die das fressen weiss ich nicht, sie 
+> > tragen es weg. "Au fein, Baumaterial, und wir brauchen keine Kreditkarte!"
+
+Selbstverstaendlich tragen die das als Baumaterial und nicht als Futter 
+weg, sonst waers teurer.
+
+"20% auf alles - ausser Tiernahrung"
+
+SCNR,
+Daniel
+
+-----------------------------------------------------------------------------
+
+
+
+Sockenfressende Maschmaschinen... (Ronda, 13. Feb 2008, 21:29:03):
+... gibt es tatsaechlich. Hab Praktikum bei Miele gemacht, die haben damals
+(tm) daran rumgeforscht, wie sie verhindern koennen, dass einzelne Socken zu
+fluechten versuchen.
+
+Ronda
+
+[Anmerkung des Einreichers: Zusammengebaut aus 2 Postings einen
+Threads]
+
+Newsgruppe: de.etc.haushalt
+Date: Tue, 12 Feb 2008 13:35:39 +0100
+From: "Jochen Kriegerowski" <joinvalid@smtp.ru>
+Subject: Re: sockenfressende Waschmaschine
+Message-ID: <fos3qs$422$00$1@news.t-online.com>
+
+"Patrick Kibies" <linuxuser1@web.de> schrieb
+
+> > HaJo Hachtkemper wrote:
+
+>> >> Ist Dir schon mal aufgefallen, dass die Summe der eingefuellten und
+>> >> entnommenen Socken einer Waschladung immer ungerade ist? Socken
+>> >> bekommen in der Waschmaschine schwarze Loecher, und durch die
+>> >> verschwinden sie in ein Paralleluniversum.
+
+> > Besonders spannend wird es, wenn von dort Socken zurueckkehren. Und das
+> > obwohl keine Socken in der Maschine waren. Wurden diese Socken dann im
+> > Paralleluniversum gewaschen und haben ein aehnliches Schicksal erlitten?
+
+Ja. Die Parallelwaschmaschinen sind durch Wurmloecher verbunden.
+(ist dir schon mal die wurmfoermigen Teile aufgefallen, die von der
+Rueckseite deiner Waschmaschine zur Wand fuehren? Die haben innen
+einen Hohlraum. Ein Loch!)
+
+> > btw.: Bekommen auch weisse Socken schwarze Loecher? 
+> > Ach ja: Wie sieht es mit Golfsocken (18 Loecher) aus: verfaerben sich da
+dann
+> > die Loecher nach schwarz oder kommen da neue - schwarze - Loecher hinzu?
+
+Die sind ein Spezialfall. Die werden in einem grossen Loch gesam-
+melt ("in-one-hole") und dienen dann im Fruehjahr den Birdies als
+Nistmaterial.
+
+> > Fragen ueber Fragen.
+
+> > Gruss 
+> > Patrick, der nahezu ueberlegt sich mal mit einem Socken
+> > mitwaschen zu lassen um Beobachtungen anzustellen.
+
+Gibt es ein Parallelusenet, damit du uns schreiben kannst wenn
+du am anderen Ende rauskommst?
+
+> > Nebenfrage: Wie kaemme ich nach einer 60C-Waesche meine Haare wieder
+> > durch?  Empfiehlt sich Weichspueler?
+
+Es empfiehlt sich eine Rasur, als Vorsichtsmassnahme.
+
+Gruss
+Jochen 
+
+-----------------------------------------------------------------------------
+
+
+
+Spieglein, Spieglein... (Ronda, 17. Feb 2008, 23:51:30):
+From: Wolfgang Draxinger <wdraxinger@darkstargames.de>
+Newsgroups: ger.ct
+Subject: Re: Spieglein, Spieglein .....
+Date: Sun, 17 Feb 2008 14:49:14 +0100
+Message-ID: <rjql85-aq5.ln1@darkstargames.dnsalias.net>
+
+Andreas Huettner wrote:
+
+> > Es bleibt dann noch immer eine ziemlich grosse Auswahl. Aber
+> > diese wird drastisch gekuerzt, wenn man nun auch noch ein NICHT
+> > SPIEGELNDES hochaufloesendes Display wuenscht. Anscheinend will
+> > heute alle Welt sich selbst bei der Arbeit am Notebook zusehen
+> > koennen, wie sonst ist, ausser den vielleicht helleren und
+> > brillianteren Farben, diese Spiegelseuche zu erklaeren.
+
+Liegt wohl am WAF. Erst vor 3 Tagen habe ich in der U-Bahn
+beoebachtet, wie ein Maedel ihr Klapphandy oeffnete, dann wartete
+bis das LCD-Backlight wieder verlosch und hat das Ding dann als
+Schminkspiegel verwendet. Das war _mein_ Aha-Erlebnis was das
+angeht. Vermutlich lief das so:
+
+Die Marketing-Abteilung macht einen Zielgruppentest zur Akzeptanz
+des neuen Designs. Also laedt man sich ein paar Jungs und Maedels
+ein und setzt sie an die Kiste zum "arbeiten". Maedels sind da
+irgendwie zielorientierter: "Ich will jetzt was schreiben."
+oder "Chatten waere jetzt ganz nett." Die maennlichen Vertreter
+dagegen sind Technikspielkinder "Oh, ja da schau mal her, da
+kann ich hier an den Einstellungen rumspielen, das koennte man
+noch verbessern usw." Alles in allem halt das typische Bild das
+sich ein Bastler von so einer Kiste macht. Meistens landet sowas
+im Mittelfeld, da kann man immer was dran verbessern.
+
+Nun hat das Maedel aber seine Arbeiten erledigt. Die Schminke
+gehoert nochmal korrigiert. "Mist noch 20 Minuten soll ich hier
+noch rumsitzen." Die Maus und Tastatur wird nicht angeruehrt -
+Langeweile, der Bildschirmschoner "schwarzer Bildschirm" springt
+an. Bei 50% der Geraete ist ein Glare-Display verbaut und bei 50%
+der Maedels macht das Herz einen Luftsprung "Das Teil hat ja
+sogar einen Schminkspiegel drin!!! Super!!!." Also wird die
+Wertung des Geraets in der Kategorie "Nutzwert" korrigiert und
+auf Maximum gestellt.
+
+Bei der Auswertung stellt der Hersteller fest, dass die 50% der
+Testpersonen, die ein Glare-Display im Geraet hatten, den Nutzen
+durchweg positiv bewerteten, waehrend der Rest dem Geraet eine
+neutrale Wertung in dieser Kategorie gab.
+
+Und jetzt bitte nicht hauen: Manchmal tragen die Frauen eben doch
+die Schuld an einem Uebel in der Welt!
+
+Wolfgang -SCNR- Draxinger
+
+-----------------------------------------------------------------------------
+
+
+
+Ich such da grad nen Auto... (Ronda, 18. Feb 2008, 00:12:19):
+... auch die Sig ist nett. Oder eben nicht nett. Aber triffts. So der flache
+Kalauer erlaubt ist.
+
+Ronda
+
+From: Andreas Cammin <andreas.cammin@krasse-herde.org>
+Subject: Re: Asiatische Autos besser als europaeische?
+Newsgroups: de.etc.fahrzeug.auto
+Date: Thu, 14 Feb 2008 18:34:58 +0100
+Message-ID: <47b47bd1$0$2708$9b622d9e@news.freenet.de>
+
+Roman Schuetz schrieb:
+
+> >Auslaendische Fabrikate spielen z.B. bei Firmenfahrzeugen so gut wie
+> >keine Rolle, Firmen und Behoerden kaufen i.d.R. deutsche Fabrikate.
+
+Man sagt nicht mehr "Auslaendische Fahrzeuge". Politisch korrekt heisst 
+das jetzt "Autos mit Migrationshintergrund" :-)
+
+An*scnr*dreas
+-- "Komm her, wenn Du was willst!" ist ein Instrument der Deeskalation, das
+koerperliche Gewalt vermeidet. Ausnahmen bestaetigen die Regel. (Max Sievers
+in de.rec.fahrrad) 
+
+-----------------------------------------------------------------------------
+
+
+
+Privatversichert ist kuscheliger! (Ronda, 18. Feb 2008, 00:16:38):
+Subject: Re: Notfall
+From: Timm Thiemann <timms-news@gmx.net>
+Reply-To: timm.NO-SPAM@gmx.net
+Date: Sun, 10 Feb 2008 21:11:54 +0100
+Message-ID: <aqlnof.8v5.ln@pommes.timmthiemann.de>
+Newsgroups: de.alt.talk.unmut
+
+
+
+A.Lange wrote:
+> > 
+> > "Dann bekommt sie auch keinen Termin bei uns. Wir sind vollkommen 
+> > ueberlastet und koennen keine neuen Patienten annehmen."
+> > "Sie ist privat versichert."
+> > "Ach so, waere ihnen uebermorgen recht?"
+> > "Ja", Chipkarte gezueckt, Wachhund guckt rauf.
+> > "Sie sind ja gesetzlich versichert!"
+
+"Sind Sie privat versichert oder bist du Kassenpatient?"
+
+Jaja. Und dann war da noch Madame, die den Rettungsdienst mit "MEIN MANN
+IST PRIVAT VERSICHERT!" empfing. Das "Ralf, bring die _weiche_ Trage!"
+hat nur zu einem ganz milden Anschiss gefuehrt.
+
+-----------------------------------------------------------------------------
+
+
+
+Kiss 'n Kill (Ronda, 23. Feb 2008, 10:48:15):
+Nicht nur fuer Kieler...
+
+From: Michael Pachta <mipani@gmx.de>
+Subject: Re: Verbot von bestimmten Kennzeichenkombinationen?
+Newsgroups: de.soc.verkehr
+Date: Tue, 19 Feb 2008 00:32:14 +0100
+Message-ID: <61uirsF20nirkU1@mid.individual.net>
+
+Marc Stuermer schrieb/wrote/escribi:
+> >Du wirst auch kein "K - Z" kriegen oder andere Kennzeichen, die
+> >Organisationen des 3. Reiches entsprechen. 
+
+Was hier in Kiel natuerlich schade ist, denn es gibt kein KI-SS. Des 
+Oefteren sehe ich aber KI-LL. Kuessen verboten, toeten erlaubt.
+
+Ein Nachbarkreis (Schleswig-Flensburg) hat das Kennzeichen SL. Ich habe 
+gelegentlich die Kombination SL-UT gesehen. Das duerfte bei anglophonen 
+Menschen ein Schmunzeln verursachen.
+
+Michael
+
+-----------------------------------------------------------------------------
+
+
+
+Sex ist dem Jakobsweg sein Genitiv (Ronda, 23. Feb 2008, 10:48:45):
+From: Lothar Frings <da_lodda@gmx.de>
+Subject: Re: Profi-Entsafter
+Newsgroups: de.etc.sprache.deutsch
+Date:Thu, 21 Feb 2008 00:35:24 -0800 (PST)
+Message-ID:
+<27c2b28c-1763-4a03-8b7c-300ab0334fda@f47g2000hsd.googlegroups.com>
+
+> > Jetzt muss ich wieder an die "handgeschoepfte" Zottersche Schokolade
+> > denken, sowie an den Vortrag von Herrn Zotter inklusive der Erklaerung
+> > fuer diese Wortkreation (woertlich bekomme ich es nicht mehr hin, aber
+> > die Quintessenz daraus war ein erfrischend ehrliches "es klingt einfach
+> > besser").
+
+Harald Schmidt hat vor kurzem ein Buch mit dem
+Titel "Sex ist dem Jakobsweg sein Genitiv"
+veroeffentlicht. Als man ihn fragte, was denn der
+Titel solle, sagte er "Keine Ahnung. Der Verleger
+wollte, dass die Woerter darin vorkommen."
+
+-----------------------------------------------------------------------------
+
+
+
+Was Bikini mit Teebeuteln zu tun haben (Ronda, 23. Feb 2008, 10:49:30):
+Message-ID: <47ba22d6$0$23019$9b4e6d93@newsspool1.arcor-online.net>
+From: "Christian F." <spammails.creon@gmx.net>
+Newsgroups: de.alt.talk.unmut
+Subject: Re: Tee in Raum und Zeit
+Date: 19 Feb 2008 00:29:10 GMT
+
+Seit Volker Pispers weiss doch jeder, dass die Arbeitsplaetze in der 
+Teebeutelbranche von der Anzahl der Ecken eines Teebeutels abhaengt. Daher 
+dient die kunstvolle Gestaltung der Arbeitsplatzbeschaffung.
+
+Die Wirksamkeit eines Teebeutels (bedeutet: Die Effizienz, mit der das 
+Teearoma in das Wasser uebergeht) ist im uebrigen proportional vom Volumen 
+des Teebeutels. Die Idee, den Teebeutel der Tassenform anzupassen ist 
+also gar nicht so verkehrt. Die Optimierung muesste jedoch nun darin 
+bestehen, den Beutel wegzulassen, den Plunder ohne Tuete ins Wasser zu 
+geben und nach beendeter Prozedur den Siff mit einem Sieb wieder 
+herauszufischen.
+
+Kurz und knapp: Der beste Bikini ist "kein Bikini", die beste Religion 
+ist "keine Religion" und der beste Teebeutel ist "kein Teebeutel".
+
+Christian F.
+
+-----------------------------------------------------------------------------
+
+
+
+42 (Ronda, 24. Feb 2008, 18:49:12):
+From: "Ulrich F. Heidenreich" <nospam.0x4711@tremornet.de>
+Subject: 42?
+Newsgroups: de.alt.arnooo
+Date: Sat, 23 Feb 2008 18:21:27 +0100
+Message-ID: <fppo77.3vvnlul.1@ufh.invalid.de>
+
+Hallo!
+
+Mir raubt gerade eines der letzten ungeloesten Raetsel der Menschheit den
+Schlaf: Spart eine Energiesparlampe etwa nur dann Energie, wenn sie auch
+eingeschaltet ist? Ich fuehle mich naemlich dazu hingerissen, ein solches
+Teil, selbst wenn kein Licht benoetigt wird, gelegentlich einzuschalten,
+um in den Genuss des Spareffekts zu kommen. 
+
+Mache ich das richtig oder falsch?
+
+TIA,
+Ulrich
+
+P.S.: Ueber die Reihenfolge diskutieren wir bitte erst spaeter ...
+
+-----------------------------------------------------------------------------
+
+
+
+Betreten der Wasserflaeche verboten! (Ronda, 27. Feb 2008, 21:22:35):
+From: Manfred Hoss <rostkern@arcor.de>
+Subject: Re: Ungenaue Aussagen.
+Newsgroups: de.etc.sprache.deutsch
+Date: Sat, 23 Feb 2008 11:29:51 +0100
+Message-ID: <1f2d99zcdsrvu$.10n9iz10vxu8u.dlg@40tude.net>
+
+Am Sat, 23 Feb 2008 11:14:24 +0100 schrieb Walter Schmid:
+
+> >Wolfram Heinrich schrieb:
+> >
+>> >>Und das andere: "Betreten der Wasserflaeche verboten."
+> >
+> >Man muss diesem Jesus, falls er wiederkommt, doch sagen, was hier 
+> >erlaubt ist!
+
+Was glaubst du, warum Jesus bislang noch nicht wiedergekommen ist?
+
+SCNR
+Manfred.
+
+-----------------------------------------------------------------------------
+
+
+
+CPU (Compressing Parrots Unit) (Ronda, 27. Feb 2008, 21:23:19):
+Message-ID: <47C26F82.3040408@behnel.de>
+Date: Mon, 25 Feb 2008 08:34:26 +0100
+From: Stefan Behnel <stefan_ml@behnel.de>
+Newsgroups: de.comp.lang.python
+Subject: Re: Fragen zu Python von einem Interessenten.
+
+Stefan Scholl wrote:
+
+[snip, TR]
+
+> > $ cat dingsmod.py 
+> > def monty(x):
+> >     print "%d parrots are dead." % x
+> > $ cat dingsmain.py 
+> > from dingsmod import monty
+> > import random
+> > 
+> > monty(random.randint(0, 100))
+
+[snip, TR]
+
+> > $ PYTHONPATH=dingsmod.zip python dingsmain.pyc 
+> > 97 parrots are dead.
+
+Hab's gerade mal ausprobiert, bei mir gibt das aus:
+
+   $ PYTHONPATH=dingsmod.zip python dingsmain.pyc
+   23 parrots are dead.
+
+Vielleicht habe ich einfach eine schwaechere CPU (compressing parrots unit),
+bei der die anderen nicht so lebensbedrohlich stark zusammengepresst werden?
+
+Stefan :)
+
+-----------------------------------------------------------------------------
+
+
+
+Schleichwerbung (Ronda, 27. Feb 2008, 21:24:23):
+From: Thomas Gerlach <usenet@unterderbruecke.de>
+Subject: Re: Titeltext Wikipedia
+Newsgroups: de.etc.sprache.deutsch
+Date: Sun, 24 Feb 2008 14:25:55 +0100
+Message-ID: <47c16ffb$0$23012$9b4e6d93@newsspool1.arcor-online.net>
+
+Gunhild Simon schrieb:
+
+> >Wie lautet denn das Pendant zu Bauherr?
+
+Bauknecht.
+
+SCNR
+Thomas
+
+-----------------------------------------------------------------------------
+
+
+
+Nix Polizist, nix Problem. (Ronda, 27. Feb 2008, 21:27:18):
+Erinnert mich an das riesige Werbeplakat damals (tm) vor einer Bruecke bei
+Stuttgart. Darauf hatte die Stadt Stuttgart ein Foto eines Autotransporters
+gepappt, der unter der Bruecke festhaengt - ein Auto (kein Mercedes!) plakativ
+zwischen Bruecke und Transporter verkeilt. Titel "Er wollte es nicht
+glauben"...
+
+Ronda
+
+From: Oliver Cromm <lispamateur@yahoo.de>
+Subject: Re: Ungenaue Aussagen.
+Newsgroups: de.etc.sprache.deutsch
+Date:Sat, 23 Feb 2008 14:59:48 -0500
+Message-ID: <1td4u3ginnhvv.dlg@mid.crommatograph.info>
+
+>>> >>> "Wir moechten Sie freundlich darauf hinweisen, dass hier nur
+>>> >>> Sozialversager ihren Muell abladen."
+
+>> >> Du ueberforderst die intellektuellen Kapazitaeten der Zielgruppe.
+
+> > Die uebersieht auch das einfachst gehaltene Schild. Ist ja schliesslich
+> > keine Polizei in der Naehe.
+
+Beifahrer: Da ist ein Schild an der Bruecke: Maximalhoehe 3,50m. Sind wir
+da nicht drueber?
+
+Fahrer: Was soll's, ist doch kein Polizist da.
+
+-----------------------------------------------------------------------------
+
+
+
+de.alt.mud soll geloescht werden! (Ronda, 27. Feb 2008, 23:06:25):
+[ SN: Bezieht sich auf die aktuell gelaufene Diskussion um die 
+      Loeschung von d.a.m. <lnvg85-d38.ln1@dreadnought.homedns.org> ]
+
+From: Susalla@FF <susalla@gmx.net>
+User-Agent: FinalFrontier SchleppTOP(R) 8960 Newsreader Module
+Newsgroups: de.alt.mud
+Date: 26 Feb 2008 20:08:51 +0100
+Subject: Re: Usenetgateway aus FinalFrontier
+Message-ID: <fq1o43$m8f$1@finalfrontier.mud.de>
+
+
+Hmm, und das geht wirklich?
+
+Im Uebrigen bin ich der Ansicht, dass daa (de.alt.admin)
+geloescht werden sollte :-)
+Moegliche Ausweichgruppen:
+1. daa (de.alt.astrologie) (Vorhersagen von Trafficentwicklungen,
+   Diskussionsergebnissen etc. aus den Sternen)
+2. de.alt.soc.knigge (weil man von den dortigen Nutzern vielleicht
+   etwas ueber guten Ton lernen koennte)
+3. de.alt.dummschwatz (muss das erklaert werden?)
+4. de.alt.flame (fuer die, bei denen 2. nicht hilft)
+
+Typische Artikel aus daa sind in den genannten Gruppen durchaus
+passend und geben auf die eine oder andere Art Anlass zu
+Diskussionen (und die soll es ja geben).
+
+Alternativ koennten auch alle in eine noch nicht existierende
+Sammelgruppe zusammengefasst werden (verbessert die
+Uebersichtlichkeit der Hierarchie deutlicher, da mehr Gruppen
+eliminiert werden).
+
+
+Susalla@FF
+
+-----------------------------------------------------------------------------
+
+
+
+Noten fuer inhomogene Kleingruppe (Ronda,  4. Mar 2008, 00:08:35):
+From: David Kastrup <dak@gnu.org>
+Newsgroups: de.rec.musik.machen
+Subject: Re: Noten fuer inhomogene Kleingruppe
+Date: Wed, 27 Feb 2008 12:12:33 +0100
+Message-ID: <861w6yodpa.fsf@lola.quinscape.zz>
+
+
+Peter Mueller <peter-mueller7@gmx.net> writes:
+
+> > auf einem Familienfest sollen alle musizierenden Familienmitglieder
+> > wenigstens ein gemeinsames Stueck vorspielen. Da einige der
+> > mitmusizierenden Kinder noch nicht absolut sicher sind, sollte es ein
+> > leichtes Stueck sein, das sich aber doch ganz nett anhoeren soll.
+> > Unser Besetzung sieht wie folgt aus:
+> >
+> > Querfloete
+> > Klarinette/Tenorsax
+> > Klarinette
+> > Sopransax (absoluter Anfaenger)
+> > Altsax/Tenorsax
+> > Tenorsax
+> > Posaune
+> > Fagott
+> > Piano (Anfaenger)
+> > Schlagzeug (absoluter Anfaenger)
+
+Wie lange besteht die Fehde mit den Nachbarn schon?
+
+-----------------------------------------------------------------------------
+
+
+
+Aus der Kirche austreten (Ronda,  4. Mar 2008, 00:12:58):
+From: allinger@brain.net (Wolfgang Allinger)
+Subject: Re: Tipp: Aus der Kirche austretten ...
+Newsgroups: de.etc.beruf.selbstaendig
+Date: 02 Mar 2008 08:43:00 -0400
+Message-ID: <A$5xP9C5cjB@allinger-307049.user.uni-berlin>
+
+
+ On 02 Mar 08 at group /de/etc/beruf/selbstaendig in article
+ <kscheller@ochs.franken.de>  (Konni Scheller)  wrote:
+
+> >Eric Lorenz <elo-newsgroups@usenet.arcornews.de> wrote:
+
+>> >> Dort wird das
+>> >> entsprechend (gegen eine kleine Gebuehr...bei mir waren es damals 30
+>> >> DM) eingetragen.
+
+> >Das Erstaunliche an diesem Vorgang ist, dass es etwas kostet - und
+> >dass das seltsamerweise angeblich mit der Religionsfreiheit vereinbar
+> >ist.
+
+Och, da gabs in meinem Fall des Austritts (um 1971) einige  
+Seltsamkeiten.
+
+Ich war evg., meine Frau rk. Nachdem der rk. Priester unbedingt eine  
+Unterschrift haben wollte, dass alle evtl. Kinder unsererseits "im  
+wahren Glauben der rk. Kirche erzogen werden" und noch so ein paar  
+Klopse (Eheschule...), sind wir dann zum evg. gegangen, anstandslos  
+getraut, selbst die Kirche war kostenlos geschmueckt, der rk. Priester  
+hatte eine Preisliste, wo jedes Hosianna, Kerze, Lied und Bluemchen  
+einzeln draufstand. Von dem Zeitpunkt war mein Weib stinkesauer auf rk.  
+zumal ihr der rk. noch ein paarmal auf die Nerven ging...
+
+Es gab seinerzeit (Pillen Paul?) noch so ein paar finstere Vorgaenge...
+
+Dann bekam ich die 1. Gehaltsabrechnung als Ing. Staunend musste ich  
+feststellen, dass ich auf einmal auch rk. Kirchensteuer berappen musste.
+
+Wurde saeuberlich 50:50 geteilt zw. evg. und rk., dachte ich...
+
+Bei der naechsten Abrechnung bekam die rk. 0,01 DM mehr als die evg. und  
+bei meiner Frau ebenfalls.
+
+Nachfragen bei der Personalabteilung ergaben, dass ges. geregelt ist,  
+dass immer zu Gunsten der rk. gerundet wird. Da ist mir dann der Kragen  
+geplatzt. Wenn die Herrschaften sich nicht zu fein sind, wg. einem  
+einzelnen Pfennig zu schachern und ein Gesetz dazu zu machen, dann bin  
+ich auch nicht zu fein, in meinem Fall das zu beenden.
+
+Geht(ging) aber nicht so einfach: rein kommste mehr oder weniger  
+automatisch, fuers raus sind latuernich wieder komplizierteste Gesetze und  
+Vorschriften gemacht worden. 1. wir mussten das schriftlich machen (na  
+gut, sehe ich noch ein), 2. musste man dazu in einer weit entfernten  
+Aussenstelle persoenlich erscheinen. Dass man da mit OeNV nur schwer  
+hinkam und die nur von 10-12 Uhr an 3 Tagen in der Woche offen hatten,  
+erfuhr man auch erst von einem kleinen Zettel an der dortigen Tuer! Mit  
+den Oeffnungszeiten musste man jedesmal einen ganzen Urlaubstag  
+verballern, da ich damals nicht am Ort arbeitete! Nachdem ich also beim  
+ersten Anlauf vor der geschlossenen Tuere stand, nahm ich die Sache dann  
+persoenlich und zog es durch! 3. irgendwie noch 20DM ausgeklinkt...
+
+Also ich bin letztendlich anlaesslich wegen 1 Pfennig IMHO  
+ungerechtfertigter Aufrundung ausgetreten. Hab nur leider nicht gedacht,  
+mir damals so einen Spruch wie 'Geiz iss geil!' einfallen und sichern zu  
+lassen :-(
+
+Saludos Wolfgang
+-- Meine 7 Sinne: Unsinn, Schwachsinn, Bloedsinn, Wahnsinn, Stumpfsinn,
+Irrsinn, Loetzinn.
+
+-----------------------------------------------------------------------------
+
+
+
+Oesterreich not found?! (Ronda,  6. Mar 2008, 00:15:28):
+From: "Michael Fesser" <netizen@gmx.de>
+Subject: "Error in application oesterreich"
+Newsgroups: de.alt.recovery.webauthor
+Date: Tuesday, February 26, 2008 5:15 PM
+Message-ID: <ade8s3d36greq45geocefqdsg28rvl5a82@4ax.com>
+
+Andere kommen mit einem schnoeden 404, aber diese Fehlermeldung hier hat
+doch was:
+
+| Error in application oesterreich
+|
+| Object not found.
+
+http://wien.orf.at/foo
+
+Sind die Oesis wirklich weg? Kann mal jemand nachschauen?
+
+SCNR
+Micha
+
+-----------------------------------------------------------------------------
+
+
+
+Oh je... (Ronda, 13. Mar 2008, 21:13:11):
+... denkt dran, wenn Ihr was im Usenet postet...
+
+Ronda
+
+SN: Dem OP ging es um Einmischungen bei der Erziehung seiner Kinder
+durch seine Eltern.
+
+From: Thomas Bliesener <nospam@melix.com.mx>
+Newsgroups: de.soc.familie.kinder
+Subject: Re: Eltern unertraeglich seitdem unsere Tochter
+ da ist - Hilfe!!
+Date: Mon, 10 Mar 2008 14:20:29 -0600
+Message-ID: <slrnftb60d.9er.nospam@bli.melix.com.mx>
+
+Willibald Papesch schrieb:
+> > Na ja, und wenn ich mir die Kommentare so ansehe, befuerchte ich, in
+> > etichen 20 ... 30 Jahren werde sich dasselbe Schauspiel wieder
+> > wiederholen, und man wird wieder sagen koennen, vielleicht bekommen
+> > sie nur die Rechnung ... 
+
+Das wird einfach:
+"Wuerdest Du bitte mal danach googeln? Dieselbe Frage hat Dein Vater
+gerade vor dreissig Jahren gestellt
+-- X-no-Sig: yes
+
+-----------------------------------------------------------------------------
+
+
+
+Katzenpolitik (Ronda, 13. Mar 2008, 21:57:40):
+From: kscheller@ochs.franken.de (Konni Scheller)
+Subject: Re: Partition ist da und irgendwie doch nicht da
+Newsgroups: de.alt.sysadmin.recovery
+Date: Mon, 10 Mar 2008 09:57:36 +0100
+Message-ID: <1idkyz0.juswga1tfrxmaN%kscheller@ochs.franken.de>
+
+Juergen Ernst Guenther <muftix@rrr.de> wrote:
+
+> > Wer mal bewusst einem Blindenhund bei der Arbeit zugesehen hat,
+> > kommt nicht mehr auf die dumme Idee, dass Katzen denken koennten.
+[..]
+> > Hunde und Primaten erwarten, dass man kommuniziert.
+
+Du hast also das Katzenprotokoll nicht verstanden.
+
+Zur Erlaeuterung...
+
+Das diplomatische Protokoll von felis silvestrus ist recht
+kompliziert,
+aber eigentlich einfach zu verstehen. Es beruht auf gegenseitigen
+Respekt und Unabhaengigkeit. Es funktioniert also nicht wie bei Hunden,
+die sich dir willig unterordnen, wenn du nur bestimmt genug
+auftrittst.
+Eine Katze wird sich stattdessen auf aktiven oder passiven Widerstand
+zurueckziehen oder einfach verschwinden, wenn du versuchst, sie zu
+dominieren. Stattdessen muss man sie ueberzeugen.
+
+Versucht man Katzen z.B. gegen ihren Willen zu streicheln, dann nehmen
+sie das meist zunaechst hin - Katzen sind sehr hoeflich. Doch du musst
+eben auch merken, dass sie das nicht wollen und die Aktion rechtzeitig
+beenden. Sie gibt Dir also eine Chance, dein Gesicht zu wahren.
+Genauso
+erwartet das die Katze aber von Dir.
+
+Willst du Freundschaft mit einer Katze schliessen, dann fixiere sie
+niemals mit den Augen. Das wird als Drohung verstanden. Stattdessen
+schliesse langsam die Augen, oeffne sie nur halb wieder. Gaehne auch mal.
+Sie wird dich moegen.
+
+Katzen greifen normalerweise niemals ohne Grund an. Sie zeigen Dir,
+wenn
+sie ihre Ruhe haben wollen. Allerdings sollte man die Signale auch
+beachten: Schwanzhaltung, Ohren, Gesichtsausdruck.
+
+Katzen sind also wesentlich einfacher zu verstehen als z.B. Frauen
+(obwohl es hilft ;).
+
+Servus,
+Konni
+
+-----------------------------------------------------------------------------
+
+
+
+Elementarteilchenphysiker... (Ronda, 13. Mar 2008, 21:58:55):
+From: Rolf_Bombach <rolfnospambombach@bluewin.ch>
+Subject: Re: Reichweite von Funkschluesseln
+Newsgroups: de.sci.electronics
+Date: Sun, 09 Mar 2008 10:55:51 +0100
+Message-ID: <47d3b429$1_1@news.bluewin.ch>
+
+Falk Willberg schrieb:
+> > Rolf_Bombach schrieb:
+>> >> Bjoern Schliessmann schrieb:
+>>> >>> Ralph A. Schmid, dk5ras wrote:
+>>>> >>>> "Markus Gronotte" <maqqusz@gmx.de> wrote:
+>>> >>>  
+>>>>> >>>>> Zweitens: 433MHz bedeutet eine Wellenlaenge von 2,3 nm.
+>>>> >>>> Rechne bitte nochmal nach.
+>>> >>> Was hast du gegen Roentgenschluessel? :)
+>> >> Vielleicht meint er Nautische Meilen?
+> > 
+> > 700kHz passt auch nicht...
+
+Makus ist ja unter die Kern- und Elementarteilchenphysiker
+gegangen. Die feiern ja oft schon Triumphe, wenn theoretischer
+und Messwert im gleichen Quadranten zu liegen kommen. *duck*
+(O-Ton eines Vortragenden: ...well, all curves are on the
+same graph...)
+
+-----------------------------------------------------------------------------
+
+
+
+Katzen II (Ronda, 13. Mar 2008, 21:59:47):
+Message-ID: <1idi8s6.1bssf6k134v9nwN%kscheller@ochs.franken.de>
+From: kscheller@ochs.franken.de (Konni Scheller)
+Newsgroups: de.alt.sysadmin.recovery
+Subject: Re: Partition ist da und irgendwie doch nicht da
+Date: Sat, 8 Mar 2008 22:22:43 +0100
+
+Mirko Liss <mirko.liss@web.de> wrote:
+
+> > Ich habe nie diese Katzenfreunde verstanden, die sich so ein widerliches
+> > Mistvieh zulegen, das sie Tag fuer Tag schikaniert.  Ebenso gut koennte
+> > man Kinder in die Welt setzen.
+
+Ein Hund denkt: Sie fuettern mich, sie sorgen fuer mich, sie streicheln
+mich: das muessen Goetter sein. 
+
+Eine Katze denkt: Sie fuettern mich, sie sorgen fuer mich, sie streicheln
+mich: ich muss ein Gott sein. 
+
+Servus,
+Konni
+
+-----------------------------------------------------------------------------
+
+
+
+Kleinigkeiteneinkauf (Ronda, 13. Mar 2008, 22:01:30):
+From: Mathias Fuhrmann <shueznaa@spamfence.net>
+Subject: Re: Stress beim Einpacken
+Newsgroups: de.alt.fan.aldi
+Date: Thu, 6 Mar 2008 13:20:00 +0100
+Message-ID: <47cfe171$0$21942$9b4e6d93@newsspool2.arcor-online.net>
+
+Hartmut 'Hardy' Schiszler schrieb:
+
+> >Fuer _eine_ Kleinigkeit benoetigt auch niemand einen Wagen. Der haelt dann 
+> >sogar den Betrieb an der Kasse nicht unnoetig auf.
+> >Nicht den Grundgedanken aus den Augen verlieren.
+
+Du gehst vermutlich nie/selten mit einer Frau zum Kleinigkeiteneinkauf.
+;-)
+
+Mathias
+
+-----------------------------------------------------------------------------
+
+
+
+Katzen III (Ronda, 13. Mar 2008, 22:02:08):
+From: Hanno Gardemann <gardemann@online.de>
+Subject: Re: Wie viel Moebel braucht eine Katze?
+Newsgroups: de.rec.tiere.katzen
+Date: Wed, 05 Mar 2008 22:34:36 +0100
+Message-ID: <fqn3iu$mnh$1@news.albasani.net>
+
+Rudolf Steinmeyer schrieb:
+
+> >Es geht hier nicht um unsere Katze, wir haben eigentlich keine.
+
+Sowieso!
+Menschen haben nie Katzen, Katzen haben Menschen.
+
+> >Die gehoert dem Nachbarn gegenueber und nimmt uns nur als angenehmere 
+> >Unterkunft zu etwa einem Drittel ihrer Zeit in Anspruch. Ihr stehen im 
+> >Wohnzimmer zwei Kissen am Boden, davon eines am Heizkoerper, und ein 
+> >beliebiger Platz auf dem Ecksofa zu. Nun aber hat sie auch noch meinen 
+> >Fernseh-Sessel als gut befunden. Muss ich das dulden? 
+
+Komische Frage. Selbstverstaendlich! Ausserdem ist 
+das Katzenpersonal verpflichtet, Zugang zu einem 
+sicheren Hochsitz zu ermoeglichen von dem aus die 
+Katze ihr Personal kontrollieren kann.
+
+> >Der ist noch 
+> >ziemlich neu und hat an die 1.200 Euro gekostet! 
+
+Soll die Katze sich etwa in einen alten, billigen 
+Sessel legen?
+Als ich Weihnachten fuer meine Frau einen neuen 
+Fernsehsessel besorgt hatte, ist Arthur auch 
+sofort von seinem alten Sessel in den neuen 
+umgezogen.
+Ab und an darf meine Frau den Sessel auch mal 
+benutzen, Arthur ist ja keine Unkatze. Den 
+Zeitrahmen bestimmt er aber schon selbst, ist ja 
+wohl selbstverstaendlich.
+
+> >Dass sie auch mal 
+> >gelegentlich, wenn die Sonne scheint, mein Bett liegenswert findet nehme 
+> >ich hin; denn ich muss gluecklicherweise nicht tagsueber im Bett liegen.
+
+Kann ja noch kommen, wenn Du Dich mit der Katze 
+wegen dieser rechtlich eindeutigen Sesselsache 
+anlegst. Katzen verstehen keinen Spass, wenn sie 
+im Recht sind.
+Und sie sind immer im Recht.
+Und die im von vorne herein aussichtslosen 
+Auseinandersetzungen koennen zu entzuendlichen 
+Kratzern fuehren.
+Und die wiederum koennten zu einem erzwungenen 
+Ganztagesaufenthalt im Bett fuehren. Wobei die 
+Katze sicher nichts gegen eine gemeinsame 
+Bettnutzung einzuwenden hat, wenn Du Dich nicht 
+allzu breit machst.
+
+> >Wie ist die Rechtslage, darf ich sie des Sessels entheben?
+> >Den Tierschutzbund will ich nicht befragen, die sind parteiisch.
+
+Die Rechtslage ist eindeutig! S. o.!
+
+Paragraph 1: Die Katze hat immer und ist immer im 
+Recht.
+Paragraph 2: Wird das Recht der Katze von ihrem 
+Personal (vulgo Mensch) angezweifelt oder in Frage 
+gestellt, tritt automatisch Paragraph 1 in Kraft.
+
+(...)
+
+Hanno
+
+-----------------------------------------------------------------------------
+
+
+
+Beethoven ist TOT! (Ronda, 13. Mar 2008, 22:09:53):
+From: Lothar Frings <da_lodda@gmx.de>
+Subject: Re: Vernichtende Kritiken
+Newsgroups: de.etc.sprache.deutsch
+Date: Tue, 4 Mar 2008 03:41:08 -0800 (PST)
+Message-ID:
+<e00b21a8-a5dd-4abc-ba48-1ea0a0f1ef8b@n75g2000hsh.googlegroups.com>
+
+[SN: Zitat ergaenzt]
+
+>> >> Ich suche also boesartige Kritiken, fallen euch welche ein? Sie koennen 
+>> >> auch auf Englisch oder Franzoesisch sein, wenn bei der Uebersetzung der 
+>> >> Wortwitz verlorengeht.
+
+> > "Yesterday the City Hall Orchestra played Brahms. Brahms lost."
+
+Polizist klingelt an der Wohnungstuer, von innen klingt
+Klaviermusik.
+
+"Guten Tag, ich gehe einem Hinweis aus der Nachbarschaft
+nach. Angeblich wird hier ein gewisser Beethoven ermordet."
+
+-----------------------------------------------------------------------------
+
+
+
+Keine Katzen diesmal (Ronda, 15. Mar 2008, 00:08:41):
+Message-ID:
+<df7e9c90-8e61-46e8-a501-78de926d7c04@n77g2000hse.googlegroups.com>
+From: "G.O.Tuhls" <G.O.Tuhls@googlemail.com>
+Newsgroups: de.alt.talk.unmut
+Subject: Re: Liebe Bahn- (und Bus-)reisende!
+Date: Thu, 13 Mar 2008 03:10:17 -0700 (PDT)
+
+On 13 Mrz., 00:36, "Norbert R." wrote:
+> >
+> > vielleicht sollte man da mal politischerseits ein Verbot dieser langen
+> > und ausziehbaren Hundeleinen erwaegen *aufschreiderhundebesitzer*. Frueher
+> > ging es doch auch, mit einer nur 1,50 m langen Hundeleine mit
+> > Einheitslaenge auch grosse Hunde auszufuehren. Oder mal diese
+Hundebesitzer
+> > verpflichten, mit ihren Hunden eine Hundeschulung zu absolvieren.
+
+Nicht immer gleich nach der Politik rufen! Selbsthilfe ist angesagt:
+Mit einem Wuerstchen in der Hand 3-5 Mal um Frauchen rumrennen, der
+Koeter folgt Dir selbstverstaendlich & done.
+
+Gruss
+G.O.
+
+-----------------------------------------------------------------------------
+
+
+
+"Medion empfielt ..." (sic!) (Ronda, 16. Mar 2008, 22:20:42):
+From: Hartmut 'Hardy' Schiszler <schiszler@web.de>
+Newsgroups: de.alt.fan.aldi
+Subject: Re: "Medion empfielt ..."
+Date: Fri, 14 Mar 2008 07:05:15 +0100
+Message-ID: <63uistF29n6djU3@mid.individual.net>
+
+
+Florian Diesch schrieb:
+> > darkon@gmx.de (Volker "darkon" Riehl) wrote:
+> >
+>> >> Uwe Reithuber <koh@gmx.at> wrote:
+>> >>
+>>> >>> Wenn man
+>>> >>> sich ernsthaft mal damit beschaeftigt (und es gibt in diversen
+Magazinen
+>>> >>> sogar Schritt-fuer-Schritt-Anleitungen fuer Effekte) ist die
+Oberflaeche
+>>> >>> intuitiv.
+>> >> Wenn man sich erst mit grossartig damit beschaeftigen und Anleitungen
+>> >> lesen muss, dann ist das eigentlich das genaue Gegenteil von Intuitiv.
+>> >>
+>> >> Intuitiv bedeutet, dass die Bedienung sich dem Anwender sofort von
+selbst
+>> >> erschliesst.
+> >
+> > Gibt's ausser der Mutterbrust irgendwas, das intuitiv benutzbar ist?
+
+Untenrum.
+
+Hardy
+
+-----------------------------------------------------------------------------
+
+
+
+Linux, Windows und die Porno-Videos (Ronda, 17. Mar 2008, 22:41:56):
+From: Peter Wenz <sparta@rrr.de>
+Newsgroups: de.alt.fan.aldi
+Subject: Re: "Medion empfielt ..."
+Date: Sun, 16 Mar 2008 09:19:20 +0100
+Message-ID: <gob1zg103tqe$.dlg@ubu.schnauze-sonst-beule.de>
+
+Am Sun, 16 Mar 2008 07:42:51 +0100 schrieb Hartmut 'Hardy' Schiszler:
+
+> > Florian Diesch schrieb:
+>> >> Hartmut 'Hardy' Schiszler <schiszler@web.de> wrote:
+
+>>>> >>>> Gibt's ausser der Mutterbrust irgendwas, das intuitiv benutzbar ist?
+>>> >>> Untenrum.
+>> >> Wenn das so intuitiv ist, warum gibt's dann so viel Schulungsunterlagen 
+>> >> dazu? In meiner Lieblingsvideothek fuellen die eine ganze Abteilung! Ich
+>> >> denke daher eher, dass das fuer viele Menschen ein extrem schwieriges 
+>> >> Thema ist.
+> > Siehst du, jetzt sind wird zurueck beim Thema:
+> > Was du an Doku in deiner Videothek siehst sind Anleitungen fuer 
+> > Hardcore^W^Linux-User.
+
+Jep. Man schaut sich die Doku an und macht es dann.
+
+> > Der Laie kommt auch ohne gut klar, hat halt einen 
+> > wesentlich geringeren Funktionsumfang und geht Sicherheitsrisiken 
+> > ein(zeigen sich haeufig neun Monate spaeter), also ist das dann Windows.
+
+Ich gehe eher davon aus, dass die _deutsche_(!!!1) Uebersetzung =
+'Fenster' auf den eingeschraenkten Leistungsumfang hinweist.
+
+Durch die Scheibe den anderen dabei zuschauen, ohne selbst zu wissen,
+was passiert, beschreibt den Unterschied ganz gut...
+
+Cheers
+Peter
+
+-----------------------------------------------------------------------------
+
+
+
+Wer von den Felinen hier war das?! (Ronda, 17. Mar 2008, 22:45:53):
+From: Die Rote Lucy <die_rote_lucy@gmx.de>
+Newsgroups: de.alt.admin,de.rec.tiere.katzen
+Subject: Vorschlag: de.alt.felidae
+Date: Sun, 16 Mar 2008 19:25:06 +0100
+Message-ID: <20080316192506.186c8621.die_rote_lucy@gmx.de>
+
+
+Name und Tagline
+----------------
+
+de.alt.felidae   Von Feliden fuer Feliden, Hominiden muessen draussen
+bleiben
+
+Charta
+------
+
+Diese Gruppe ist ausschliesslich fuer die Benutzung durch Angehoerige
+der Familie der Felidae gedacht. Hominiden sind ausdruecklich nur als
+Diskussionsgegenstand und keinesfalls als aktive Diskussionsteilnehmer
+gestattet. Ebenso Angehoerige anderer Familien, z.B. der Canidae, Muridae
+etc.
+
+Die Gruppe ist vorlaeufig unmoderiert. Sollten Feliden dort in aehnlicher
+Art und Weise von Hominiden misshandelt werden wie im uebrigen Usenet
+oder im realen Leben, behalten wir uns eine spaetere Moderation vor.
+Ebenso im Falle einer Unterwanderung der Gruppe durch Stegano-Hominiden.
+
+Begruendung
+----------
+
+Zwar existiert in de.all die Gruppe de.rec.tiere.katzen, aber diese wird
+nahezu ausschliesslich von Hominiden benutzt. Eine Gruppe fuer den
+Austausch unter Feliden fehlt bislang voellig in de.all.
+
+Obwohl Computer und das Usenet vermutlich durch Hominiden entwickelt
+wurden, gibt es keinen logisch zwingenden Grund, Angehoerigen anderer
+Spezies, die ueber physischen Zugang zu vernetzten Computern verfuegen
+sowie ueber die erforderlichen Faehigkeiten zu ihrer Benutzung, die
+Nutzung dieser Erfindungen zum weltweiten gegenseitigen
+Informationsaustausch unter Artgenossen vorzuenthalten.
+
+Eine Nutzung der von Hominiden befallenen Gruppen ist Feliden
+allerdings nicht zumutbar, da Hominiden dort in einer chauvinistisch-
+diskriminierenen Art ueber "ihre" Katzen diskutieren, die
+eine krasse Verletzung der Wuerde aller Feliden als selbstbestimmte
+Lebewesen darstellt. Feliden werden dort von ihren "Eigentuemern" als
+leibeigene Sachgegenstaende ohne eigene Rechte, insbesondere das
+Grundrecht auf freie Selbstbestimmung, behandelt.
+
+Diese repressiv-hoministische Sichtweise der Artenwelt stammt aus den
+dunkelsten Zeiten der Geschichte der europaeischen Hominiden vor der
+sog. Aufklaerung und entspricht den Anforderungen an ein konstruktives
+Zusammenleben im Hinblick auf das Gemeinwohl aller Spezies auf dem
+Planeten Erde im 21. Jahrhundert in keinster Weise.
+
+Die Diskussion ueber diesen Vorschlag findet in der Newsgroup
+de.alt.admin statt.
+
+-- Feliden aller Laender vernetzt Euch! 
+
+-----------------------------------------------------------------------------
+
+
+
+Der Link ist echt echt... (Ronda, 17. Mar 2008, 22:48:43):
+From: Joern Abatz <for-spam-only@abatz.de>
+Subject: Re: ?
+Newsgroups: de.etc.sprache.deutsch
+Date:Sat, 08 Mar 2008 05:13:08 +0100
+Message-ID: <pan.2008.03.08.04.13.06.707608@abatz.de>
+
+[SN: Zitat ergaenzt]
+
+>> >> Und da unterscheidet der kleine Dampferzeuger hinwiederum zwischen
+>> >> Wrasen (Sattdampf) und Brueden (Heissdampf)
+
+> > Und ich finde es echt schade, dass es das Buch "Wasserkochen leicht 
+> > gemacht" von Hans Dampf und Angelika Nebel-Dampf nicht mehr zu erwerben 
+> > gibt.
+
+> > Als ich meiner Mutter vor langer Zeit einen Wasserkocher zu Weihnachten 
+> > schenkte, gab es es schon nicht mehr und das waere das perfekte 
+> > Beigeschenk gewesen.
+
+> > P.S: Und ich muss immer an dieses Buch denken, wenn mein Blick auf 
+> > "C-kurz und gut von Peter Kirch und Ulla Kirch-Prinz" faellt ... ;-)
+
+http://www.amazon.de/Wasserkochen-leicht-gemacht-Ratgeber-Ahnungslose/dp/38852
+01240
+
+-- Martin Gerdes 
+
+-----------------------------------------------------------------------------
+
+
+
+Deppenbindestrich (Ronda, 21. Mar 2008, 14:26:09):
+From: Andreas Hoefeld <me@privacy.net>
+Subject: Re: Wandernde-Binde Striche?
+Newsgroups: de.etc.sprache.deutsch
+Date: Wed, 19 Mar 2008 21:15:28 +0100
+Message-ID: <47e1745b$0$4849$9b4e6d93@newsspool4.arcor-online.net>
+
+Nachricht von Dirk Schneider:
+> > Hallo zusammen,
+> >
+> > da sah ich heute im Supermarkt im Regal zwei Sorten Backmischungen der
+> > Firma Schrei (Name geaendert): Einmal "Kirsch Kuchen" und direkt daneben
+> > "Russischer-Topfenkuchen". Ob da die Bindestriche uebergesprungen sind?
+> > Auf deren Webseite gibt es auch noch z.B. "Bio Rahm-Apfel Kuchen",
+> > "Himbeer Joghurt Schnitte" oder "Kirsch-Baisertorte".
+
+Neben dem Deppenleerzeichen gibt es auch den Deppenbindestrich.
+Mein persoenlicher Liebling ist der in der Pariser-Weltausstellung.
+
+Andreas
+
+-----------------------------------------------------------------------------
+
+
+
+Eyewear! (Ronda, 21. Mar 2008, 14:28:05):
+Ha, da passt, dass ich immer sage dass ich meine Brille anziehe!
+
+Ronda
+
+From: Volker Gringmuth <einklich@gmx.net>
+Newsgroups: de.etc.sprache.deutsch
+Subject: Re: eyewear
+Date: Mon, 17 Mar 2008 20:35:30 +0100
+Message-ID: <frmkmi.19s.1@marvin.einklich.net>
+
+Mark Milke wrote:
+
+> > wie wuerdet Ihr eyewear ins Deutsche uebersetzen oder ist eyewear? 
+
+Ich fuerchte, "eyewear" ist so deutsch wie "Handy" oder "Flyer" :)
+
+> > Kann man zu eyewear einfach Brillen sagen?
+
+Koennte man, aber das klingt ja steinzeitlich. Dann schon lieber 
+"Augenbekleidung". 
+
+Schliesslich tragen wir auch keine Uhren mehr am Handgelenk, sondern 
+"timewear"!
+
+Hab ich schon mal den Untertitel "Fachgeschaeft fuer Erektionsbekleidung" 
+an einem Kondomladen erwaehnt, dessen Anblick mich augenblicklich in ein 
+hilflos am Boden nach Luft japsendes Etwas verwandelte? 
+
+
+vG
+
+-----------------------------------------------------------------------------
+
+
+
+Neue Herausforderungen gesucht! (Ronda, 21. Mar 2008, 14:28:35):
+Subject:     Neue Dokus auf N24 und n-tv
+From:        Bernd Graber <bernd.graber@hotmail.de>
+Newsgroups:  de.rec.tv.misc
+Date:        Mon, 17 Mar 2008 05:34:01 -0700 (PDT)
+Message-ID: <3a07bca4-d0cd-455e-bf9d-df95636020a4@e6g2000prf.googlegroups.com>
+
+Weiss hier zufaellig jemand, wann N24 und n-tv mal wieder auf
+Einkaufstour gehen und endlich neue Dokus senden?***
+
+"Alltag auf einem Flugzeugtraeger" habe ich gefuehlte 2000x gesehen.
+Katapult-Start und Fangseil-Landung bei Nacht beherrsche ich im
+Schlaf. Koennte sofort bei der US-Navy anfangen. Aber auch Hochhaeuser
+sprengen, den groessten Bagger der Welt bedienen oder Supertanker bauen
+- dank N24 alles kein Problem.
+
+Brauche neue Herausforderungen.
+
+Bernd
+
+*** bei der Gelegenheit bitte auch Kronzucker entsorgen.
+
+-----------------------------------------------------------------------------
+
+
+
+Die Signatur ist auch schoen (Ronda, 29. Mar 2008, 22:33:29):
+From: r.schwentker@regioconnect.net (Roger Schwentker)
+Newsgroups: de.alt.sysadmin.recovery
+Subject: Re: Amyuni PDF Converter
+Date: Fri, 28 Mar 2008 06:14:34 +0000 (UTC)
+Message-ID: <fsi2c9$bkg$3@silvana.westfalen.de>
+
+Hans Bonfigt <bonfigt.ses-koeln@t-online.de> wrote:
+> > Noch vor zehn Jahren gab es Faelle, in denen Vollblut-Vertieblerinnen
+> > mit freizuegigem Koerpereinsatz dafuer sorgten, dass uralte RM-Kisten
+> > zu ueberteuerten Preisen ihren Weg in diverse Behoerden fanden.
+> > Damit ist angeblich jetzt Schluss.
+
+Stimmt. Die RM werden nicht mehr hergestellt.
+
+  Gruss
+    Roger Schwentker
+    r.schwentker@regioconnect.net
+-- Die einzig oekologische Verpackung fuer Milch ist eine Kuh. Weil man die
+Verpackung mitessen kann. [Dieter Nuhr] 
+
+-----------------------------------------------------------------------------
+
+
+
+Kinder-Jedi-Schwert (Ronda, 29. Mar 2008, 22:34:47):
+... hrgs, wahrscheinlich werd ich in Zukunft immer gaga grinsen, wenn mal
+wieder jemand in einem "ernsthaften" Vortrag einen Laserpointer zueckt...
+
+Message-ID: <652el5F2cildkU3@mid.dfncis.de>
+From: Oliver Schad <nospam.spam.entfernen@oschad.de>
+Newsgroups: de.alt.sysadmin.recovery
+Subject: Re: Partition ist da und irgendwie doch nicht da
+Date: Thu, 27 Mar 2008 21:33:42 +0100
+
+Arnim Sommer schrieb:
+
+> > Andreas Scherbaum schrieb:
+>> >> Was mich wiederum dran erinnert, das ich neue Batterien fuer den
+>> >> Laserstift brauche ...
+>> >> 
+> > Ist das sowas wie ein Laserdrucker in handlich?
+
+Nein, das ist ein Kinder-Jedi-Schwert.
+
+mfg
+Oli
+
+-- Man darf ruhig intelligent sein, man muss sich nur zu helfen wissen. 
+
+-----------------------------------------------------------------------------
+
+
+
+Interessanter Vergleich (Ronda, 29. Mar 2008, 22:36:37):
+From: Konrad Wilhelm <konrad_wilhelm@web.de>
+Subject: Re: Tellofix kaufen
+Newsgroups: de.rec.mampf
+Date: Sat, 22 Mar 2008 00:13:25 +0100
+Message-ID: <svf8u3dd3k57isu8a2qg54bura0ud5g8rc@4ax.com>
+
+On Fri, 21 Mar 2008 23:39:35 +0100, faust <bernd.winter@online.de>
+wrote:
+
+> >Daniel Krebs schrieb:
+>> >> Konrad Wilhelm <konrad_wilhelm@web.de> wrote:
+>> >>
+>>> >>> Ich wuesste noch nicht mal, worum es sich bei Tellofix handeln
+koennte.
+>> >>
+>> >> Ist gewuerztes Glutamat ;-)
+>> >> Daniel
+> >Hallo Daniel,
+> >klaer mich bitte auf. Das folgende ist die Inhaltsangabe von Tellofix:
+> >
+> >     *  Klare Delikatess-Suppe und Allwuerzmittel mit Suppengruen
+> >     * Millionenfach bewaehrt und begehrt
+> >     * fuer hoechste Ansprueche
+> >     * das Beste vom Besten
+> >     * glutenfrei, lactovegetabil, cholesterinfrei
+> >     * auf pflanzlicher Basis
+> >     * Instant - sofort loeslich
+> >     * Nur 0,1 g Fett je 100 ml Suppe
+> >
+> >Da steht glutenfrei, ist das nicht das selbe wie Glutamat?
+
+Nicht direkt. Gluten und Glutamat sind ungefaehr so vergleichbar wie
+Uran und Urin.
+
+Ernst: Gluten ist ein Portein aus Weizen und manchen anderen
+Getreiden. Glutamat ist das Salz einer Aminosaeure.
+
+k.
+
+-----------------------------------------------------------------------------
+
+
+
+Swappnoefbefehr (Ronda, 29. Mar 2008, 22:37:51):
+From: Ren <Kar98@The-Coalition.US>
+Subject: Re: Was fuer ein deutsches Wort ist "gekidnappt"?
+Newsgroups: de.etc.sprache.deutsch
+Date:Fri, 21 Mar 2008 19:30:27 GMT
+Message-ID: <2008032114302744303-Kar98@TheCoalitionUS>
+
+
+>> >> Slip ist auch nicht im Deutschen erfunden, es wird nur anders 
+>> >> verwendet als im Englischen, wo es "Unterrock" bedeutet.
+
+> > Theoretisch ist es so genauer, aber:
+> > Es ist eine auffaellig andere Verwendung und soll besser sein als
+> > "Schluepfer". Es handelt sich nicht um eine Bedeutungsverschiebung. 
+> > Das Wort ist praktisch neu erfunden worden.
+
+Eben, und warum? Weil "Schluepfer" eklig klingt, genau wie 
+"Geschlechtsverkehr", obwohl doch beides sehr huebsch sein kann ;)
+
+Wenn "Handy" nicht fuers Deutsche erfunden worden waere, hiessen die 
+Dinger "Selbstwaehlapparate fuer den nichtoeffentlichen, beweglichen 
+Fernsprechverkehr", oder kurz Swappnoefbefehr, und das ist doch nicht 
+wirklich huebsch, oder?
+
+-----------------------------------------------------------------------------
+
+
+
+Fuer eine ganz spezielle Kroete aus Koeln (Ronda, 29. Mar 2008, 22:39:18):
+From: "Martin Udelhoven" <maetesudelhoven@googlemail.com>
+Subject: Re: Abendmahlzeit
+Newsgroups: de.etc.sprache.deutsch
+Date:Thu, 20 Mar 2008 09:15:25 +0100
+Message-ID: <frt6ek$8t$1@newsreader2.netcologne.de>
+
+>> >> Viele Gruesse von Dani, die in Koeln auch eine Fleischpflanzlsemmel
+bekam
+>> >> statt des Frikadellenbroetchens auf der Karte
+
+> > In Koeln wuerde ich mich wundern, wenn ich 'ne Halve Hahn bestelle, aber
+> > ein halbes Haehnchen bekomme.
+
+Wirklich wunderlich wuerde Dir, wenn Du ein Altbier bestelltest.
+
+Dagegen ist die Bestellung eines Wassers im Brauhaus noch schmerzfrei: "Und 
+Handtuch und Seife dazu?!"
+
+-----------------------------------------------------------------------------
+
+
+
+Politisch korrekt Bilder verfaelschen (Ronda, 29. Mar 2008, 22:40:12):
+Subject: Re: Kragen: nicht hochgeschlagen
+From: Andreas Hoefeld <me@privacy.net>
+Newsgroups: de.etc.sprache.deutsch
+Message-ID: <47e2bd90$0$4848$9b4e6d93@newsspool4.arcor-online.net>
+
+Nachricht von Helga Schulz:
+
+>>>>> >>>>> Und gefakten Bildern glaubst Du mehr?
+>>>> >>>> Ist "gefakte Bilder" ein deutscher Begriff?
+> > 
+>> >> Einigen wir uns auf "verfaelschen" als Uebersetzung von "faken"?
+> > 
+> > Nein. Allenfalls auf "tuerken".
+
+Das ist diskriminierend. Ich haette gern "Bilder mit nachtraeglich 
+hinzugefuegtem Migrationshintergrund."
+
+Threadverbindend,
+Andreas
+
+
+-= END forwarded message =-
+
+
+-----------------------------------------------------------------------------
+
+
+
+Dem Artikel fehlt Viagra, wie mir scheint (Ronda, 30. Mar 2008, 23:03:35):
+Betreff: Re: eyewear
+Datum: Sat, 22 Mar 2008 13:44:31 +0100
+Von: Thomas Schade <toscha@rrr.de>
+Newsgroups: de.etc.sprache.deutsch
+Message-ID: <47E4FF2F.6080905@news.toscha.de>
+
+On 22.03.2008 11:53, Volker Gringmuth wrote:
+
+>>>>>>>>>>>>>> >>>>>>>>>>>>>> Hm, in diesem Artikel scheint mir die
+Bezeichnung
+>>>>>>>>>>>>>> >>>>>>>>>>>>>> "Fachgeschaeft fuer Erektionsbedarf" eher der
+witzige
+>>>>>>>>>>>>>> >>>>>>>>>>>>>> Einfall des Autors dieses Artikels zu sein und
+nicht
+>>>>>>>>>>>>>> >>>>>>>>>>>>>> der selbstgewaehlte Untertitel der
+"Condomi"-Kette.
+>>>>>>>>>>>>> >>>>>>>>>>>>>
+>>>>>>>>>>>>> >>>>>>>>>>>>> Laut
+>>>>>>>>>>>>> >>>>>>>>>>>>>
+http://www.spiegel.de/wirtschaft/0,1518,471301,00.html 
+>>>>>>>>>>>>> >>>>>>>>>>>>> ist sie uebrigens pleite.
+>>>>>>>>>>>> >>>>>>>>>>>>
+>>>>>>>>>>>> >>>>>>>>>>>> Dann haben sie es ja ausgestanden.
+>>>>>>>>>>> >>>>>>>>>>>
+>>>>>>>>>>> >>>>>>>>>>> Laut
+>>>>>>>>>>> >>>>>>>>>>>
+http://www.welt.de/wirtschaft/article1003223/Australier_w
+>>>>>>>>>>> >>>>>>>>>>> ollen_ Cond omi_wieder_gross_machen.html soll die
+Marke
+>>>>>>>>>>> >>>>>>>>>>> wieder aufleben.
+>>>>>>>>>> >>>>>>>>>>
+>>>>>>>>>> >>>>>>>>>> Du meinst, sie wollen die Marke wieder aufrichten?
+>>>>>>>>> >>>>>>>>>
+>>>>>>>>> >>>>>>>>> Es besteht wohl grosser Erektionsbedarf.
+>>>>>>>> >>>>>>>>
+>>>>>>>> >>>>>>>> Dieser Ausdruck ist nicht subtil genug, das kommt ziemlich
+>>>>>>>> >>>>>>>> steif rueber.
+>>>>>>> >>>>>>>
+>>>>>>> >>>>>>> Entscheidend ist, was vorne rauskommt.
+>>>>>> >>>>>>
+>>>>>> >>>>>> Daraus muss man kein grosses Sekret machen.
+>>>>> >>>>>
+>>>>> >>>>> Und man braucht dafuer nicht unbedingt eine Sekretaerin.
+>>>> >>>>
+>>>> >>>> Ich wollte auch noch einen Witz bringen, aber er war zu schlaff.
+>>> >>>
+>>> >>> Um zum Ausgangspunkt zurueckzukommen: Haben die von Condomi nicht
+>>> >>> immer behauptet, sie seien so gut aufgestellt?
+>> >>
+>> >> Sie haben wohl was uebergezogen bekommen.
+> > 
+> > Was ist denn schlimm daran, wenn der Geschaeftsfuehrer von Condomi 
+> > bei einem geplanten Treffen nicht kommen kann?
+
+Der versetzte Partner koennte darob sehr wohl erregt sein.
+
+
+Ciao
+Toscha
+-- Wenn man immer nur kann wenn man soll, aber nie darf wenn man will, dann
+mag man auch nicht, wenn man muss. 
+
+-----------------------------------------------------------------------------
+
+
+
+Schmarrn oder nicht Schmarrn... (Ronda,  7. Apr 2008, 01:01:18):
+Message-ID: <47f315d8@news.uni-ulm.de>
+From: Volker Birk <bumens@dingens.org>
+Subject: Re: Pilotprojekt fuer biometrische Grenzkontrollen
+Newsgroups: de.org.ccc
+Date: 2 Apr 2008 07:12:56 +0100
+
+Dominic Valerie Casare <teardrug@arcor.de> wrote:
+> > Bundesregierung bewertet Pilotprojekt fuer biometrische
+> > Grenzkontrollen positiv
+
+Das war klar.
+
+Man beweist ihnen, dass die automatisierten Grenzkontrollen billig zu
+ueberwinden sind, und dann ist es "technisch machbar" und wird "positiv"
+bewertet.
+
+Bloss nicht zugeben, dass es Unfug ist.
+
+Demnaechst wird's da immer "klingeln" und Alarm wird ausgeloest, wenn
+einer von tausenden Wolfgang Schaeubles vorbeikommt ;-)
+
+Viele Gruesse,
+VB.
+
+-----------------------------------------------------------------------------
+
+
+
+40 oder 60 Grad? (Ronda,  7. Apr 2008, 01:02:36):
+From: Johannes <jodresselnospam@web.de>
+Newsgroups: de.alt.rec.digitalfotografie
+Subject: Re: (f) Wie gefaellt CF-Karten der Hauptwaschgang ?
+Date: Thu, 03 Apr 2008 09:37:45 +0200
+Message-ID: <ft22c2$9kh$1@online.de>
+
+Stefan Baum schrieb:
+> > Hallo Leute,
+> > 
+> > heute offenbarte mir meine Frau, das nun endlich auch meine Speicherkarten
+> > blitzblank waeren.
+> > Sie hat sie naemlich in der Waschmaschine gefunden.
+> > Bevor ich jetzt kleine Holzkreuzchen bastel und ein Eckchen im Garten
+> > aushebe, gibt es noch eine Chance, das man die weiter verwenden kann?
+
+Naja, Ehefrauen, die CF-Karten gewaschen haben, wuerde ich nicht weiter 
+verwenden. Ein Eckchen im Garten ist der rechte Weg, ich wuerde mich mit
+einem Holzkreuz begnuegen.
+
+> > Bin fuer eure Erfahrungen oder ergaenzende Wiederbelebungstipps dankbar.
+
+Es gibt genuegend neue Frauen, daher habe ich es nie mit Wiederbelebung 
+versucht!
+
+SCNR
+
+-----------------------------------------------------------------------------
+
+
+
+G*, bist Du das? (Ronda,  7. Apr 2008, 01:05:03):
+Newsgroups: de.comp.text.tex
+Subject: Re: Danke fuer den Fisch
+Date: Wed, 02 Apr 2008 14:49:40 +0200
+From: David Kastrup <dak@gnu.org>
+
+Ekkart Kleinod <eknews@web.de> writes:
+
+> > Ich halte naemlich dctt fuer eine der freundlichsten, hilfreichsten und
+> > lesbarsten Gruppen (und das sage ich nicht nur aus Einschleimerei).
+
+Mir fehlt halt momentan die Zeit.
+
+-----------------------------------------------------------------------------
+
+
+
+Trennblaetter in Fotoalben (Ronda,  7. Apr 2008, 01:07:09):
+From: gerrit.brodmann@gmx.de (Gerrit Brodmann)
+Newsgroups: de.rec.fotografie
+Subject: Re: Trennblaetter in Fotoalben
+Date: Tue, 01 Apr 2008 19:41:56 GMT
+Message-ID: <47f78f10.456045546@news.arcor.de>
+
+Tobias Meyer <usenet.okt2005@bf-vln.de> wrote:
+
+> >Hallo,
+> >
+> >in Fotoalben ist ja ueblicherweise ein Trennblatt zwischen den Seiten. Wozu
+> >ist das gut, und ist mit Problemen zu rechnen wenn man darauf verzichtet?
+
+Haengt von den Motiven ab. Wenn auf einem Bild ein maennliches Wesen
+ist, auf dem anderen ein weibliches der gleichen Gattung kann es ggfls
+spaeter Babyfotos geben, wenn Du sie aufeinander legst.
+
+Zwei Bilder von Fahrzeugen uebereinander kann zu teurem Blechschaden
+und Hochstufung der Versicherung fuehren.
+
+Wenn Du ein Bild von Dir und einer Sahnetorte auf den
+gegenueberliegenden Bildern hast, wirst Du auf dem naechsten Bild dicker
+aussehen. Auch solltest Du die Bilder Deiner Katze udn die von den
+Goldfischen nicht auf den gegenueberliegenden Seiten ohne Trennblatt
+lagern...
+
+-----------------------------------------------------------------------------
+
+
+
+Geldautomatenpingeschichten (Ronda,  7. Apr 2008, 01:11:20):
+Hat noch jemand nette Geschichten dazu?
+
+Ronda *erinnert sich mit Grinsen an den bloeden Geldautomaten in Frankreich,
+der meine EC-Karte entwertet hat. Warum waren sich auch Zugangscode zum
+Rechnerraum und EC-PIN so aehnlich. Bloederweise hat die Rechnerraumtuer aber
+auch kein Geld rausgegeben.*
+
+From: Jan van Beers <tnp@gmx.ch>
+Newsgroups: de.etc.bahn.misc
+Subject: Re: [OT]Simple Passwoerter, was: Amokfahrten
+Date: Mon, 31 Mar 2008 17:47:17 +0200
+Message-ID: <sj12v3d3hl7f0k1js8distoo646hr4a9vg@4ax.com>
+
+Christoph Zimmermann <1753@ch-zimmermann.de> wrote:
+> >Michael Platen schrieb:
+>> >> Geldautomaten 
+> >
+> >und ich hatte mal eine Karte, die genau das als PIN hatte, die 
+> >Vorgaengerkarte dazu 8-8-9-9...
+
+*g*
+hatte mal 1141 als PIN. Normalerweise harmlos, aber ich bin mal mit
+dem Mopped tanken gewesen, drueck dem Maedel hinter der Theke meine
+Karte in die hand, sie legt die ein und sagt "11 41".
+Ich: WAAAAASS!??!1!elf!!
+Sie: hatten sie nicht Sauele 3?
+
+Mann, das wirkte schneller als jeder Kaffee...
+
+> >Gruesse
+> >
+> >-chriz
+Cu
+Jan
+
+-----------------------------------------------------------------------------
+
+
+
+Pippi Langstrumpf (Ronda,  7. Apr 2008, 01:15:43):
+Weblink: http://www.heise.de/tp/foren/S-Pippi-Langstrumpf-als-Neoliberale/foru
+m-134692/msg-14655925/read/
+
+[ SN: Quoting zum besseren Verstaendnis von Hand ergaenzt. ]
+
+29. Maerz 2008 13:40 
+Pippi Langstrumpf als Neoliberale 
+archenoe (763 Beitraege seit 05.02.04)  
+
+PippiLangstrumpf schrieb am 29. Maerz 2008 13:24
+> > Faulenzer schrieb am 29. Maerz 2008 5:26
+>> > > ...etliche Banken koennen nur noch mit staatlicher Hilfe am Leben
+>> > > gehalten werden.
+>> > >
+>> > > Hilft der Staat nicht, dann Bankrun !
+> > Na und? Pleiten gehoeren dazu und sind sogar volkswirtschaftlich
+> > foerderlich, weil unproduktive Unternehmen dadurch aussortiert werden.
+> > Weshalb sollte fuer Banken nicht das gelten, was fuer jeden kleinen
+> > Mittelstaendler gilt? Ich halte das massive Eingreifen des Staats* fuer
+> > absolut kontraproduktiv.
+> >
+> > * Das gilt nicht fuer das Eingreifen der Zentralbanken, um die noetige
+> > Liquiditaet auf den Geldmaerkten sicherzustellen. Dieses Geld wird ja
+> > auch wieder zurueckgezahlt.
+
+Leg' Dir doch bitte einen anderen nick zu!
+
+Pippi Langstrumpf ist eine Mischung aus individuellem Anarchismus,
+sozialistischen Grunderkenntnissen, libertaerem Antiautoritarismus und
+Muessiggang auf der objektiven Grundlage eines durch (romantisierte)
+Piratenverbrechen zustandekommenen Reichtums.
+
+Und da kommst Du uns hier mit plumpester Herrschaftsideologie, indem
+Du das Ideal eines vollkommenen Marktes predigst, der nur ab und zu
+einige "faule Eier" aussortieren muesse.
+
+Schaeme Dich!
+
+-----------------------------------------------------------------------------
+
+
+
+"Animal pro"... ah ja (Ronda, 29. Apr 2008, 20:58:37):
+From: Oliver Jennrich <oliver.jennrich@gmx.net>
+Subject: Re: Aktueller Stand: Beutelloser Staubsauger?
+Newsgroups: de.etc.haushalt
+Date: Fri, 25 Apr 2008 23:55:54 +0200
+Message-ID: <a1fr6cttx91.fsf@ID-371.news.uni-berlin.de>
+
+Gabriele Conrad <nc-conradga@netcologne.de> writes:
+
+> > Peter Wenz wrote:
+> >
+>> >> Stefan Schaffner schrieb:
+>>> >>> Ich frage mich nun aber, warum man den DC 20 "Animal Pro" nennt. Ist
+>>> >>> das dann der noch am ehesten fuer Tierhaare geeignete Dysen oder hat
+>>> >>> er auch Vorteile gegenueber einem Beutelsauger in Bezug auf Tierhaare?
+>> >>
+>> >> Der kann einen ganzen Eisbaer wegsaugen.
+> >
+> > Das ist eine Verschmutzung, die in meiner Wohnung eher selten auftritt.
+
+Kannste mal sehen, wie gut der Sauger ist.
+
+-----------------------------------------------------------------------------
+
+
+
+Nicht nur fuer Moppedfahrer (Ronda, 29. Apr 2008, 20:59:13):
+Newsgroups: de.rec.motorrad
+Subject: Re: LED Leuchtmittel besser geworden?
+From: Volker Bartheld <dr_versaeg@freenet.de>
+Date: Wed, 23 Apr 2008 10:08:34 +0200
+Message-ID: <fqsu63s48t7l$.1eo1ih9hme8et.dlg@40tude.net>
+
+Moin!
+
+>> >> Mir gehen diese Idiotenlampen auch auf den Sack. Nachdem man nun schon
+>> >> von vielen Autos mit den deppaten Xenon-Lampen von hinten genervt
+>> >> wird
+
+> > Falls nur ein Brenner zu sehen ist, ist die Dose kaputt oder Du hast
+> > 'ne BMW hinter dir....
+
+Aprospos Brenner: Neulich habe ich bei einem Daimler gesehen, dass sich
+offenbar die einzelnen Nebelscheinwerfer abhaengig vom Lenkwinkel zu- oder
+abschalteten. So eine Art "Nebelkurvenlicht fuer Arme" quasi. Natuerlich
+kein Xenon aber bussifein und premiummaessig PWM-geregelt soft auf- und
+abgeblendet.
+
+Sicher gibts dafuer wieder eine tolle Marketingaussage, ich koennte
+jedenfalls regelmaessig kotzen bei dem hirnverbrannten Unfug, der in die
+Dosen reingebastelt wird.
+
+Meine Top-10 der unverzichtbaren Extras waere:
+
+1) Drosselung auf 60km/h wenn die Nebelschlussleuchte brennt.
+2) Bremslichter gehen nach 4s Dauerbetrieb automatisch aus.
+3) Warnblinklicht >1 Min. bei geparkter Dose verstaendigt automatisch via 
+   GPS/GSM den Abschleppwagen - schliesslich muss ein Defekt vorliegen.
+4) Hupkonto: Wer - dank Kopplung von GPS/Navi und Steuerungsgeraet im 
+   Lenkrad - innerhalb geschlossener Ortschaften pro Monat haeufiger als 5x 
+   hupt, muss sich die Funktion durch Verkehrsunterricht wieder 
+   freischalten lassen.
+5) Handybetrieb und Motorstopp: Laeuft ein nicht angemeldetes Handy ohne
+   Freisprech im Auto, geht der Motor aus. Das darf gerne auch den    
+   Beifahrer betreffen, der soll gefaelligst ebenfalls den Schnabel halten.
+6) Motorleistungsabo: Wer staendig ABS/ESP/BASt & Co bemueht, kann offenbar 
+   nicht mit der vollen Motorleistung umgehen und wird erstmal auf 75PS 
+   zurueckgestuft. Schont ueberdies die Umwelt. Weiter bei 4).
+7) Linksblinken und Tempi >150km/h: Passiert beides ueber eine Dauer von 
+   mehr als 60 Sekunden, ist der Fahrer offenbar mit den vielen 
+   Bedienungselementen ueberfordert und wird auf 130km/h eingebremst. 
+   Weiter bei 4).
+8) Autobahnschleicher: Erkennt das GPS/Navi Autobahnbetrieb, der 
+   Abstandswarner gruenes Licht und trotzdem langandauernde 
+   Sub-Richtgeschwindigkeit, wird beim naechsten Routing "ohne Autobahn" 
+   als Default angenommen. Weiter bei 4).
+9) Platte Reifen und andere technische Defekte: Dank Reifendrucksensor, 
+   Lichtsteuergeraet, Smogchip und Co startet die Premiumkarre gar nicht 
+   erst anstatt zur rollenden Wanderduene zu werden. Weiter bei 4).
+
+Last but not least und und wieder mehr motorradrelevant:
+
+10) Inverses Motorrad-Sentinel: Durch Annaeherungssensorik und RFID werden
+    Dosentreiber aus ihrem Mittagsschlaefchen gerissen, *bevor* sie einen   
+    Motorradfahrer umnieten koennen.
+
+Viele Gruesse,
+Volker
+
+-----------------------------------------------------------------------------
+
+
+
+Hessen sind so... (Ronda, 29. Apr 2008, 21:10:35):
+From:Guido Jurock <nntp@nurfuerspam.de>
+Subject: Re: Unwillkommenes Duzen
+Newsgroups: de.alt.soc.knigge
+Date: Sat, 19 Apr 2008 19:21:40 +0200
+Message-ID: <y0nnx925dfzl.1c5eify38a8mb$.dlg@40tude.net>
+
+Am Fri, 11 Apr 2008 13:18:39 +0200 schrieb Daniel Kruge:
+
+> > [...]
+> > 
+> > Ich habe bei fremden Menschen sehr oft beobachtet, dass sie mich ohne 
+> > bedenken duzen. [...]
+> > 
+> > Und wenn ja, was waere denn eine Empfehlenswerte Vorgehensweise, dem 
+> > Duzen Einhalt zu gebieten bzw. Duz-Situationen von Anfang an zu 
+> > vermeiden? Dabei wuerde ich am liebsten so Konfliktfrei wie moeglich 
+> > vorgehen, denn ich moechte mich mit niemandem anlegen, auch wenn ich von 
+> > dieser Respektlosigkeit mir gegenueber, nachvollziehbarer weise, nicht 
+> > unbedingt begeistert bin.
+
+Ich hatte vor einiger Zeit mal das Vergnuegen, folgendem Dialog in der
+Flughafenkantine in Frankfurt beizuwohnen:
+
+Handelnde Personen:
+
+- Ein tuerkischstaemmiger, ca. 20jaehriger Flughafenmitarbeiter
+- Ein hessischer, ca. 50jaehriger Koch
+- Ich
+
+ Kantinengast: "Gib mir ma Frrigadelle"
+ 
+ Koch (guckt ueber seine Brille): "Kenne mer uns?"
+ 
+ Gast: "Hae?"
+ 
+ Koch: "Ei, simmerma zusamme in de Kinnergadde gegange?"
+ 
+ Gast: "Haeae?"
+ 
+ Koch "Odder simmer wenigstensema im Bahnhofvieddel de Trepp 
+ runnergefalle?"
+ 
+ Gast: "Haeaeae?"
+ 
+ Koch (faengt an Frikadellen und Sosse auf den Teller zu schaufeln): "Ne, is 
+ scho gut. Isch hatt gedacht, Sie haedde misch geduzt..."
+ 
+ Gast (hektisch): Ne, Ne! Da muessen Sie sich verhoert haben!"
+ 
+ Koch (reicht den Teller rueber) "Ahso. Dann isja gut."
+ 
+ (Abgang Gast)
+ 
+ Koch (zu mir): "Bidde?"
+ 
+ Ich: "Gebbe Sie mir doch bidde auch zwei so Bremsbacke."
+ 
+ Koch (guckt wieder ueber seine Brille): "Sie habbe ja gaaar ka 
+ Verschtaendnis fuer Teschnik, junger Mann. Dess sinn Kupplungsscheiben." 
+
+ (reicht den Teller rueber, Abgang ich)
+ 
+ (5 Meter weiter, Gast unterhaelt sich mit Arbeitskollegen)
+ 
+ Gast: "Ey, hassu gehoert? Was Arschloch!"
+
+Zugegeben: Konfliktfrei kann man das nicht unbedingt nennen. Aber fuer
+die eher unangenehmen oder penetranten Zeitgenossen ueberlegenswert.
+Evtl. Dialekt anpassen oder weglassen.
+
+-----------------------------------------------------------------------------
+
+
+
+Terrorverdacht! (Ronda, 29. Apr 2008, 21:10:57):
+From: Francis Debord <zodiac4@arcor.de>
+Date: 18 Apr 2008 07:21:17 GMT
+Subject: Re: Anmeldezeiten
+Newsgroups: alt.linux.suse
+Message-ID: <48084bed$0$23699$9b4e6d93@newsspool2.arcor-online.net>
+
+
+[ SN: Quoting hinzugefuegt ]
+
+
+On Fri, 18 Apr 2008, Monika Gutbrodt wrote:
+> >
+> > Hallo,
+> > kann man die Zeiten einschraenken, zu denen sich einzelne Benutzer
+> > anmelden duerfen? Falls ja: wie und wo?
+
+
+Nicht Antworten!
+
+Die Frau will nur ihre Kinder terrorisieren!
+
+-----------------------------------------------------------------------------
+
+
+
+Medicus und die Schnittchen (Ronda, 29. Apr 2008, 21:11:31):
+From: Arnim Sommer <usenet@ranthoron.de>
+Newsgroups: de.alt.sysadmin.recovery
+Subject: Re: OT: Samba SuSE-Linux 7.1
+Date: Sun, 13 Apr 2008 13:13:44 +0200
+Message-ID: <66e878F2jjsu7U3@mid.individual.net>
+
+Dieter Bruegmann schrieb:
+[Butter]
+> > Zwanzig Leute einladen und Schnittchen machen?
+> > 
+Im "Medicus" wird eine Anwendung  la "Zwanzig Schnittchen einladen und Leute
+machen" beschrieben...
+
+A!S
+
+-----------------------------------------------------------------------------
+
+
+
+Werbung fuers Final Frontier (Ronda, 29. Apr 2008, 21:12:17):
+Message-ID: <ftksl0$ebm$1@finalfrontier.mud.de>
+From: "Gynite@FF" <horizontalpunk@arcor.de>
+Newsgroups: de.alt.mud
+Subject: Re: Call for Papers ...
+Date: 10 Apr 2008 13:11:27 +0200
+
+Mario Donick wrote:
+> > Insbesondere koennten aktive MUD-Spieler, die gleichzeitig
+> > wissenschaftlich taetig sind, eine Bereicherung sein, weil sie beide
+> > Seiten kennen und nicht nur abstrakt daherreden wuerden von etwas, von
+> > dem sie keine oder nur minimale Ahnung haben. Es gibt (neben guten
+> > Arbeiten) viel zu viele Texte, denen man anmerkt, dass der Autor nie
+> > selbst mehr als nur ein paar Probe-Sessions in einem MUD aktiv war.
+
+Gute Nachricht: Im Final Frontier koennen ab sofort interessierte
+Wissenschaftler zu Studienzwecken einen *kostenlosen* Account erhalten!
+Einfach 'telnet ff.mud.de' auf der Konsole eingeben und mit beliebigen Namen
+einloggen. Wie gesagt, das Angebot steht Euch kostenlos und 24/7 zur
+Verfuegung! ;-)
+
+*G*ynite@FF (bringt Opfer fuer die Wissenschaft)
+
+-----------------------------------------------------------------------------
+
+
+
+Internet Tubes (Ronda, 29. Apr 2008, 21:13:58):
+From: XxXxX@bt.com
+To:   mailing@list
+Subject: Re: Internet Reachability
+Date: Thu, 10 Apr 2008 22:00:24 +0100
+
+> >Anyone noticing any issues reaching sites through their "Internet tubes"?  
+ 
+It seems that a Chinese ping-pong ball factory recently started making
+balls that are slightly larger than the standard size. As a result, ISPs
+whose tubes are newer, are suffering from pneumatic congestion, kind of
+like pneumonia if you know what I mean. This isn't affecting the larger
+ISPs since their tubes are older, and have higher traffic levels. The
+increased wear on these high-traffic tubes means that they are a
+slightly larger diameter and the new balls fit through better. The FCC
+recommends ISPs affected by the flood of these Chinese ping-pong balls
+to increase air pressure on their tubes to compensate, or to block
+Chinese traffic from entering their networks.
+
+-----------------------------------------------------------------------------
+
+
+
+Aliens auf dem Mars (Ronda, 29. Apr 2008, 21:14:56):
+From: Lothar Frings <da_lodda@gmx.de>
+Newsgroups: de.etc.sprache.deutsch
+Subject: Re: Der Lerner, der Beginner und der Student
+Date: Tue, 8 Apr 2008 08:59:35 -0700 (PDT)
+Message-ID:
+<d2601e47-29d1-43eb-acca-c08cb3981669@k13g2000hse.googlegroups.com>
+
+Christina Kunze tat kund
+
+> > Nam quod Mars aliis, dat tibi regna Venus?
+
+Die Aliens sind auf dem Mars, weil es auf
+der Venus regnet? Clever, die gruenen Kerlchen.
+
+-----------------------------------------------------------------------------
+
+
+
+Anwesende Anwaelte / Anwaeltinnen bitte weglesen (Ronda,  1. Mai 2008, 14:23:25):
+From: Dominic Valerie Casare <teardrug@arcor.de>
+Newsgroups: de.org.ccc
+Subject: Re: Schaeuble (wiedermal)
+Date: Mon, 28 Apr 2008 19:14:46 +0200
+Message-ID: <Pine.LNX.4.64.0804281904210.4792@neuromancer.neuromatrix>
+
+On Mon, 28 Apr 2008, Daniel Cornel wrote:
+> > Heiko Kuerschner schrieb:
+>> > > Dominic Valerie Casare schrieb:
+>>> > >> Was wir dringend brauchen, ist eine Moeglichkeit, eine
+>>> > >> Regierung per Volksentscheid vorzeitig aus dem Amt zu jagen, wenn die
+so
+>>> > >> arg danebenhaut, wie die grosse Koalition. So eine Art
+Misstrauensantrag
+>>> > >> im Namen des Volkes...
+>> > > Full ACK
+> > So eine absurde Idee, wo kaemen wir denn da hin, wenn das Volk ueber die
+> > eigene Politik entscheiden wuerde?
+
+Alternativ koennte man vllt auch eine Aenderung im GG anregen, die 
+beinhaltet, dass /Anwaelte/ prinzipiell nicht mehr als Abgeordnete 
+kandidieren duerfen, weil das ja von Berufswegen schon *kaeufliche* 
+*Vertreter* nahezu beliebiger Interessen sind und damit untauglich als 
+einfacher Vertreter des Volkes an sich. Der Verdacht liegt nahe, dass 
+diese Spezies schon aus /Gewohnheit/ ihr persoenliches Engagement von 
+dem zu erwartenden Honorar abhaengig macht und da... <Ey Finger weg! 
+Lasstmichlossihr...arrrghnmgnmmmhmmm>
+
+-----------------------------------------------------------------------------
+
+
+
+Linksdrehendes gewaltfrei gemahlenes Mehl (Ronda, 11. Mai 2008, 21:12:55):
+[SN: Quoting ergaenzt]
+
+From: "Thomas Friedrich" <spameater1234@hotmail.com>
+Subject: Re: Wallraff in Lidl-Broetchenfabrik - Discounter sind der
+letzte Abschaum
+Newsgroups: de.alt.fan.aldi
+Date: Mon, 5 May 2008 21:09:18 +0100
+Message-ID: <SPJTj.25307$j7.467330@news.indigo.ie>
+
+
+"Ralf Schmode" <rschmode@gmx.net> schrieb im Newsbeitrag 
+news:fvnn91$hi7$03$1@news.t-online.com...
+
+> >Ralf Wenzel schrieb:
+> >
+>> >>On 5 Mai, 19:52, Hannelore Goos <BenutzeFormu...@meineWebsite.unten>
+>> >>wrote:
+>>> >>>Nein. Bereits im Jahr 2000 ist im "Lexikon der populaeren
+>>> >>>Ernaehrungsirrtuemer" ausfuehrlich beschrieben, warum Industriebrot
+gesuender
+>>> >>>ist als durchschnittliches Baeckerbrot. Der Leiter des Europaeischen
+>>> >>>Instituts fuer Lebensmittel- und Ernaehrungswissenschaften sollte es
+wohl
+>>> >>>wissen.
+>> >>
+>> >>Ja, und Legehennen sind in Legebatterien nachweislich gesuender als in
+>> >>der Freilandhaltung. Trotzdem wuerde ich kotzen, wuerde ich wissentlich
+>> >>ein Batterie-Ei essen muessen.
+> >
+> >Man soll also deshalb kein Discounterbrot essen, weil es nicht artgerecht 
+> >gebacken wurde?
+
+Jein. Nur wenn das dazugehoerige linksdrehende Mehl gewaltfrei gemahlen 
+wurde. 
+
+-----------------------------------------------------------------------------
+
+
+
+Nichtraucherbecken?! Ich will Fotos sehen! (Ronda, 11. Mai 2008, 21:14:39):
+Subject: Re: Jedem das Seine
+From: Detlef Sax <b46@noart.de>
+Date: Sun, 4 May 2008 09:36:21 +0000 (UTC)
+Message-ID: <slrng1r186.c2.b46@zottel2.noart.de>
+Newsgroups: de.talk.jokes
+
+On Sun, 04 May 2008 10:47:43 +0200, HaJo Hachtkemper wrote:
+[...]
+> > Kein Witz: Hat schon mal jemand genauso fassungslos wie ich im Freibad
+> > in Oeynhausen vor dem Nichtraucherbecken gestanden?
+
+send pics.
+Ernsthaft, schick das an die Titanic oder biete das sonstwo an.
+
+Manchmal bekommt man ja den Eindruck das die ganze Welt total
+durchgeknallt ist und man der einzige Nichtdurchgeknallte ist.
+Stimmt natuerlich nicht. kann ja nicht stimmen, weil es nicht stimmen
+darf.
+Aber wenn das was du da oben geschrieben hast wahr ist, wird
+unsereiner schon wieder in diesem Gedanken bestaerkt.
+
+Vielleicht sollten wir anfangen Schilder zu drucken und diese heimlich
+an Gebaeuden anbringen.
+
+Vorschlaege, bitte um Ergaenzung:
+Nichtraucherpolizei, 14. Revier
+Nichtraucherfinanzamt
+Nichtrauchervollzugsanstalt
+Nichtraucherfriedhof
+Nichtraucherstrasse
+
+Im Krankenhaus, Neugeborenenstation:
+Nur fuer neugeborene Nichtraucher
+
+Nichtraucherbaum, das bepinkeln dieses Baumes mit Zigarette im Mund
+wird mit 40 Ocken bestraft
+
+Oder im Supermarkt:
+Nichtraucherschampoo
+Nichtraucherjoghurt, rechtsdrehend.
+Spaghetti nach Nichtraucherart
+
+Filmplakat:
+Ausgezeichnet mit dem Nichtraucherpreis 2008
+
+Taetowieren koennen wir auch:
+Rumbalotte
+[.. Hier bitte erschwaenzen ..]
+
+D.
+
+-----------------------------------------------------------------------------
+
+
+
+Bitte nicht weglaufen! (Ronda, 11. Mai 2008, 21:15:11):
+From: Marcus Siegl <Marcus.Siegl@web.de>
+Newsgroups: de.comp.os.unix.linux.misc
+Subject: Re: Fundsache
+Date: Mon, 05 May 2008 11:59:56 +0200
+Message-ID: <fvmlqu$7ac$1@news.belwue.de>
+
+Hi Norbert
+
+> > im Heftchen zur Treiberinstallation meiner S-ATA-Karte findet man die
+> > Anleitung:
+> > 
+> > "Das Linux-System starten und als Wurzel anmelden..."
+
+Das erinnert mich an die "Muschelflucht-Zusatzeinrichtung" (Shell escape 
+feature) eines Programms und eine Anzeige an einem Computer: "bitte 
+nicht weglaufen" (Please stand by)
+
+Bye
+
+-----------------------------------------------------------------------------
+
+
+
+Raucherabteil, bitte hier nicht atmen (Ronda, 11. Mai 2008, 21:16:54):
+From: Lajos Kuljo <kuljo01@yahoo.com>
+Newsgroups: de.talk.jokes
+Subject: Jedem das Seine
+Message-ID: <fvg0q8$kmc$1@magma.woody.ch>
+
+Die Aufteilung der Kneipen in Raucher- und Nichtraucherabteile ist ja 
+so, als man die Schwimmbecken in Hineinpinkeln- und 
+Nichthineinpinkelnhaelften teilen wuerde.
+
+-----------------------------------------------------------------------------
+
+
+
+Denkfehler (Ronda, 11. Mai 2008, 21:18:06):
+Oder: Wie viel Suppe kann man aus einer Galapagos-Schildkroete machen?
+
+Ronda
+
+Subject: Re: Tchibo-LaserPointer ...
+From: Ralf Muschall <ralfmuschall@googlemail.com>
+Newsgroups: ger.ct
+Message-ID:
+<7040d986-11f2-47ac-988f-4677a3f696b6@e39g2000hsf.googlegroups.com>
+
+On Apr 30, 5:18 pm, "Matthias Eissing" <MEiss...@gmx.de> wrote:
+..
+> > Menschen, die Haustiere haben, leben nachweislich laenger, haben
+geringeres
+> > Herzinfarkt-Risiko und sind ausgeglichener.
+
+Das haengt stark von der Art ab. Besonders gut ist es, wenn man
+Galapagos-Schildkroeten ueber ihre gesamte Lebensdauer betreut.
+Noch niemand, der das perfekt geschafft hat, ist juenger als mit 300
+gestorben.
+
+Ralf
+
+-----------------------------------------------------------------------------
+
+
+
+"Der Rechner" oder "Die Anlage" (Ronda, 11. Mai 2008, 21:19:46):
+Der Link auf Wikipedia zu Mailuefterl ist auch nett.
+
+Ronda
+
+From: Dieter Bruegmann <08430173.1.didispandau@mycleaninbox.net>
+Subject: Re: Wie man es auch machen kann...
+Newsgroups: de.alt.sysadmin.recovery
+Date: Wed, 30 Apr 2008 17:03:12 +0200
+Message-ID: <fva8og.3e4.3@bruhaha.de>
+
+Stefan Froehlich (30 Apr 2008 14:03:19 GMT):
+
+>> >> Mein erster Chef hat die EDV im Lochkartenzeitalter ganz allein
+>> >> aufgebaut und konnte auch schoene Geschichten erzaehlen.
+> >
+> > Deswegen waren auch die Vorlesungen von Prof. Zemanek immer sehr
+> > beliebt. <http://de.wikipedia.org/wiki/Mail%C3%BCfterl> geht auf
+> > sein Konto, es gab da auch immer sehr nette Geschichten, besonders
+> > in "menschliche Aspekte des Computers". Haette ich mir eigentlich
+> > mehr davon anhoeren sollen...
+
+In einem meiner ersten Lehrgaenge hat der Dozent, ein ganz
+Altgedienter, auch etwas aus dem Naehkaestchen geplaudert. Man solle
+nicht "der Rechner", sondern lieber "die Anlage" sagen. Damit treffe
+man das Weiblich-Tueckische viel besser.
+
+
+Da Didi
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Bitte nicht weglaufen! (Vanion, 11. Mai 2008, 21:26:30):
+~#! rn=Ronda rt=1210533311 rg=schmarrn.netdigest
+~#! tid=1210533311
+Als Wurzel anmelden ... weia.
+
+V*
+
+-----------------------------------------------------------------------------
+
+
+
+Anarchistische CSU. Ah ja? (Ronda, 15. Mai 2008, 22:48:53):
+From: Wolfram Heinrich <info@theodor-rieh.de>
+Subject: Re: Jagdrecht
+Newsgroups: de.soc.recht.misc
+Date: Mon, 12 May 2008 10:31:36 +0200
+Message-ID: <1mj18z79ib32l$.dlg@www.theodor-rieh.de>
+
+Am Sun, 11 May 2008 19:52:16 +0200 schrieb Konrad Wilhelm:
+
+> > On Sun, 11 May 2008 18:16:59 +0200, gerd unverfehrt <gunverf@gwdg.de>
+> > wrote:
+> > 
+>> >>Wolfram Heinrich schrieb:
+>>> >>> Am Sun, 11 May 2008 13:04:44 +0200 schrieb Hannelore Goos:
+>>> >>> 
+>>>> >>>> Am Sun, 11 May 2008 10:06:43 +0200 schrieb Wolfram Heinrich:
+>>>> >>>>
+>>>>> >>>>> Hobbyjaeger, nicht die Foerster, mit denen habe ich nicht die
+geringsten
+>>>>> >>>>> Probleme). 
+>>>> >>>> Foerster sind Baumgaertner und haben mit dem Wildbestand nichts zu
+tun.
+>>> >>> 
+>>> >>> Der Foerster im Silberwald ist jedenfalls noch immer mit dem Gewehr
+ueber der
+>>> >>> Schulter rumgelaufen.
+>> >>
+>> >>Gewehre der Foerster in Heimatfilmen dienen nicht dazu, Wild 
+>> >>zu erschiessen, sondern Wilddiebe.
+>> >>
+> > Zumindest, wenn sie Ederlein heissen.
+> > 
+> > ("Es war ein Schuetz, 
+> > in seinen besten Jaharen
+> >  ...")
+> > 
+Jennerwein, nicht Ederlein. Man beachte an der Stelle, dass in bayerischer
+Folklore die Wilderer in aller Regel die Guten sind, die Jaeger/Foerster
+dagegen die Boesen. Das ist die anarchistische Ader im Bayern, die ihn auch
+CSU waehlen laesst. 
+
+Ciao
+Wolfram
+
+-----------------------------------------------------------------------------
+
+
+
+Verhaltensforschung an Ameisen. Oder: Die Hochebene lebt! (Ronda, 15. Mai 2008, 22:52:21):
+From: Dorothee Hermann <DorotheeHermann@gmx.net>
+Subject: Re: Ameisen toeten
+Newsgroups: de.etc.haushalt
+Date: Thu, 15 May 2008 20:27:00 +0200
+Message-ID: <693d9dF30f4ioU1@mid.individual.net>
+
+Jon J Panury schrieb:
+> > [... Ameisen in der Wohnung]
+> > Man nimmt sich die Zeit und toetet einige Ameisen, wie man sie zu
+> > fassen kriegt; und jetzt kommt's: Die Ameisenleichen *liegen lassen*!
+
+> > Man kann fast immer davon ausgehen, dass die Ameisen, die man
+> > _vereinzelt_ (zu wenigen) in der Wohnzng antrifft, so'ne Art
+> > "Kundschafter" sind. Wenn die nicht zurueck kommen, oder wenn
+> > nachfolgende Tiere die Vorgeschickten tot rumliegen bemerken (und die
+> > *merken* das!), werden sie verstehen, dass hier nicht gut krabbeln ist
+> > - und weg bleiben. 
+
+Freud fuer Ameisen? ;-)
+Ich hab eher die Erfahrung "es kommt die ganze Familie zur Beerdigung 
+und sie feiern tagelang" gemacht!
+
+
+Dorothee
+
+-----------------------------------------------------------------------------
+
+
+
+Computer. Auf bayerisch. (Ronda, 21. Mai 2008, 23:40:52):
+From: Dieter Bruegmann <08516139.1.didispandau@spamgourmet.com>
+Subject: Re: Website
+Newsgroups: de.etc.sprache.deutsch
+Date: Fri, 16 May 2008 13:09:14 +0200
+Message-ID: <g0k11r.3ig.3@bruhaha.de>
+
+Gunhild Simon (Fri, 16 May 2008 00:38:06 -0700 (PDT)):
+
+> > Und den Computer nenne ich Rechner.
+
+Der Bayer nennt den Computer "Saupreiss, elegdronischer".
+
+
+Da Didi
+
+-----------------------------------------------------------------------------
+
+
+
+Fuer Lehrer und Lehrerinnen. (Ronda, 21. Mai 2008, 23:41:54):
+From: Reinhard Gonaus <reinhard@ibido.at>
+Subject: Re: Benachteiligung der Frau?
+Newsgroups: de.etc.sprache.deutsch
+Date: Mon, 19 May 2008 19:33:23 +0200
+Message-ID: <69drqbF322mqiU1@mid.individual.net>
+
+>> >> Vor einer Weile hoerte ich mal einen lustig klingenden 
+>> >> Ausdruck fuer "Unterricht, bei dem der Lehrer den Schuelern 
+>> >> immer gerade mal eine Unterrichtsstunde voraus ist". Wie 
+>> >> koennte das geheissen haben?
+
+> > Schwellendidaktik ist zumindest verwandt: Der Lehrer weiss erst an der 
+> > Schwelle des Klassenzimmers, was er in der jeweiligen Stunde machen 
+> > wird.
+
+Es gibt:
+
+den Autodidaktiker: Er beginnt die Unterrichtsplanung, wenn er morgens 
+ins Auto steigt.
+
+den Schwellendidaktiker: s.o.
+
+den Hammerdidaktiker: Er betritt die Klasse, schlaegt das Klassenbuch auf und
+fragt: "Was hammer denn gestern g'macht?"
+
+-----------------------------------------------------------------------------
+
+
+
+Zukunft ist auch nicht mehr das was sie mal war (Ronda, 21. Mai 2008, 23:43:00):
+Subject: Re: Website
+From: Andreas Hoefeld <me@privacy.net>
+Date: Fri, 16 May 2008 23:25:52 +0200
+Message-ID: <482dfbdd$0$6517$9b4e6d93@newsspool4.arcor-online.net>
+Newsgroups: de.etc.sprache.deutsch
+
+Nachricht von Dieter Bruegmann:
+> > Daniela Duerbeck (Fri, 16 May 2008 00:53:48 +0200):
+> > 
+>> > > Oliver Cromm wrote:
+>> > >
+>>> > >> Ich fuerchte, das funktioniert im Deutschen nicht, da ist ein Logbuch
+ein
+>>> > >> zu exotischer Gegenstand. Ich sage auch "der Blog", das habe ich
+>> > > Aber wir sind doch alle aufgewachsen mit: "Computer-Logbuch Nummer xxx
+>> > > der Enterprise, Sternzeit ..., Captain Kirk"
+> > 
+> > Weshalb musste man in der Zukunft eigentlich immer die aktuelle Zeit
+> > mit aufsprechen?
+
+In den 60er Jahren war die Zukunft noch nicht so weit entwickelt.
+
+-----------------------------------------------------------------------------
+
+
+
+Die Wahrheit ueber die Packstation (Ronda, 21. Mai 2008, 23:44:20):
+From: Jens Mueller <usenet-11-2007@tessarakt.de>
+Subject: Re: Karte von der Packstation
+Newsgroups: de.etc.post
+Date: Thu, 15 May 2008 13:40:18 +0200
+
+Christian Mueller schrieb:
+> > Marion Scheffels schrieb:
+
+>> >> Nein, ich denke, da ganze Design der Karte ist nur Marketing.
+
+> > Ah, ich hatte schon die Befuerchtung, in der hochmodernen
+> > Packstation saessen eingesperrt DHL-Azubi und wuerde manuell die
+> > Pakete raussuchen und schriftlich aus einer Liste austragen.
+> > Damit das bei schwierigen Kunden-Namen einfacher geht, hat man
+> > ihnen alte KK-RitschRatsch zur Verfuegung gestellt.
+
+Ah, ich dachte erst, damit das im Dunkeln einfacher geht, ist der 
+Schriftzug gepraegt.
+
+-----------------------------------------------------------------------------
+
+
+
+Fuer Sight-City Fans (Ronda, 21. Mai 2008, 23:45:15):
+From: Birgit Nietsch <birgit-nietsch@gmx.de>
+Newsgroups: de.alt.sysadmin.recovery
+Subject: Re: Brauchbare Workstation fuer unsereins?
+Date: Thu, 15 May 2008 13:40:54 +0200
+Message-ID: <692lqmF301pkuU2@mid.individual.net>
+
+Christoph Schmitz schrieb:
+
+> > Lutz Donnerhacke schrieb:
+>> >> 
+>> >> Stimmt, das sind die besten Beifahrer: "Links, links, da links"
+>> >> 
+>> >> "hab ich mal gearbeitet."
+> > 
+> > "Kommt von rechts ein Auto?" - "Nein"...
+> > 
+> > ... "nur eine Strassenbahn."
+> > 
+> > Ok, *solche* Beifahrer darwinisieren sich schnell weg.
+
+F: "Na, wird's hier bald mal frei?!" 
+B: "Also hier rechts seh ich nichts."
+F: *gasgeb* - *STUTZ!* - *BREMMMMMMMMS!!!*
+
+Ein Fall aus dem Bekanntenkreis. Der Beifahrer ist blind.
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Fuer Sight-City Fans (Grimmborn, 22. Mai 2008, 00:44:07):
+~#! rn=Ronda rt=1211406315 rg=schmarrn.netdigest
+~#! tid=1211406315
+"Von rechts ein Smart und von links auch frei." 
+
+GdA
+
+-----------------------------------------------------------------------------
+
+
+
+Schadenfreude? (Ronda,  4. Jun 2008, 22:08:16):
+Message-ID: <2f633692-bfb4-4f3b-91df-3c71f00e726c@79g2000hsk.googlegroups.com>
+From: Erwin Schlonz <schlonz.2.erwin@spamgourmet.com>
+Newsgroups: de.alt.talk.unmut
+Subject: Re: Der Sommer ist da...
+Date: Mon, 2 Jun 2008 02:46:51 -0700 (PDT)
+
+On 1 Jun., 23:12, "Norbert R." <m...@norbert-raps.de> wrote:
+> > ... aber nicht nur mit der erwachenden und bluehenden Natur und
+> > angenehmer Waerme, sondern auch mit Cabrio-Fahrern, die jetzt tagsueber
+> > und nachts jederzeit lautstark zeigen muessen, was sie fuer ein tolles
+> > Auto und fuer 'ne tolle Musik an Bord haben! Leider will aber kaum jemand
+> > auf der Strasse in deren Umgebung diesen ach so tollen Sound hoeren!
+> > Irgendwie bloed, oder?
+
+Dieser Unmut wird durch eine ganz bestimmte Schadenfreude mehr als
+kompensiert.
+
+Nie werde ich die Durchsage im hiesigen Einkaufszentrum vergessen:
+
+"Eine Information fuer unsere Cabrio-Fahrer:
+ .
+ .
+ .
+ Es regnet."
+
+Erwin Schlonz
+
+-----------------------------------------------------------------------------
+
+
+
+Indiana Jones (Ronda,  4. Jun 2008, 22:09:50):
+Erinnert mich irgendwie an die Beschwerde einer Freundin, der damals aktuelle
+James Bond waere so furchtbar unrealistisch, der davor waere VIEL besser
+gewesen. Hinweis: Der davor war der, bei dem er mit einem Motorrad neben einem
+Flugzeug runterspringt und dann ins Flugzeug klettert. No further comment.
+
+Ronda
+
+Message-ID: <g1fe8v$5b22@cobis.msgid.de>
+From: Cornell Binder <cobi@dafhs.org>
+Newsgroups: de.rec.film.misc
+Subject: Re: Indiana Jones sehr unterhaltsam
+Date: 26 May 2008 22:40:31 GMT
+
+Sepp Neuper <Sepp_Neuper@web.de> tat schreiben tun:
+> > Cdric Menge <CRMenge@web.de> schrieb:
+> > 
+>> >>Noe, er hat das Siegel im Tempel doch wieder ueberschritten. Das war IIRC
+>> >>nicht nur die Grenze fuer den Gral, sondern auch fuer dessen Wirkung.
+> > 
+> > Was soll denn das fuer einen Sinn haben?
+
+Was fuer eine merkwuerdige Frage, wenn es um Indiana Jones geht.
+
+
+CoBi
+
+-----------------------------------------------------------------------------
+
+
+
+Freiwillig vertreten oder wie? (Ronda,  4. Jun 2008, 22:10:26):
+From: Bernhard Muenzer <bmuenzer@yahoo.com>
+Subject: Re: Bordsteinschwalbe
+Newsgroups: de.etc.beruf.selbstaendig
+Date: 16 May 2008 22:29:28 +0200
+Message-ID: <tzgyj8lz.fsf@yahoo.com>
+
+Will Berghoff <real_nospam@berghoffs.de> writes:
+> > Zumindest die Pflichtmitgliedschaft in der IHK ist hier in Luebeck
+> > nachweislich gegeben. In der Vollversammlung ist das Gewerbe aber nur
+> > indirekt vertreten.
+
+Meinst Du damit, dass sich die Prostituierten in der IHK-Vollversammlung
+durch ihre Freier vertreten lassen?
+
+-----------------------------------------------------------------------------
+
+
+
+Das ist doch mal pragmatisch (Ronda,  4. Jun 2008, 22:10:55):
+From: Martin Heening <martin5667@web.de>
+Newsgroups: de.rec.sport.fussball
+Subject: Re: Hamburg im UEFA Cup ...
+Date: Wed, 21 May 2008 11:26:50 +0200
+Message-ID: <g10psr$la2$02$1@news.t-online.com>
+
+Hannes Gnad schrieb:
+> > Juergen Gerkens <Gerkens@nurfuerspam.de> wrote:
+>> >> Beim VFB zappelte das Netz uebrigens auch oefter als bei allen
+Absteigern.
+> > Ja, wissen wir alles. Und wir werden handeln.
+
+Die Netze einfach in der Nacht vor dem Heimspiel rausschneiden?
+
+SCNR,
+Martin
+
+-----------------------------------------------------------------------------
+
+
+
+Brrr... (Ronda,  4. Jun 2008, 22:11:17):
+From: Lothar Kimmeringer <news200709@kimmeringer.de>
+Subject: Re: Lidl Chef-Koch fuer Spaghetti Bolognese rausgeflogen??
+Newsgroups: de.alt.fan.aldi
+Date: Tue, 3 Jun 2008 19:06:57 +0200
+Message-ID: <8vcp00kxtu00$.dlg@kimmeringer.de>
+
+Ulrich F. Heidenreich wrote:
+
+> >Fuer 1,29 als http://invalid.de/tetra-ei.jpg
+> >
+> >CU!
+> >Ulrich - Gerade in einem Anfall von Geldverschwendung 
+> >         rein zu Demonstrationszwecken zugegriffen habend.
+
+Fuer welche Zielgruppe das gedacht ist, duerfte einem spaetestens
+klar sein, wenn man die Zeichnung einer Pfanne neben der Ge-
+brauchsanweisung sieht, die wohl sicherstellen soll, dass die
+betreffende Person nicht versucht, die Pampe durch die Kaffee-
+maschine zu jagen, weil sie mit dem Begriff "Pfanne" nichts
+anzufangen weiss.
+
+
+Gruesse, Lothar
+
+-----------------------------------------------------------------------------
+
+
+
+Birken und Birken und Birken und... Birken. (Ronda,  8. Jun 2008, 19:43:38):
+Newsgroups: de.etc.bahn.misc
+Subject: Transib ;-) - war: Von Berlin ohne umsteigen zum Baikalsee
+From: Klaus Mueller <newsgro-reis@yahoo.de>
+Date: Sun, 01 Jun 2008 14:27:06 +0200
+Message-ID: <4842959e$0$27453$9b4e6d93@newsspool4.arcor-online.net>
+
+Ferdi Albers schrieb:
+
+>>> >>> Am Mittwoch dem 4.6. ist es erstmals so weit:
+>>> >>> Der direkte Schlafwagen Berlin - Irkutsk faehrt erstmals, Fahrzeit ist
+>>> >>> exakt
+>>> >>> 120 Stunden und 4 Minuten.
+>> >> Was kostet das so ungefaehr?
+> > 
+> > Normalpreis: 244,70
+> > + Schlafwagen
+
+Habe ich gerade gefunden (Autor unbekannt):
+
+Vor allem aber kriegen Sie Zeit geschenkt. Viel Zeit sogar. Zeit genug, 
+um zwei oder drei Romane zu lesen. Zeit genug, um nachzudenken und 
+stundenlang aus dem Fenster zu sehen und die voruebergleitende Landschaft 
+zu betrachten.
+
+Irgendwann ist es dann aber auch genug. Irgendwann will man einfach 
+keine Romane mehr lesen. Man will auch nicht mehr nachdenken. Irgendwann 
+faellt einem auf, dass es im Fenster immer das Gleiche zu sehen gibt, 
+naemlich Birken, Birken, Birken, Birken, Birken, Birken, Birken, Birken, 
+Birken, Birken, Birken, Birken, Birken, Birken, Birken, Birken, Birken, 
+Birken, Birken, Birken, Birken, Birken, Birken, Birken, Birken, Birken, 
+Birken, Birken, Birken. Manchmal gibt es auch ein Dorf oder ein Feld. 
+Dann aber sofort wieder Birken. Wenn man nicht gerade wie die Frau, mit 
+der ich mal von Novosibirsk nach Irkutsk gefahren bin, von Tajga bis 
+Zima, immerhin also 1400 Kilometer, benoetigt, um ein einziges (!) Raetsel 
+zu loesen, dann bemerkt man irgendwann folgendes: Es ist total 
+langweilig, so lange Zug zu fahren!
+
+Russen haben deshalb auch wenig Verstaendnis fuer die deutsche 
+Eisenbahnromantik. Dass jemand, der fuer das gleiche Geld nach Australien 
+fliegen koennte, freiwillig die ganze Strecke der Transsib abfaehrt, ist 
+fuer viele hier unbegreiflich. Ich glaube, keinem Russen fiele es ein, 
+sich sieben Tage in den Zug zu setzen, nur um dann wieder nach Hause 
+zurueckzufliegen. Doch natuerlich gibt es auch hier eine vernuenftige 
+Erklaerung. Wenn man in Deutschland auf die Strasse rausgeht, steht man 
+schon an der Grenze zu einem Nachbarland. Direkt vor der eigenen Haustuer 
+beginnt Daenemark und aus dem Hoffenster sieht man schon die 
+oesterreichischen und Schweizer Alpen. Deutsche freuen sich in den 
+russischen Zuegen darum einfach ueber die unglaubliche Tatsache, dass sie 
+jetzt schon fuenf Tage unterwegs und immer noch im gleichen Land sind. 
+Ein merkwuerdiges Vergnuegen, kann ja sein, aber versuchen Sie, meine 
+lieben Russen, nachsichtig zu sein, milde und verstaendnisvoll. Unter uns 
+gesagt, sie haben natuerlich Recht: Siebeneinhalb Tage mit dem Zug von 
+Moskau nach Wladiwostok zu fahren, um dann von dort aus nach Deutschland 
+zurueckzufliegen, ist tatsaechlich ein bisschen debil.
+
+-----------------------------------------------------------------------------
+
+
+
+.... hae?! (Ronda,  8. Jun 2008, 19:45:23):
+From: Ulrich Diez <eu_angelion@web.de.invalid>
+Newsgroups: de.soc.weltanschauung.christentum,de.talk.liebesakt
+Subject: Re: Sex vor der Ehe ist biblisch als Unzucht verurteilt
+Date: Fri, 6 Jun 2008 17:30:21 +0200
+Message-ID: <g2bl8h$4pa$00$1@news.t-online.com>
+
+schon.denise@gmail.com schrieb:
+
+> > Ich finde dich ein bisschen nett, wenn du nur kein "Fisch" bist.
+
+Das Lesen dieser Zeile hat einiges bei mir bewirkt. Viele
+Synapsen in meinem Oberschlundganglion haben
+unkontrolliert gefeuert.
+Ueberwaeltigende Gedanken stroemten deshalb auf mich ein
+und wollten mit meiner Weltsicht in Einklang gebracht
+werden.
+Aus dem neuronalen Gewitter in meinem Kopf wurde in
+atemberaubendem Tempo eine Art schwarzes Loch,
+welches immer mehr Ideen anzog.
+Der Kulminationspunkt dieser Entwicklung war eine Art
+mentale Detonation, ein Genieblitz, eine Gedankenexplosion,
+ein Fanal, gespeist aus der Frage aller Fragen: Hae?
+
+Ulrich
+
+-----------------------------------------------------------------------------
+
+
+
+Kevin (Ronda,  9. Jun 2008, 20:56:54):
+Also ich kenn einen, der ist schwer in Ordnung - der ist aber auch ein
+bisschen aelter als "Kevin allein zuhaus"...
+
+Ronda
+
+From: Ralf Kusmierz <me@privacy.invalid>
+Subject: Re: speditiv
+Newsgroups: de.etc.sprache.deutsch
+Date: Sun, 08 Jun 2008 04:11:23 +0200
+Message-ID: <g2ff4b$n81$1@online.de>
+
+...
+Kevin ist kein Name, sondern eine Diagnose.
+...
+
+-----------------------------------------------------------------------------
+
+
+
+Geh-Kaffee (Ronda,  9. Jun 2008, 20:58:58):
+From: spambin03_12@macpla.net (Matthias Damm)
+Subject: Re: Public Viewing
+Newsgroups: de.etc.sprache.deutsch
+Date: Sun, 8 Jun 2008 19:38:27 +0200
+Message-ID: <1ii8egr.106f5l1vt9wlcN@mid.macpla.net>
+
+> > "Suchwort im Mai: "Public Viewing"  wird wieder Tausende anziehen bei
+> > der Fussball-Europameisterschaft. Faellt Ihnen dafuer ein griffiges
+> > deutsches Wort ein? fragt die Aktion "Lebendiges Deutsch". 
+
+Ah, die Aktion, die einen neuen Ausdruck fuer "Coffee to Go" suchte und
+sich statt fuer "Kaffee zum Mitnehmen" fuer "Geh-Kaffee" entschied? Die
+Sprache, die solche Freunde hat, braucht keine Feinde mehr ...
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Kevin (Rumata,  9. Jun 2008, 21:00:39):
+~#! rn=Ronda rt=1213037814 rg=schmarrn.netdigest
+~#! tid=1213037814
+Als Alternativen zum Namen "Kevin" empfehle ich Cesius, Farenheit oder Reumur.
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Geh-Kaffee (Ronda,  9. Jun 2008, 21:01:59):
+~#! rn=Ronda rt=1213037938 rg=schmarrn.netdigest
+~#! tid=1213037938
+Mal ein Selbst-Reply: Ist eigentlich "Coffee to go" im Englischen korrekt? Die
+Tage im Burger King mehrfach mitbekommen (irgendwo im Badischen, des
+Englischen bedingt maechtige Bedienung): "Do you want that for getaway?"
+Irgendwie hat das was, mit dem Fluchtauto beim Burger King Kraefte zu
+sammeln...
+
+Ronda
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Geh-Kaffee (Rumata,  9. Jun 2008, 21:03:47):
+~#! rn=Ronda rt=1213038119 rg=schmarrn.netdigest
+~#! tid=1213037938
+Ausser in megaschmarrn ist selbstreply keine Suende.
+Zum Thema: "takeaway" waere jedenfalls richtiger gewesen. 
+
+-----------------------------------------------------------------------------
+
+
+
+Die Bahn braucht auch Kleingeld... (Ronda, 25. Jun 2008, 22:50:55):
+From: Fredy Barth <fbarth@spamfence.de>
+Subject: Re: Moderne Kids und die gute alte Zeit
+Newsgroups: de.etc.bahn.misc
+Date: Wed, 18 Jun 2008 20:00:20 +0200
+Message-ID: <6bt2loF3dcnbaU1@mid.individual.net>
+
+Frank Hucklenbroich schrieb:
+
+> > Wir haben (in den 70ern) auch Pfennige auf die Strassenbahnschienen gelegt
+> > damit sie plattgefahren wurden,
+
+Das hab ich in meiner Karriere nur ein einziges Mal erlebt.
+Aber von einem Kollegen hab ich erzaehlt bekommen, vor Jahren haetten
+Kinder vor seinen mit einer V100 bespannten Gueterzug Muenzen auf's Gleis
+gelegt. Er habe dann angehalten, sei rausgesprungen, habe das Geld
+eingesammelt und sei dann weitergefahren. Die Gesichter der Kids muessen ein
+Bild fuer die Goetter gewesen sein. :-)
+
+
+Pfueagott, Fredy
+-- "Ich gehe davon aus, dass die Bahn nicht grundsaetzlich bescheuert ist."
+Christian Lorch in de.etc.bahn.misc
+
+-----------------------------------------------------------------------------
+
+
+
+Monster-Ausflug... (Ronda, 25. Jun 2008, 22:52:12):
+... ist eine interessante Bezeichnung fuer eine Klassenfahrt...
+
+Ronda
+
+Date: Wed, 28 May 2008 19:41:10 +0200
+From: Helmut Barth <Helmut.Barth@arcor.de>
+Newsgroups: de.etc.bahn.misc
+Subject: Re: AW: Monster-Ausflug einer Schule
+Message-ID: <483d9937$0$6606$9b4e6d93@newsspool2.arcor-online.net>
+
+Salut!
+
+Jens Kaubisch schrieb:
+
+> > Nur mal zur Information, als ich noch zur Schule gingen, wurden wir 
+> > Schueler mit der Abwicklung der Klassenfahrt betraut. Vom Aussuchen des
+> > Ziels ueber das kassieren des Geldes bishin zum Fahrscheinkauf und 
+> > Gruppenbestellung und Erstellen von Infomaterial sowie Aktivitaeten vor
+> > Ort! Unser Klassenlehrer hat sich da nur wenig drum gekuemmert, er stand
+> > allenfalls beratetnd zur Seite. Das war 1987 eine 7. Klasse einer 
+> > polytechnischen Oberschule der DDR!
+
+Und? Was ist dabei rausgekommen? Muendige Buerger die ihre Regierung zum 
+Teufel und ihren Staat durch die Esse gejagt haben. Wer wird denn 
+ernsthaft so etwas wollen?
+
+Gruessle, Helmut
+
+-----------------------------------------------------------------------------
+
+
+
+Interviews (Ronda, 25. Jun 2008, 22:53:34):
+Message-ID: <6bk0nsF3a54sfU1@mid.individual.net>
+From: Falk Willberg <Faweglassenlk@falk-willberg.de>
+Newsgroups: de.alt.sysadmin.recovery
+Subject: Re: Wie man es auch machen kann...
+Date: Sun, 15 Jun 2008 10:04:07 +0200
+
+Martin Hotze schrieb:
+> > Stefan Froehlich schrieb:
+>> >> Wir _koennen_ zwar nicht Fussballspielen, aber wir _wuerden_ es gerne
+>> >> koennen. Ein subtiler Unterschied.
+> > 
+> > Ja, und man versucht mit "wir" alle kollektiv zu vereinnahmen.
+> > 
+>> >> Servus,
+>> >>    Stefan (Verweigerer Nr. 2)
+> > 
+> > Eine Suche nach "Verweigerer" bei ibaeaeh bringt meine Sicht der Dinge 
+> > auch recht klar zum Ausdruck. :-)
+
+Ich mag die EM: Die Interviews mit Ballack&Co. waren kaum zu verstehen, 
+  aber der kroatische Spieler sprach gutes Deutsch und ich konnte seinen 
+Ausfuehrungen sogar fast folgen ;-)
+
+Falk
+
+-----------------------------------------------------------------------------
+
+
+
+So ist das mit den Product-Bundles wirklich (Ronda, 25. Jun 2008, 22:54:38):
+From: Johann Mayerwieser <johann.mayerwieser@gmail.com>
+Subject: Re: Promotion-Packs?
+Newsgroups: de.alt.fan.aldi
+Date:Thu, 12 Jun 2008 17:39:39 +0200
+Message-ID: <gmg254llpgk6g359nbb0btjqhpi5k770ds@4ax.com>
+
+Joerg-Olaf Schaefers <olaf@usenet.fx3.org> wrote:
+
+> >Sven Boetcher wrote:
+>> >> Hallo Pfennigfuchser,
+>> >> 
+>> >> verschiedene Hersteller bieten ja immer sogenannte "Promotion Packs" 
+>> >> oder "CashBack"-Aktionen an. Habe sowas noch nie genutzt weil fuer mich 
+>> >> nie das passende dabei war.
+>> >> 
+>> >> Nun habe ich bei www.kodak.de den Fotodrucker "G610 gefunden". Den 
+>> >> moechte ich gerne haben und er soll 89 Euro kosten, gleich bei Kodak 
+>> >> bestellbar ab Werk. Zufaellig sehe ich auf der Seite, dass ich den 
+>> >> Drucker fuer 29 Euro erhalten, wenn ich auch eine Digitalkamera dazu 
+>> >> kaufe. Ich habe jetzt einfach mal die "C613" fuer eigentlich 69 Euro
+> >
+> >Naja, das ist wohl ein Auslaufmodell/im letzten Sommer noch fix
+> >auf den Markt geworfenes Geraet mit 6MP und Plastelinsen, das
+> >bereits bei seiner Markteinfuehrung nicht mehr auf der Hoehe der
+> >Zeit war.
+
+Und vor allem wird die Kamera nicht vom Verkauf beigepackt, sondern
+vom Abfallverantwortlichen der Firma Kodak: die Entsorgung ueber den
+Konsumenten kommt Kodak billiger, als ueber die Sonderabfallentsorgung.
+
+Liebe Gruesse
+Hannes
+
+-----------------------------------------------------------------------------
+
+
+
+Beamtenkinder rutschen mit Antrag (Ronda, 25. Jun 2008, 23:00:03):
+From: rha1207@t-online.de (Ralf Heinrich Arning)
+Subject: Re: "Mama, nochmal Rutschen!"
+Newsgroups: de.etc.sprache.deutsch
+Date: Tue, 10 Jun 2008 00:00:25 +0200
+Message-ID: <1iiakdh.1avrvt81c5ruv4N%rha1207@t-online.de>
+
+Rainer Willis <rainerwillis@web.de> wrote:
+
+> > Helga Schulz schrieb:
+> > 
+>> > > "Rutschen durchfuehren" ist voellig unidiomatisch, wer soll denn so
+>> > > reden??
+> > 
+> > Zukuenftige Beamte?
+
+Aber nein! Die rufen: "Mama, Einreichung eines Antrag auf Genehmigung
+nochmaligen Rutschens"
+
+-----------------------------------------------------------------------------
+
+
+
+GleichstellungsbeauftragterIn (Ronda, 25. Jun 2008, 23:02:14):
+From: "Lars Braesicke" <braesicke@yahoo.de>
+Newsgroups: de.etc.sprache.deutsch
+Subject: Re: Gender-Kompetenz
+Date: Mon, 9 Jun 2008 12:44:58 +0200
+Message-ID: <6b4ft9F38h88bU1@mid.individual.net>
+
+Lothar Frings schrieb:
+> > Wolfram Heinrich tat kund:
+> >
+>> >> Nachtrag: An der FU Berlin wird der Zusatzstudiengang
+>> >> Gender-Kompetenz angeboten. Das traeum ich doch alles bloss.
+> >
+> > Och, da gibt es schon interessante Fragen.
+> > Zum Beispiel, warum Gleichstellungsbeauftragte
+> > immer weiblich sind.
+
+Weil Frauen benachteiligt werden, wird auch eine 
+Gleichstellungsbeauftragte in ihrer Taetigkeit benachteiligt werden. Die 
+stete Besetzung von Gleichstellungsbeauftragtenstellen mit Frauen ist 
+somit eine Perfidie des Patriarchats!
+
+scnr
+Lars
+
+-----------------------------------------------------------------------------
+
+
+
+Fuer Janne und die Kieler Woche (Ronda, 25. Jun 2008, 23:28:09):
+Mist, ich kann nicht nach Kiel fahren :-(
+
+Ronda
+
+From: Michael Hess <mhess_de@web.de>
+Subject: Re: SKS in Ostasien machen
+Newsgroups: de.rec.sport.segeln
+Date: Wed, 18 Jun 2008 10:04:04 +0900
+Message-ID: <6br583F3dn5l8U2@mid.individual.net>
+
+Wolfgang Allinger wrote:
+> >  On 17 Jun 08 at group /de/rec/sport/segeln in article
+> >  <mhess_de@web.de>  (Michael Hess)  wrote:
+> > 
+>> >> Dictonary Sailing German - Japanese (Teil 1)
+>> >>
+>> >> Klar zur wende! - Oiii tackuuu shimasu yooo!
+>> >> Rund achtern, stuetz! - Daiyoubu yo!
+>> >> Trimm Fock! - Oiii Gypu checku shimasu yooo!
+>> >>
+>> >> Anlegerbier - Otsukaresama kanpai <pfischh!>
+> > 
+> > Oiiijuijuiyooooo! kacka! -- Grundberuehrung :-?
+> > 
+
+Naja meist wird dem Navigator und Steuermann dann 
+stillschweigend ein kleines Schwert gereicht ;)
+
+Servus,
+Michael
+
+-----------------------------------------------------------------------------
+
+
+
+Was Admins so fuehlen (Ronda, 25. Jun 2008, 23:33:56):
+From:          Bastian Scholz <nimrodXX@gmx.de>
+Newsgroup:     de.alt.sysadmin.recovery
+Subject:       Re: [RANT] Mailserver von KMUs und DNS
+Date:          Mon, 26 May 2008 07:35:03 
+Message-ID:    <pan.2008.05.26.05.35.02.851001@gmx.de>
+
+Am Sat, 24 May 2008 08:30:26 +0000 schrieb Juergen P. Meier:
+
+> > Mach dir nichts draus, viele vergessen beim SPAM-Thema, dass die
+> > eigentliche Klassifizierung, was genau alles SPAM ist und was nicht,
+> > durchaus eine wichtige Subjektive Komponente hat. Zwar gibt es E-Mails,
+> > die keiner der >6 Mrd. Menschen als nicht-SPAM einstufen wuerde (und damit
+> > jedem objektiven Filterkriterium genuegen), aber es gibt eben auch eine
+> > ganz dicke Grauzone. So wie die Mail in diesem Fall.
+
+Hehehe ich arbeite in nem Pharma Grosshandel, wenn wir hier Standardfilter
+verweden und z.B. Viagra als Spam markieren, wuerde gefuehlt die Haelfte
+unserer Bestellungen im Nirvana landen :-)
+
+Gruesse
+
+Bastian
+
+-----------------------------------------------------------------------------
+
+
+
+Schnecken und so (Ronda, 25. Jun 2008, 23:36:37):
+Subject:     Re: Wie terminiere ich Nacktschnecken richtig?
+From:        Kerstin <cricky@arcor.de>
+Newsgroups:  de.rec.garten
+Date:        Thu, 19 Jun 2008 22:23:04 +0200
+Message-ID:  <485ac03d$1@news.arcor-ip.de>
+
+"Harald" <Har@al.d> schrieb im Newsbeitrag news:g3eeb6$t6b$1@aioe.org...
+> > x-no-archive: yes
+> >
+> > Sprengstoff und Bazooka haben sich als negativ fuer den Garten, aber nicht
+> > toedlich genug fuer die Schneckenplage erwiesen.
+> >
+> > Wie kriege ich die Viecher tot, ohne meinen Garten in eine nuklear 
+> > verstrahlte
+> > Atomwueste zu verwandeln?
+> >
+> > Bitte um Rat!
+
+*rofl*
+sammeln, sammeln, sammeln, sammeln, sammeln, sammeln, sammeln, sammeln
+sammeln, sammeln, sammeln, sammeln, sammeln, sammeln, sammeln, sammeln
+sammeln, sammeln, sammeln, sammeln, sammeln, sammeln, sammeln, sammeln
+sammeln, sammeln, sammeln, sammeln, sammeln, sammeln, sammeln, sammeln
+sammeln, sammeln, sammeln, sammeln, sammeln, sammeln, sammeln, sammeln
+
+-----------------------------------------------------------------------------
+
+
+
+Haendewaschen ist schlecht fuer den Router (Ronda, 25. Jun 2008, 23:37:43):
+[auf den relevanten Teil gekuerzt]
+
+From: T-Online-Team@t-online.com (T-Online-Team)
+Subject: Re: Speedport W 701V stuerzt haeufig ab
+Newsgroups: t-online.zugang.adsl
+Date: Sun, 15 Jun 2008 19:54:25 +0200
+Message-ID: <486a52c8.25641875@T-Online-Team.dialin.t-online.de>
+
+
+> > Btw: Dazu passte auch ein User, der beschrieb, dass jedes Mal, wenn er
+> > auf Toilette war, der Router rebootete und sich daher irgendwie beobach-
+> > tet fuehlte. Es stellte sich heraus, dass er einen elektrischen Durch-
+> > lauferhitzer hat und sich offenbar jedes Mal die Haende wusch. (Brav! ;-)
+> > Da elektrische Durchlauferhitzer dem haeuslichen Netz sehr ploetzlich eine
+> > sehr hohe Leistung abverlangen, erschien uns ein kurzfristig abfallender
+> > Eingangsstrom des Routernetzteils, was sich dann entsprechend auf den
+> > Ausgangsstrom auswirkte, die einzig plausible Erklaerung des Fehlers zu
+> > sein. 
+> > 
+> > Mit freundlichen Gruessen
+> > Ihr T-Online-Team
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Monster-Ausflug... (Anthea, 26. Jun 2008, 13:07:49):
+~#! rn=Ronda rt=1214427132 rg=schmarrn.netdigest
+~#! tid=1214427132
+Wenn es denn eine "Klassenfahrt" waere. Aber das war ein kompletter
+Schulausflug.
+http://tinyurl.com/5mu5jb
+
+
+"Ralph A. Schmid, dk5ras   		Profil anzeigen
+ Weitere Optionen 23 Mai, 11:58 
+
+Moin, 
+
+das klingt nach einer Herausforderung :-) 
+
+siehe 
+
+> http://www.derwesten.de/nachrichten/staedte/unna/2008/5/21/news-48528... 
+
+Unna. (dwd) Pendler auf dem Unnaer Bahnhof sollten sich am 
+Freitagmorgen in Acht nehmen. Denn gegen 8 Uhr werden zeitgleich ueber 
+1 000 Schueler auf den Bahnsteig von Gleis 2 stroemen. ... 
+
+... Dann naemlich startet das Geschwister-Scholl-Gymnasium den groessten 
+Schulausflug seiner Geschichte. Es ist ein Projekt der Superlative, 
+das Schulleiter Michael Strobel da vorhat..."
+
+-----------------------------------------------------------------------------
+
+
+
+Legacy Notebook (Ronda, 28. Jun 2008, 20:51:00):
+From: Joerg-Olaf Schaefers <olaf@usenet.fx3.org>
+Subject: Re: Netbook fuer 399 Euro ab 3.7.
+Newsgroups: de.alt.fan.aldi
+Message-ID: <6cevtaF3f5b8eU1@mid.dfncis.de>
+Date: Wed, 25 Jun 2008 15:35:38 +0200
+
+
+Robert Fischer wrote:
+...
+> > Ich habe einen wunderbaren Kugelschreiber mit dem ich
+> > sehr variabel jede Schriftgroesse kostenguenstig darstellen kann.
+
+Super Sache. Ich habe aber ein paar konzeptionelle Nach-
+teile entdeckt:
+
+- Das Schriftbild. Offenbar gibt es da immer mal wieder
+    Kompatibilitaetsprobleme. Von Kugelschreiber-Evangelis-
+    ten werden diese als Sicherheitsfeature gepriesen: Was
+    Dritte nicht lesen koennen, koennen sie auch nicht miss-
+    brauchen.
+
+    Das Problem: mitunter kann man selber nicht mehr lesen
+    oder nachvollziehen, was man geschrieben hat.
+    Welche Auswirkung dieser permanente Datenverlust fuer
+    das kollektive Gedaechtnis der Menschheit und unsere
+    Kultur hat, kann sich jeder selbst ausmalen (Bitte
+    nicht mit einem Kuli!).
+
+- Die Tintenfarbe. Eine falsche Tintenfarbe kann die re-
+    ligioesen Gefuehle von Minderheiten verletzten! Schneller
+    als durch die Wahl einer unpassenden Tintenfarbe kann
+    man einen bereits sicher geglaubten Millionenvertrag
+    nicht wieder verlieren. Geraet man an Fundamentalisten,
+    sind moeglicherweise gar Anschlaege auf Unbeteiligte die
+    Folge.
+
+- Die lausige Indexierbarkeit. Sicher, man kann Kuliauf-
+    zeichnungen scannen und als PDF abspeichern. In ihnen
+    mittels einer Suchmaschine - und sei es eine lokale -
+    nach Schluesselwoertern oder Phrasen suchen, kann man in
+    der Regel nicht.
+
+- Oh, wo wir gerade bei den technischen Aspekten sind:
+    Suchen & Ersetzen funktioniert bei handgeschriebenen
+    Aufzeichnungen nur bedingt. Dauerhaftes Loeschen gar
+    nicht (Durchstreichen ist keine Option. Herrje, wie
+    schaut denn das aus?)
+
+- Tintenflecke. Fakt ist: Kugelschreiber sabbern mitunter
+    mehr als inkontinente Eisbaerenbabys, sind aber nicht an-
+    naehernd so suess! Ein Faktum, das von der Tintenroller-
+    lobbby konsequent totgeschwiegen wird. Ich habe kuerzlich
+    Erna P. zum Thema befragt, Reinigungsfachkraft mit Spe-
+    zialisierung Damenoberbekleidung. Ihre Reaktion war ein-
+    deutig: "Die Scheisse bekommt man nur schwer wieder raus!"
+
+    Und dann? Milchbad? Haarspray? Fleckensalz? Eine Gewalt-
+    spirale, die kaum zu stoppen ist und nicht selten zum
+    Totalverlust fuehrt. Dann lieber XP mit 512MB RAM ...
+
+- Der Fingerprint des Mediums. Und dabei meine ich nicht
+    nur den oekologischen (Kugelschreiben-Minen sind keine
+    erstrebenswerten Arbeitsplaetze, oft kontaminiert und
+    sicher auch dunkel). Ich meine die Stellflaeche in Re-
+    lation zur Information. Schonmal ein Notizbuch gesta-
+    pelt? Sicher, bei einem kein Problem. Das liegt dann
+    da so rum.
+
+    Aber was ist, wenn man hunderte hat? Und Umziehen muss?
+    Nicht sich, sondern mit Sack, Pack und hunderten Notiz-
+    buechern? Das ist kein Spass! Da spuert man die Last der
+    fuer das begrizelte Papier gemeuchelten Baeume direkt im
+    Kreuz!
+
+    Im Gegensatz zum Umzug mit einer einzelnen DVD, die mue-
+    helos die Informationen hunderter handbeschriebener No-
+    tizbuecher aufnehmen kann. Zudem ist sie bei geeigneter
+    Wahl des Datenformats indexierbar!
+
+- Last, but not least: Flugsicherheit! Reisesicherheit
+    allgemein! Kugelschreiber sind ein potentielles Sicher-
+    heitsrisiko! Man kann sie als Stichwaffen verwenden.
+    Oder aus dem Clip eine Bombe bauen.
+
+
+Sorry, Kugelschreiber sind keine Alternativ. Weder aus
+technischer, noch aus moralischer Perspektive.
+
+
+
+    Tschuess,
+    Andre
+
+-- Die Signaturen werden gerade ueberarbeitet, ich bitte um Ihr Verstaendnis! 
+
+-----------------------------------------------------------------------------
+
+
+
+Man sollte echt... (Ronda, 28. Jun 2008, 20:52:14):
+... mehr Aktien von Firmen kaufen, die Visitenkarten und so drucken...
+
+Ronda
+
+Betreff: Re: "DB BAHN" auf den Tueren - neu?
+Datum: Mon, 23 Jun 2008 22:13:59 +0200
+Von: Daniel Weber <dw2007@news.solani.org>
+Newsgruppen: de.etc.bahn.misc
+Message-ID: <g3p068$spb$1@solani.org>
+
+Fredy Barth schrieb:
+> > Ja das ist neu. Die DB wurde doch mal wieder umorganisiert. Alles was
+> > Personenverkehr ist, heisst jetzt DB Bahn (Also ausgeschrieben
+> > "Die Bahn Bahn" :-) ), Gueterverkehr ist DB Schenker und Netz heiss jetzt
+> > DB Netze. Das muss jetzt an allen Einstiegstueren drangeschrieben werden.
+
+Damit man nicht versehentlich bei der konzerneigenen Konkurrenz
+einsteigt? ;-)
+
+> > Dafuer werden die grossen DB-Kekse an den Seiten weggekratzt.
+
+Ganz weg? Die RE/RB zwischen Muenchen und Salzburg bekommen vor den
+grossen Keks alle ein kursives "REGIO" gepappt. Die DoStos zusaetzlich
+"Muenchen Salzburg Express" darunter (meist nach hinten abschuessiger
+werdend).
+
+Bei der naechsten Umorganisation wuerde ich vorschlagen, die mit
+Umorganisationen, Aufklebern und Lacken befassten Abteilungen als
+Tochter auszugruenden. Das waere dann mit Sicherheit die profitabelste im
+Konzern. ;-)
+
+Ciao,
+Daniel
+
+-----------------------------------------------------------------------------
+
+
+
+Politisch korrekte Kinderlieder (Ronda, 28. Jun 2008, 20:52:40):
+From: "Helmut P. Einfalt" <helmut.p.einfalt_DELETETHIS@_XXX_aon.at>
+Subject: Re: Political Correctness
+Newsgroups: de.etc.sprache.deutsch
+Date: Wed, 25 Jun 2008 10:41:05 +0200
+Message-ID: <486203f8$0$2240$91cee783@newsreader01.highway.telekom.at>
+
+>> >> Damals sang man im Kindergarten auch noch das Lied "Zehn kleine
+>> >> Negerlein...". Heute wuerde ein solches zur sofortigen Entlassung der
+>> >> Erzieherin fuehren.
+
+> > Aber "Zehn kleine Afroamerikaner" ist silbentechnisch
+> > schon sehr lang.
+
+"Zehn kleine dunkelhaeutige MitbuergerInnen" (samt gesprochenem Binnen-I)
+ist auch irgendwie nicht das Optimale!
+
+-----------------------------------------------------------------------------
+
+
+
+Tax Collectors of the Caribean?! (Ronda, 29. Jun 2008, 00:15:32):
+From: Gerald Fix <gerald.fix@t-online.de>
+Subject: Re: Beamtendeutsch als anerkannte Berufskrankheit?
+Newsgroups: de.etc.sprache.deutsch
+Date: Mon, 16 Jun 2008 16:29:15 +0200
+Message-ID: <a5uc54di4sksil8qm1cel6uv95p1gptfol@4ax.com>
+
+On Sun, 15 Jun 2008 19:39:54 +0200, Wolfram Heinrich
+
+<info@theodor-rieh.de> wrote:
+
+>> >>Verbrauchsteuerrechtliche Genehmigungen fuer Landwirte und
+>> >>Nebenerwerbslandwirte :-)
+> >
+> >Als ich 10 war, war das mein Traumjob.
+
+Meiner war Pirat. Irgendwann bin ich draufgekommen, dass man den
+gleichen Effekt mit weniger Risiko erreicht. So wurde ich
+Finanzbeamter.
+-- Viele Gruesse Gerald Fix 
+
+-----------------------------------------------------------------------------
+
+
+
+Giftcocktail (Ronda,  6. Jul 2008, 12:46:48):
+Subject:     Giftcocktail
+From:        Harald Maedl <harald.maedl@gmx.de>
+Newsgroups:  de.alt.talk.unmut
+Date:        Wed, 2 Jul 2008 22:00:08 +0200
+Message-ID: <g4gmt4$q7l$03$1@news.t-online.com>
+
+Die Injektion von Apamin dauerte nur Millisekunden. Sofort wurden die
+Kaliumkanaele der Nervenzelle blockiert und es entstand ein
+Ungleichgewicht zwischen Kalium- und Natriumgehalt in der Zelle. Quasi
+unverzueglich konnten alle spannungsgesteuerten Kanaele nicht mehr
+geschlossen werden. Die Nervenzellen standen auf Feuerbereitschaft und
+bestaendig konnten nun Signale fliessen, ohne dass sie durch die
+Kaliumpumpen gehemmt werden konnten.
+
+Zugleich wurde mit dem Apamin das Phosphatidylcholin-2-acylhydrase,
+kurz PLA2, mit einem Anteil von rund 10% appliziert. Die Wirkung war
+verheerend. Die Phospholipide wurden in rasender Geschwindigkeit durch
+hydrolytische Spaltung vom zweiten Kohlenstoff-Atom (beta-C-Atom)
+abgetrennt.  Die hauptsaechlich aus Lecithin bestehenden Zellmembranen
+wurden zu Lysolecithin umgewandelt und die Zelloberflaeche dadurch
+massiv geschaedigt. Gleichzeitig wurde die Gerinnungsfaehigkeit des
+Blutes herabgesetzt. Aus den Lipiden wurde Arachidonsaeure, die vorher
+in gebundener Form vorlag, freigesetzt und nach und nach in steil
+ansteigender Konzentration zu Eicosanoide umgewandelt. Eikosanoide sind
+Neurotransmitter und verantwortlich fuer Allergie Fieber und Schmerz,
+Schmerz und Schmerz.
+
+Doch damit nicht genug, damit sich vorher genannte Stoffe auch
+moeglichst effektiv ausbreiten konnten, wurde durch gleichzeitige
+Injektion von Hyaluronidase dafuer gesorgt, dass sich die Blutgefaesse
+erweitern und insgesamt fuer den gereichten Cocktail durchlaessiger
+wurden. Als Abrundung diente schliesslich noch eine gehoerige Portion
+Histamin, was zu beschleunigtem Puls und insgesamt einer raschen
+weiteren Ausbreitung gesorgt hat.
+
+Ja, er tut hoellisch weh, dieser Bienenstich und die Hand ist trotz
+intensiver Kuehlung richtig dick.
+Ich will Mitleid, Trost - JETZT!
+
+-----------------------------------------------------------------------------
+
+
+
+[Dazu faellt mir kein Titel ein] (Ronda,  6. Jul 2008, 12:57:02):
+ 
+From: Thomas Schade <toscha@rrr.de>
+Subject: Re: Regular
+Newsgroups: de.etc.sprache.deutsch
+Date: Thu, 19 Jun 2008 22:48:03 +0200
+Message-ID: <485AC603.4060202@news.toscha.de>
+
+On 19.06.2008 07:52, Wolfram Heinrich wrote:
+
+> >Na also. Ich liebe die Katholische Kirche. Sie spricht zwar ziemlichen
+> >Unfug, aber wenn sie mal was gesagt hat, dann bleibt sie dabei. Punkt. Bei
+> >denen ist nichts von Pudding zu spueren, die kannst du an die Wand nageln -
+> >wenn du kannst.
+
+Warum nicht? Hat doch beim Gruender auch geklappt.
+
+
+Ciao
+Toscha
+
+-----------------------------------------------------------------------------
+
+
+
+Re: [Dazu faellt mir kein Titel ein] (Gloinson,  6. Jul 2008, 16:05:00):
+~#! rn=Ronda rt=1215341822 rg=schmarrn.netdigest
+~#! tid=1215341822
+Gruender der Kirche und Religionsstifter verwechseln ist auch arg schlecht zu
+betiteln.
+
+
+-----------------------------------------------------------------------------
+
+
+
+Wie viel Coffeinentzug... (Ronda, 10. Jul 2008, 22:27:20):
+... braucht man, um so was zu schreiben?!
+
+Ronda
+
+From: Georg Bauhaus <rm.tsoh.plus-bug.bauhaus@maps.futureapps.de>
+Newsgroups: de.comp.lang.misc
+Subject: Re: Modellierung
+Date: Thu, 29 May 2008 12:42:09 +0200
+Message-ID: <483e8882$0$6557$9b4e6d93@newsspool3.arcor-online.net>
+
+Stefan Ram wrote:
+
+>> >> if not Kaffeautomat.ist_noch_was_drin(Bohnen) then
+>> >>   Stift.standesgemaess_anreden("Hol ma Kaffee!")
+>> >> fi
+> > 
+> >   Das ist meiner Meinung nach ein Verstoss gegen
+> >   Tell, don't ask. [...]
+> >   Daher waere Tell, don't ask:
+> >
+> > Kaffeeautomat.ausreichende_Menge_an_Bohnen_sicherstellen( Stift );
+
+Hmm, bin nicht ueberzeugt, dass ein objektorientierter Kaffeautomat
+die Zustaendigkeit fuer Befehle an einen Stift haben sollte.
+Dafuer muss der Kaffeeautomat auch die Schnittstelle eines Stifts
+kennen. Aber was hat der Konstrukteur eines Kaffeeautomaten
+mit Anweisungen an einen Auszubildenden zu schaffen?
+
+Mir scheint fuer diesen Fall eine uebergeornete Instanz
+angemessener. Eine Instanz, die sowohl den Kaffeautomat bedient,
+als auch einen Stift anweisen darf, nach Sachlage, das heisst
+je nach dem derzeitigen Verhalten ("Zustand") des Kaffeeautomaten.
+
+Eine diesen Ueberlegungen entsprechende Methode koennte so aussehen,
+sie stammt aus der Klasse GESELLE. Ein vollstaendigeres OO-Programm
+folgt weiter unten.
+
+feature kaffe_check is
+         -- Geselle sorgt fuer Kaffenachschub.  Motivation:
+         -- Vgl. The Simpsons Movie, die Wirkung fehlenden Kaffees.
+      require
+         kaffee_aufsicht: hat_aufsicht
+      do
+         if not kaffee_automat.is_all_set then
+            kaffee_automat.reset
+         end
+
+         from
+            until kaffee_automat.fuellstand > 0
+         loop
+            stift.standesgemaess_anreden ("Hol ma Kaffee!")
+            -- Geselle macht was anderes ...
+         end
+      end
+
+Ich koennte fordern, dass ein AZUBI die allgemeine Schnittstelle
+Anweisung_Verarbeiten implementiere, damit "TellDontAsk" bei der
+Kaffeemaschine eine Stiftsteuerung ausloesen kann.  Der Azubi muss
+dann umgekehrt das Protokoll von Kaffeeautomaten verstehen,
+mit Hilfe dessen Kaffeeautomaten Nachrichten austauschen.
+
+Aber das scheint mir eine kuenstliche Verschmelzung zweier
+urspruenglich entkoppelter Module von ganz unterschiedlicher Art,
+naemlich Kaffeeautomat einerseits und Auszubildender andererseits.
+Dann doch lieber modellieren, dass ein AZUBI einen GESELLEn versteht.
+Beide sprechen ja ohnehin ein aehnliches (menschliches) Protokoll,
+dessen jeweilige Formalisierung leichter harmonisierbar scheint,
+als das zwischen Kaffeemaschine und Mensch.
+
+
+indexing
+   description: "Kaffeebohnen, geroestet."
+expanded class KAFFEE
+end
+
+indexing
+   description: "Kann man an einer Maschine druecken"
+
+deferred class
+   KNOPF
+feature
+   press is
+      deferred
+      end
+end
+
+
+indexing
+   description: "[
+      Maschinen, die Lebensmittel bevorraten und portionsweise
+      bereit stellen, auf Knopfdruck.
+      ]"
+deferred class SPENDER[INHALT]
+
+
+feature  -- Measurement
+   fuellstand: INTEGER is
+         -- Vorrat in Prozent
+      deferred
+      ensure
+         normale_befuellung: 0 <= Result and Result <= 100
+      end
+
+feature -- Status report
+   is_all_set: BOOLEAN is
+         -- in Betrieb, prinzipiell lauffaehig, kein Fehler
+      deferred
+      end
+
+   is_done: BOOLEAN is
+         -- eine Portion hergestellt
+      deferred
+      end
+
+feature -- Status setting
+   reset is
+         -- Interne Ueberpruefung neu starten
+         -- may raise an exception due to hardware failure
+      deferred
+      end
+
+
+feature -- Basic operations
+   lauf(gedrueckt: KNOPF) is
+         -- Maschinenlauf gemaess Knopffunktion starten
+      require
+         system_health: is_all_set
+         was_drin: fuellstand > 0
+      deferred
+      ensure
+         fertig: is_done
+      end
+
+   befuellen(menge: INTEGER; quelle: BAG[INHALT]) is
+         -- `menge' Einheiten aus `quelle' entnehmen und neu bevorraten
+      require
+         -- Die `quelle' muss wirklich eine Quelle sein, aber auch
+         -- wieder aufnehmen koennen, damit Wiederherausnehmen
+         -- waehrend des Befuellvorgangs modelliert werden kann:
+         quelle_voll: menge > 0 implies quelle.prunable
+         wieder_zurueck: menge < 0 implies quelle.extendible
+      deferred
+      end
+
+invariant
+   korrekt_befuellt: 0 <= fuellstand and fuellstand <= 100
+
+end -- class SPENDER
+
+
+indexing
+   description: "Taetige Beschaeftigte eines Betriebs."
+
+class MITARBEITER
+create
+   make
+feature
+   make(name: STRING; personal_nummer: INTEGER; stellung: INTEGER) is
+         -- `stellung' ist eine der Konstanten von `MITARBEITER'
+         -- die nach Weisungsbefugnis geordnet sind.
+         -- Die Ordnung muss nicht der Klassenhierarchie folgen.
+      do
+         the_name := name ; the_id := personal_nummer
+         the_status := stellung
+      end
+
+   Chef: INTEGER is 0
+   Chef_Gattin: INTEGER is 1
+   Facharbeiter: INTEGER is 10
+   Wirtschaft: INTEGER is 10
+      -- Buchhaltung, Kasse, Schriftkram, etc.
+   Lehrling: INTEGER is 100
+
+feature {MITARBEITER}  -- Implementation
+   the_name: STRING
+   the_id: INTEGER
+   the_status: INTEGER
+end -- class MITARBEITER
+
+
+indexing
+   description: "Stifte im Betrieb."
+deferred class AZUBI
+   inherit MITARBEITER
+
+feature
+   hat_was_gemacht(anweisung: STRING): BOOLEAN is
+         -- hat gehorcht und getan
+      deferred
+      end
+   standesgemaess_anreden(anweisung: STRING) is
+         -- `Current' soll `anweisung' ausfuehren
+      deferred
+      end
+end -- class AZUBI
+
+
+indexing
+   description: "Arbeitet und ist fuer den Kaffee zustaendig."
+class GESELLE inherit MITARBEITER
+
+feature
+   aufsicht(betriebsmittel: SPENDER[KAFFEE]) is
+         -- der Geselle soll fuer dieses `betriebsmittel' gerade stehen
+      do
+         kaffee_automat := betriebsmittel
+      end
+   hat_aufsicht: BOOLEAN is
+         -- ist fuer Kaffe zustaendig?
+      do
+         Result := kaffee_automat /= Void
+      end
+   kaffe_check is
+         -- Geselle sorgt fuer Kaffenachschub.  Motivation:
+         -- Vgl. The Simpsons Movie, die Wirkung fehlenden Kaffees.
+      require
+         kaffee_aufsicht: hat_aufsicht
+      do
+         if not kaffee_automat.is_all_set then
+            kaffee_automat.reset
+         end
+         from until kaffee_automat.fuellstand > 0 loop
+            stift.standesgemaess_anreden ("Hol ma Kaffee!")
+            -- Geselle macht was anderes ...
+         end
+      end
+
+feature {MITARBEITER}
+   ordne_unter(werner: AZUBI) is
+         -- der Geselle darf `werner' anweisen
+      require
+         darf_anweisen: the_status < werner.the_status
+      do
+         stift := werner
+      end
+feature {NONE} -- Implementation
+   stift: AZUBI
+   kaffee_automat: SPENDER[KAFFEE]
+end -- class GESELLE
+
+-----------------------------------------------------------------------------
+
+
+
+DB Navigation (Ronda, 10. Jul 2008, 22:27:56):
+From: Tobias Nicht <usenet.nospam@tramdriver.de>
+Subject: DB Navigation
+Newsgroups: de.etc.bahn.misc
+Date: Sun, 06 Jul 2008 22:17:42 +0200
+Message-ID: <hc1274lnc3qbf4t1qc78hsnc4sqo7s8ee7@4ax.com>
+
+Moin,
+
+ich habe mal ueberlegt wie es sich anhoeren muss, wenn die DB ein Navi
+herausgibt:
+
+-> nach Eingabe des Ziels
+
+Herzlich Wilkommen im Namen der Navigationsabteilung von DB
+Reiseplanung auf Ihrer Fahrt nach Leipzig
+Werter Fahrzeuglenker, bitte beachten Sie die Sonderangebote unserer
+Schakal Partnertankstelle. Am Blumenautomaten erhalten Sie heute den
+Strauss Feldkresse fuer 9,78
+
+-> ich fahre los bis zur naechsten Kreuzung
+
+In 200 Metern rechts abbiegen. Sie haben auch die Fahrtmoeglichkeit
+nach Friedersdorf rechts abbiegen oder Deutsch Paulsdorf gerade aus.
+
+-> ich fahre rechts rum, klar will nach Leipzig und im naechsten Ort
+kommt eine rote Ampel
+
+an der naechsten Kreuzug gerade aus
+
+-> die Ampel ist rot
+
+Werter Fahrzeuglenker, die Weiterfahrt verzoegert sich um wenige
+Minuten. Wir bedauern dies und bitten um Entschuldigung.
+
+-> naechste Kreuzung
+
+bitte fahren Sie geradeaus. Alternativ koennen Sie nach rechts in
+Richtung Goerlitz oder nach links in Richtung Loebau abbiegen.
+
+-> auf der Autobahn
+
+Werter Fahrzeuglenker bitte beachten sie, dass die Strecke laengere
+Zeit gerade aus geht. Wegen eventuell auftretenden Verunreinigungen
+ist das Rauchen waehrend des Betriebes des DB Reise und Touristik
+Navigationsgeraetes nicht gestattet. Wir bedauern dies und wuenschen
+ihnen noch einen Angenehme Fahrt......................
+
+
+OK ich rauche nicht, aber spaetestens dann haette ich das Geraet
+entsorgt. Warum muss ich aber jetzt und hier im Zug das ganze Gelabere
+ertragen? Den Kin zum Fenster rauswerfen ist nicht die Loesung, da er
+den Quatsch nicht verbrochen hat. Die Chefs mit dem Ansagefimmel
+sollten mir aber mal unter die Finger kommen!
+
+Gruss Tobias
+
+aus dem RE Saxonia in Richtung Leipzig
+
+-----------------------------------------------------------------------------
+
+
+
+Wer denkt da an Mud-Libs?! (Ronda, 10. Jul 2008, 22:28:26):
+From: henicke@t-onlne.de (Andreas Henicke)
+Newsgroups: de.alt.sysadmin.recovery
+Subject: Re: Redundanz
+Date: Sat, 5 Jul 2008 14:46:37 +0200
+Message-ID: <1ijm0ki.k8pt8k80r8kcN%henicke@t-onlne.de>
+
+Dietz Proepper <dietz-news@rotfl.franken.de> wrote:
+
+>> > > Einzelkaempfer dokumentieren selten so, dass andere damit klarkommen.
+
+> > Das stimmt so nicht. Sie setzen haeufig voraus, dass der geneigte Leser
+ueber
+> > bestimmte Grundkenntnisse der Materie verfuegt.
+
+Sie setzen voraus, dass der geneigte Leser ueber die gleichen Faehigkeiten
+und (Fehl)schluesse verfuegen wie der Genannte. Dass der Leser ein Klon des
+Einzelkaempfers ist und seine Erfahrungen ebenfalls aus der  grossen
+blutigen Multics-Offensive am Lake Amdahl 1969 gesammelt hat. 
+
+Andererseits haette ich weniger Spass, wenn ich nicht im vornhinein sagen
+koennte, fuer welche Programmteile keine Dokumentation vorhanden sein
+wird. Es sind immer die Teile, bei denen es interessant wird. 
+
+Gruss, Andreas.
+
+-----------------------------------------------------------------------------
+
+
+
+Datenschutz. Anders. (Ronda, 10. Jul 2008, 22:29:07):
+From: Magnus Wallwitz <mawall@trash-mail.de>
+Subject: Re: Datentraeger auf Knopfdruck mechanisch shreddern?
+Newsgroups: de.comp.security.misc
+Date: Tue, 01 Jul 2008 00:45:33 +0200
+Message-Id: <486961da$0$27447$9b4e6d93@newsspool4.arcor-online.net>
+
+Michael Reichenbach wrote:
+
+> > Was gibt es da noch? Gibt es magnetische Festplatten oder Flash Sticks
+> > die man auf Knopfdruck zerstoeren kann (oder fuer andere Datentraeger)?
+> > Oder Loesungen die man sich selbst basteln kann?
+
+Frag mal im oertlichen Krankenhaus, ob die sich vllt. nen neuen Kernspin
+kaufen wollen und Dir guenstig den alten verkaufen. Den packst Du dann in
+Deine (grosse) Wohnung und baust Dir ein Foerderband in das Ding. Hinten am
+Ende des Foerderbandes stellst Du einen Haecksler mit starkem Motor und
+Schneiden hin, das die Festplatte da rein faellt nachdem sie aus dem
+Kernspin kommt. Den Auswurf des Haecklers verbindest du mit einem Ofen, der
+staendig brennt. Jetzt noch eine fette Stromleitung legen lassen, der
+Kernspin laeuft glaube nicht mit 220V. Wichtig ist, dass Du niemandem davon
+erzaehlst, sonst drehn sie Dir vorher den Strom ab.
+
+Wenn Deine Wohnung zu klein ist, frag beim Tierarzt, die haben kleinere
+Kernspin. Ob das Magnetfeld bei neueren Festplatten was gegen die Schirmung
+ausrichten kann weiss ich nicht, aber da ist schon ordentlich Dampf drauf.
+
+Alternativ wuerde ich ein etwas staerkeres Schweissgeraet nehmen und wenn die
+boesen Buben kommen eine 6er Elektrode mit 400 Ampere draufbrutzeln. Das
+gibt auch ein schoenes Magnetfeld und tuechtig heiss wirds auch. Wenn das
+Magnetfeld nicht reicht machts eben die Hitze. Wenn die Daten dann noch
+verschluesselt waren sollte es reichen.
+
+Bedenke aber, dass Du dann eine neue Festplatte brauchst. Also zu den
+genannten Geraeten solltest Du noch nen Hunni fuer ne neue Platte einplanen.
+
+Auf unverschluesselte Backups auf CD im Regal neben Deinem PC wuerde ich auch
+verzichten. 
+
+Vielleicht tuts aber auch eine WLan-Platte im Nachbarkeller.
+
+Gruss
+MW
+
+-----------------------------------------------------------------------------
+
+
+
+DAS ist doch mal nen Argument fuer Muds, oder? (Ronda, 10. Jul 2008, 22:30:13):
+From: Richard W. Koenning <Richard.Koenning@t-online.de>
+Newsgroups: de.alt.rec.digitalfotografie
+Subject: Re: Nachschaerfen bei RAW-Aufnahmen
+Date: Tue, 17 Jun 2008 23:13:59 +0200
+Message-ID: <g3999t$uh8$01$1@news.t-online.com>
+
+Matthias Wieser <matthias-usenet@gmx.de> wrote:
+
+> >Du kannst gerne ein Skript schreiben, das den Foto-Ordner ueberprueft und
+> >sobald keine neuen Jpegs mehr dazu kommen (d.h. dass Bibble fertig ist),
+> >die Webseiten generiert und die Daten hochlaedt. Wo ist das Problem?
+> >
+> >Dann hast Du gute Jpegs *und* individuelle Webseiten.
+
+Dann muss man immer noch zwei unterschiedliche Dinge parallel starten
+und aufeinander abstimmen. Mit einem per Kommandozeile/Input-Datei
+steuerbaren RAW-Konverter kann man eine einfachere Loesung bauen, d.h.
+die Behauptung, es "ginge viel besser als mit Kommandozeile" stimmt
+immer noch nicht. Es mag gehen, aber nicht besser, und schon gar nicht
+viel besser.
+Ich verstehe nicht, warum die Entwicklung bei vielen Leuten bei
+Computern in genau die andere Richtung verlaeuft als bei Buechern. Bei
+letzteren faengt man mit Bilderbuechern an und arbeitet sich dann zu
+Buechern mit mehr und mehr Schrift vor.
+Ciao,
+Richard
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Wie viel Coffeinentzug... (Rumata, 11. Jul 2008, 09:03:05):
+~#! rn=Ronda rt=1215721640 rg=schmarrn.netdigest
+~#! tid=1215721640
+Zu irgendwas muss Eiffel ja gut sein...
+
+-----------------------------------------------------------------------------
+
+
+
+Re: [Dazu faellt mir kein Titel ein] (Orktoeter, 18. Jul 2008, 16:59:18):
+~#! rn=Ronda rt=1215341822 rg=schmarrn.netdigest
+~#! tid=1215341822
+Genau! Und die Erde steht im Mittelpunkt des Universums! Und es war nicht ein
+hoher Kleriker der vor kurzem oeffentlich ueber die Moeglichkeit
+ausserirdischen Lebens gesprochen hat...
+
+
+-----------------------------------------------------------------------------
+
+
+
+Legacy Memory irgendwie (Ronda, 27. Jul 2008, 21:09:15):
+From: Wolfgang Ottenweller <handyfan@oleco.net>
+Newsgroups: de.alt.fan.aldi
+Subject: Re: Filme fuer Kleinbildkameras
+Date: Sat, 12 Jul 2008 17:37:05 +0200
+Message-ID: <g5akqc$uda$1@online.de>
+
+
+
+Andreas Hoefeld schrieb:
+
+Hallo,
+
+> > Was sind Filme fuer Kleinbildkameras?
+
+Einwegspeicherkarten fuer historische Kameras. ;-)
+
+Gruss, Wolfgang
+
+-----------------------------------------------------------------------------
+
+
+
+Swapspace, einfach erklaert (Ronda, 27. Jul 2008, 21:10:14):
+From: "Ulrich F. Heidenreich" <nospam.0x4711@tremornet.de>
+Subject: Re: 10" Netbook Akoya b. AS ab 03.07.
+Newsgroups: de.alt.fan.aldi
+Date: Sat, 05 Jul 2008 20:14:29 +0200
+Message-ID: <g4okn6.3vvirln.1@ufh.invalid.de>
+
+Wilfried Kramer in <news:486fac8f.584665468@id-4017.my-fqdn.de>:
+
+> >Schon mal gesehen, wie sich ein 512MB Rechner benimmt, bei dem 600MB
+> >Hauptspeicher genutzt werden?
+
+Da kommt ein kleines gruenes Maennchen mit der weissen Fahne raus und 
+ruft verzweifelt "Wer kann mir bloss 88 MB Speicher schenken?". Das 
+Ganze in der Hoffnung, dass der Kollege aus der Festplatte mit "Ich 
+haben Swapspace, Du kaufen wollen?" zurueckwinkt.
+
+HTH,
+Ulrich 
+
+-----------------------------------------------------------------------------
+
+
+
+Nuetzlich besonders fuer Zwerge (Ronda, 27. Jul 2008, 21:32:27):
+From: Wilhelm Voigt <Willi.Voigt@web.de>
+Newsgroups: de.rec.garten
+Subject: Re: Kleingaertnerverein, welche Sachen sollte ich beachten?
+Date: Thu, 17 Jul 2008 08:34:56 +0200
+Message-ID: <6e87glF5pqa3U1@mid.individual.net>
+
+Oliver Baldig schrieb:
+
+snip
+
+Nur am Rande: Mir ist aufgefallen, dass sich im Wort etwas 
+bedeutungsschwangeres versteckt:
+
+Kleingaert nerverei n
+           ^^^^^^^^^
+
+w.
+
+-----------------------------------------------------------------------------
+
+
+
+Bad Cannstatt? (Ronda, 27. Jul 2008, 21:33:17):
+Date: Wed, 16 Jul 2008 16:56:49 +0200
+From: Helmut Barth <Helmut.Barth@arcor.de>
+Newsgroups: de.etc.bahn.eisenbahntechnik
+Subject: Re: Hauptsignal+Vorsignal
+Message-ID: <487e0c1f$0$27443$9b4e6d93@newsspool4.arcor-online.net>
+
+Salut!
+
+Falk Schade schrieb:
+
+> >  nein, in der Naehe von Bad Cannstatt
+
+"Excuse me Sir, what is so bad about Cannstatt, that they put it even in 
+the name?"
+
+SCNR, Helmut
+
+-----------------------------------------------------------------------------
+
+
+
+Gruener Pfeil (Ronda, 27. Jul 2008, 21:34:05):
+From: Andreas Viehrig <0x01++01++@dagrantla.de>
+Newsgroups: de.soc.recht.strassenverkehr
+Subject: Re: Rotlichtverstoss oder nicht?
+Date: Fri, 18 Jul 2008 08:39:19 +0200
+Message-ID: <180708.083919.49.12.dsrs.0x++@dagrantla.de>
+
+Guenter Schink schrieb:
+
+[Gruener Pfeil]
+
+> > Nun gut, das ist nicht wirklich eine Entschuldigung, aber ich kann
+> > mich auch nicht erinnern, dass diese revolutionaere Uebernahme aus der
+> > Uebernahme der DDR in der alten BRD wirklich wirksam propagiert wurde.
+
+Es gab auch in der Taetaetrae genug Probleme damit. Da wurden immer wieder
+Fussgaenger und Radfahrer von rechtsabbiegenden Blechkuebelvollkoffern
+zermatscht.
+
+Dieser gruene Pfeil widerspricht einfach der Mentalitaet des
+(gesamt)deutschen Autofahrers, denn der Pfeil moechte den deutschen
+Autofahrer gerne zum Mitdenken animieren - und dieser unverhohlene
+Angriff auf seinen von ihm ueber alles geliebten Stumpfsinn ist etwas,
+was der deutsche Autofahrer nun einfach ueberhaupt nicht leiden kann.
+
+Andi
+
+-----------------------------------------------------------------------------
+
+
+
+Fuer Mopped-fahrende Otto-Fans (Ronda, 27. Jul 2008, 21:35:34):
+Subject: Crashlog frei nach Otto
+Date: Sun, 13 Jul 2008 10:44:44 +0200
+Message-ID: <20080713104444.77e5056c@worstcase>
+From: Volker Lorna <not@valid.de>
+Newsgroups: de.rec.motorrad
+
+Hallo Gruppe!
+
+Hier ein Ausschnitt aus meinem internen Brainlog vom gestern frueh,
+gegen 7:00.
+
+Auge:     erkenne leichte Rechtskurve, oeffnend
+Auge:     Tachoablesung 90kmh
+Grosshirn: Strasse nass, Hinterreifen ist neu, Zielgeschwindigkeit 90kmh
+Grosshirn: Kommando an Gashand: halten
+Auge:     Kurvenende erreicht, naechstes kurvenende ist nicht einzusehen,
+           sieht aus wie mittelscharfe links, Leitplanke mit roten
+           Warnmarkierungen Grosshirn: Kurve bekannt, fahrbar bis etwa
+           110kmh
+Grosshirn: Strasse nass, Hinterreifen ist neu, Zielgeschwindigkeit: 70kmh
+Grosshirn: Kommando an Gashand: Schliessen
+Grosshirn: Kommando an Hand- und Fussbremse: Tempo leicht reduzieren
+Auge:     Tachoablesung 70kmh
+Auge:     Moderate Schraeglage
+Popometer:Ungewoehnliche Fahrsituation erkannt - keine Rueckmeldung von
+Hinterrad,
+           Schraeglage zu hoch fuer Geschwindigkeit und Kurvenradius
+Kleinhirn:Alarm! Schalte Grosshirn in Suspend Modus.
+....
+Kleinhirn:Powerup Grosshirn
+Auge:     Erkenne Leitplanke - 1m entfernt, bewegt sich ziemlich
+           schnell.
+Popometer:Device "Mopped" nicht gefunden, gehe auf standby
+Grosshirn: !!!
+Auge:     Restgeschwindigkeit leicht ueber Schrittgeschwindigkeit
+Gleichgewichtszentrum: Wechsel zu zweifuessigem Betrieb
+Auge: Sind grad von nem Benzinkanister ueberholt worden
+Grosshirn: Der gehoert zum Mopped - Systemcheck unterbrochen durch:
+           Mopped suchen
+Auge:     gefunden, steckt unter der Leitplanke
+Grosshirn: Mopped Schnellpruefung: Schnabel ab, linker Koffer geknuellt,
+           Navihalter zerbroeselt, rechte Tankverkleidung gerissen, alle
+           wichtigen Teile ok
+Grosshirn: Mopped hinstellen, Teile einsammeln
+Rechte Hand: Keine Rueckmeldung der Bremse, Wirkung 0, Druckpunkt am
+           Griff
+Grosshirn: Rechtliche Lage: Leitplanke kaputt, Strasse dreckig, Benzin
+           ausgelaufen
+Grosshirn: Moralische Lage: Sprit auf der Strasse - saugefaehrlich fuer
+           andere Moppeds
+Grosshirn: Systemcheck Ergebnis: Jacke am linken Arm durchgescheuert,
+           sonst alles ok
+Grosshirn: Handy raus, 110
+
+Die Rennleitung sagt "nicht angepasste Geschwindigkeit" - da hat se wohl
+recht, sonst haetts mich ja nich geworfen.
+Memo an mich: TKC80 in Zukunft nur noch auf trockener Strasse anfahren.
+Der Reifen hatte sich zuvor in wesentlich heikleren Kurven gut benommen,
+in der Ausrittkurve is der Asphalt sehr fein, vielleicht wars das.
+
+
+Gruss,
+Volker
+
+-----------------------------------------------------------------------------
+
+
+
+Amerikaner und Briten (Ronda, 27. Jul 2008, 21:36:10):
+From: Helmut Richter <hhr-m@web.de>
+Subject: Re: Dialekte in Deutschland
+Newsgroups: de.etc.sprache.deutsch
+Date: Sat, 19 Jul 2008 14:24:17 +0200
+Message-ID: <Pine.LNX.4.64.0807191415270.5626@lxhri01.lrz.lrz-muenchen.de>
+
+> > Da es etliche in den falschen Hals kriegen: das mit "Falsch", "Quatsch"
+> > war nur ein Seitenhieb auf die Diskussions-"Kultur" im Usenet.
+ 
+> > Ich bleibe aber dabei, dass solche Hoeflichkeiten im englischen Sprachraum
+> > ueblicher sind als im deutschen, und dass sich insbesondere "Tut mir leid,
+> > aber ..." fuer mich ungewohnt anhoert.
+
+Gibts da nicht auch Unterschiede zwischen britischer ("you could enhance
+your service to the community a lot by taking a bit more care to check
+the facts") und amerikanischer ("bullshit") Hoeflichkeit?
+
+-----------------------------------------------------------------------------
+
+
+
+Siemens- oder Adtranzelektronen? (Ronda, 27. Jul 2008, 21:37:26):
+From:Helmut Barth <Helmut.Barth@arcor.de>
+Subject: Re: Und wie/wann machen die Jungs die Bremsprobe?
+Newsgroups: de.etc.bahn.eisenbahntechnik
+Date: Sun, 20 Jul 2008 20:53:34 +0200
+Message-ID: <48838997$0$6563$9b4e6d93@newsspool3.arcor-online.net>
+
+Salut!
+
+Matthias Dingeldein schrieb:
+> > Helmut Barth schrieb:
+> > 
+>> >> Warum? Der Zug merkt dass er ploetzlich allein ist (da war doch noch was
+>> >> mit der "Entkuppeln"-Funktion) und bittet den Lokfuehrer um eine 
+>> >> Bestaetigung der nun gefundenen Zugkonfiguration. Lokfuehrer drueckt den
+>> >> "Jawoll, du bist jetzt mit mir ganz allein"-Knopf und schon weiss der
+Zug 
+>> >> Bescheid.
+> > 
+> > wenn der Zug vorher rumgezickt hat, kann man auch den "Jawoll, du bist
+> > jetzt mit mir ganz allein - MUAHAHAHA"-Knopf benutzen, dann weiss die
+> > Kiste schonmal, worauf sie sich jetzt einzustellen hat
+
+Ich summe da nur dreissig Sekunden "Schlaf, Kindlein schlaf" .. Die 
+Androhung stromloser Schnellheilung hat bisher fast alle Fahrzeuge 
+wieder zur Besinnung gebracht. Spaetestens nach der Umsetzung der 
+Androhung ;-).
+
+In weniger schwerwiegenden Faellen genuegt es aber auch an die 
+Selbstachtung originaler Siemens- oder Adtranzelektronen zu appelieren
+oder selbige in gepflegten Worten [1] zur Ordnung zu rufen.
+
+Eine Bestellung von einigen wenigen, gerne auch gebrauchten, 
+Ersatzelektronen fuer leichte bis mittelschwere Faelle ist leider im
+Sand 
+verlaufen..
+
+Gruessle, Helmut
+
+[1] "MACH HIN, BLOeDE KARRE. WIR SIND HIER BEI DER EISENBAHN UND NICHT 
+BEI EINER INFORMATIKVORLESUNG", hat sich bewaehrt.
+
+-----------------------------------------------------------------------------
+
+
+
+Maildisclaimer sind toll! (Ronda, 27. Jul 2008, 21:38:34):
+From: Christian Garbs <mitch@cgarbs.de>
+Subject: Re: S: Maildisclaimer
+Newsgroups: ger.ct
+Date: Thu, 24 Jul 2008 20:05:47 +0200 (CEST)
+Message-ID: <g6ag9r$csf$1@yggdrasil.mitch.h.shuttle.de>
+
+Dr. Joachim Neudert <neudert@5sl.org> wrote:
+
+> > If you are not an addressee or otherwise authorized to receive this
+> > message, you should not use, copy, disclose or take any action based
+> > on this e-mail or any information contained in the message.  If you
+> > have received this material in error, please advise the sender
+> > immediately by reply e-mail and delete this message. Thank you.
+
+Bin ich eigentlich der einzige, der jedes Mal ueber diesen
+offensichtlichen Widerspruch grinsen muss?
+
+Ich hab erst letztens jemandem eine Mail geschrieben "Ich hab
+faelschlicherweise Ihre Mail erhalten und jetzt melde ich Ihnen das.
+Wie befohlen habe ich die Mail geloescht und vergessen, also fragen sie
+mich nicht, welche das war und um was es ueberhaupt ging"...
+
+Gruss,
+Christian
+
+-----------------------------------------------------------------------------
+
+
+
+Tubenausdruecker und Erbfolge (Ronda, 27. Jul 2008, 21:39:34):
+From: Konrad Wilhelm <Konrad.Wilhelm@web.de>
+Subject: Re: Tubenausdruecker
+Newsgroups: de.etc.haushalt
+Date: Fri, 25 Jul 2008 09:42:24 +0200
+Message-ID: <hq0j845vsd3hfeokt92nocmfdn65a85jmp@4ax.com>
+
+On Fri, 25 Jul 2008 09:13:49 +0200, Hermann Koeller
+<Exp20080731@hermann-koeller.de> wrote:
+
+> >Thomas Grueske <les_ich_nicht@freenet.de> wrote:
+> >
+>> >> Dass bestimmte Sonderfaelle selbstverstaendlich entsprechende
+Hilfsmittel
+>> >> rechtfertigen, mit meinem Einwurf zielte ich allerdings doch eher auf
+Otto
+>> >> Normaltubenausdruecker.
+> >
+> >Ich denke, auch die Lebenserwartung des Geraetes rechtfertig manchmal
+> >den Preis. Diesen Tubenausdruecker koennen Generationen verwenden.
+> >
+"Das Haus mit Grundstueck soll an den Tierschutzverein gehen, aber den
+hochwertigen Tubenausdruecker soll mein Enkel Karlchen haben, der sich
+in den letzten Jahren so aufopfernd um mich gekuemmert hat"
+
+k.
+
+-----------------------------------------------------------------------------
+
+
+
+Kleine Weinkunde (lang) (Ronda,  3. Aug 2008, 13:44:24):
+From: HaJo Hachtkemper <juli_zweitausendacht@newsgroups.02368.net>
+Date: Tue, 29 Jul 2008 12:31:16 +0200
+Subject: Re: Welche wiederkehrenden Schnaeppchen lohnen *nicht*?
+Newsgroups: de.alt.fan.aldi
+Message-ID: <g6n2il.354.1@newsgroups.02368.net>
+
+
+
+Ulf Volkert schrieb:
+> > "Chteau Migraine" hoert sich ja auch erst mal ganz gut an, wenn man
+> > nicht weiter drueber nachdenkt ...
+
+Aus aktuellem Anlass also hier die Wein-FAQ:
+
+Sie koennen mit verbundenen Augen den Unterschied zwischen Hefeweizen
+und einem 1952er Chateau Migraine erkennen? Die beiden Rebsorten "Rot"
+und "Weiss" sind fuer sie kein Geheimnis? Sie trinken Rotwein gerne zum
+Fisch, Hauptsache er ist schoen suess?
+
+Klasse, das langt vollkommen. Aber was passiert, wenn sie im Kreise
+wichtiger Freunde oder Bekannter in einem erlesenen Restaurant die
+Getraenke bestellen "duerfen" und nicht dastehen wollen wie mit offener
+Hose?
+
+Folgende Situation: Sie haben neulich bei ALDI einen billigen
+mazedonischen Rotwein fuer die Grillfete erstanden und hatten am
+naechsten Morgen so gut wie keine Kopfschmerzen? Glueck gehabt. Aber
+erwaehnen Sie nie im Gespraech mit Geschaeftsfreunden: "Also dieser
+Aldi-Rotwein fuer 2,19, der war ja sooo lecker." Man wird sie
+ausstossen, ignorieren und fuerderhin keine einzige Silbe mehr mit Ihnen
+wechseln.
+Korrekt heisst das: "Mein Importeur hat mir neulich einen rassigen
+Rotwein vom Balkan empfohlen. Ein einfacher Wein, aber zu
+Kurzgebratenem gut trinkbar."
+Sie sehen also, richtig formuliert, wirkt das gleich viel weniger
+peinlich.
+
+Uebrigens "Weinkenner", die behaupten Rebsorte, Jahrgang, Lage,
+Weingut, Haarfarbe des Kellermeistes etc. am Geschmack zu erkennen
+luegen. Mehr als Rebsorte evtl. noch Region geht meist nicht. Nur
+langjaehrig erfahrene Triebtrinker koennen ihre Erfahrung einbringen und
+"alte Freunde" wiedererkennen.
+Ebenso sind Verallgemeinerungen wie: "Frankenwein ist immer trocken"
+oder "Moselwein hat mehr Saeure" normalerweise voellig an den Haaren
+herbeigezogen. Daran erkennt man den Blender. Solche Menschen lassen
+wir gekonnt auflaufen. Das Anbaugebiet Baden ist z.B. so vielfaeltig,
+dass hier eigentlich gar keine allgemeine Einordnung moeglich ist.
+
+Klugscheisserinfos:
+Faellt der Begriff "Schwarzriesling" so erwaehnen wir beilaeufig, dass es
+sich dabei um gar keinen Riesling, sondern um einen "Pinot Meunier"
+buergerlich: "Muellerrebe" handelt.
+Barriqueausbau: Weine, die im Holzfass ausgebaut werden kommen immer
+mehr in Mode. Sie bekommen meist keine Praedikate etc. da sie nicht
+mehr sortentypisch, gebietstypisch usw. schmecken.
+Rioja ist ein spanisches Anbaugebiet, keine Rebsorte.
+Q.b.A bedeutet "Qualitaetswein bestimmter Anbaugebiete", Analog zu
+auslaendischen Qualitaetsstufen (z.B. D.O.C.). Q.b.A ist kein Praedikat!
+
+Fassen Sie Weinglaeser immer am Stiel an. Nichts ist peinlicher, als
+Fettfinger am Kelch. Wein duftet, schmeckt und sieht nett aus, das
+Gehoer stimulieren wir durch das Anstossen. So werden unserer Ohren mit
+einem glockenhellen "Ping" auf den Genuss eingestimmt. Proletenfalle:
+Packt man das Glas am Kelch ertoent bei der Kollision der Glaeser nur
+ein plumpes "Pock". Glaeser mit kleinem Kelch sind fuer Weisswein, die
+mit grossem Kelch fuer Rotwein. Ueber die Glasqualitaet kann man
+genausoviel debattieren wie ueber die des Weines. Bleikristall ist
+uebrigens pfui, ebenso gefaerbtes oder aufwendig geschliffenes Glas,
+weil die Weinfarbe dann nicht mehr begutachtet werden kann. Falls man
+Ihnen ein typisches regionales Glas, z.B. einen Roemer reicht, loben
+sie den erfrischend folkloristischen Ansatz. Das zeigt, dass Sie
+wissen, dass so ein Glas Unfug ist, aber den Wirt nicht beleidigen
+wollen. Solche Glaeser nimmt man nur um sich schnell und unkomplizert
+die Lichter auszuschiessen.
+
+Eine Sektschale weisen wir pikiert zurueck, nur im hohen Sektglas kann
+man die Perlage in ihrer vollen Schoenheit bewundern. Man ist ja Aesthet.
+
+Sollten Sie in die Lage kommen den Wein ordern zu muessen befolgen Sie
+die Faustregel: Helles Fleisch: Riesling, dunkles Fleisch: Bordeaux.
+Die Chance damit daneben zuliegen geht gegen 0. Auf jeden Fall wird
+niemand Einspruch erheben, da er oder sie sonst in Erklaerungsnotstand
+geraet.
+
+Riesling ist die Perle des deutschen Weines, er hat eine angenehme
+Farbe, eine vielschichtiges Aroma, feinnervige Saeure, ausserdem muss man
+danach nicht so furzen. Bei Riesling-Bestellung erwaehnen Sie: "Den
+ewigen "Pinot Grigio" ("Chardonnay" falls ihr Gegenueber aus Italien
+kommt) kann man ja langsam nicht mehr sehen. Vorsicht: Grauburgunder
+und Rulaender sind dasselbe wie "Pinot Grigio"!
+
+Bei Bordeaux-Bestellungen: "Die "Rioja"- ("Barolo" falls Sie zu einem
+Spanier sprechen) Euphorie legt sich ja zum Glueck langsam wieder."
+
+Nie einen "halbtrockenen" Wein bestellen, das ist genauso peinlich wie
+"ros", ausser sie wollen betont Liberalitaet gegenueber gewissen
+Sexualgewohnheiten signalisieren. Zum Essen trinkt man trockenen Wein,
+zum Dessert suessen, Punkt. Sollte Ihr Mitesser aus der Provence kommen
+ist allerdings Vorsicht mit Ressentiments gegenueber Ros-Weinen
+angebracht.
+
+Rotling oder Schillerwein (Wuertemberg) ist eine andere Bezeichnung fuer
+einen aus Weiss- und Rotwein gemischten "Ros".
+
+Bestellen Sie immer einen moeglichst alten Wein wenn es um Rotwein geht
+(ausser sie muessen zahlen). Bestellen Sie einen 2-4 Jahre alten Wein
+wenn es sich um Weisswein handelt.
+
+Bestellen Sie nie offene Weine, immer eine ganze Flasche. Wenn das
+ueberhaupt geht, viele kleinere Weinstuben bekommen ihren Rebensaft
+naemlich in Schlaeuchen (s.u.) geliefert (das ist aber kein unbedingter
+Qualitaetsnachteil). Das Risiko bei offenen Weinen ist, dass man schon
+mal einen spanischen Leberkiller als lecker Rioja vorgesetzt bekommt.
+
+Schnueffeln sie am Kork wenn sie wollen, aber seien sie sich der
+Tatsache bewusst, dass er in den meisten Faellen nach Kork riecht (so
+isser halt). Nur wenn er muffelig riecht ist Vorsicht geboten, ein
+erster vorsichtiger Schluck bringt dann den Beweis.
+
+Das Dekantieren des Weines, also das Umfuellen in eine Karaffe dient
+haupsaechlich dazu, das Depot, also abgelagerte Feststoffe vom Wein zu
+trennen. Dazu legt man die Flasche vor dem Dekantieren einige Zeit
+schraeg, das Depot kann sich dann am Flaschenboden sammeln. Beim
+Umgiessen, Profis stellen dabei eine Kerze unter den Flaschenhals,
+stoppt man, bevor die Brocken in die Karaffe fliessen.
+
+Weissweine dekantiert man im allgemeinen nicht, da sie weniger
+Feststoffe enthalten und Oxidation durch zuviel Sauerstoff den
+Geschmack eher beeintraechtigt (in Richtung Sherry). Bei Rotweinen ist
+eine leichte Oxidation dem Geschmack oft zutraeglich, bei alten
+Flaschen (nicht Loddar M.) hat der Wein oft waehrend der Lagerung schon
+durch den Korken geatmet. Hier kann der "Sauerstoffschock" dem Wein
+den Rest geben.
+
+Lesen Sie die Jahreszahl auf dem Etikett. Das ist nicht das
+Verfallsdatum, sondern das Jahr der Ernte (der Kenner sagt allerdings
+"Lese").
+
+Junger Bordeaux hat in etwa den Tanningehalt von Gerberlohe. Sollte
+also jemand einen Wein aus dem Bordelais ordern, der weniger als 5
+jahre alt ist, bestellen Sie lieber ein Pils. Oder beklagen Sie
+lautstark den hohen Gehalt an Polyphenolen.
+
+Die deutschen Weinetikette sind sehr undurchsichtig. Keine Sau weiss,
+ob sich hinter einem "Oppenheimer Nierentritt" eine Perle der Oenologie
+oder ein hinterhaeltiger Angriff auf unsere Gesundheit verbirgt. Die
+Lage des Weines sagt nichts ueber seine Qualitaet aus. Ob fuerstliche
+Domaene im Reingau oder Bahndamm Nordseite aus Friesland, lassen sie
+sich nicht blenden, wenn andere mit Lagenbezeichnungen um sich werfen.
+
+Was zaehlt sind bei deutschen Weinen die Praedikate, unter Q.b.A. geht
+nix. O.b.A ist selbst allerdings noch kein Praedikat, sondern sagt nur
+aus, dass der Erzeuger nachweisen kann, wo seine Trauben gewachsen
+sind. Bei Tafel- und Landweinen ist originelle Artenvielfalt in einer
+Flasche durchaus keine Seltenheit.
+
+Wenn sie einmal aus einem "Bocksbeutel" einschenken muessen: Etikett
+nach oben, vier Finger unter die Flasche, Daumen auf die Flasche. Wein
+im Bocksbeutel ist uebrigens mindestens Qualitaetswein (Q.b.A).
+
+Es ist wissenschaftlich verbuergt, dass die wichtigsten
+Geschmacksinformationen ueber das Auge transportiert werden. Was auf
+dem Etikett steht wird geglaubt. Wenn da "trocken" steht, ist der Wein
+trocken, auch wenn sich Zuckerkristalle im Glas absetzen. Praktisch
+jeder Wien geht als "halbtrocken" durch, ausser er greift schon das
+Glas an.
+
+Wir bestellen grundsaetzlich Bordeauxweine, die sind normalerweise am
+Wort "Chateau" auf dem Etikett zu erkennen. Im Bordelais herrscht ein
+relativ strenges Klassifizierungssystem, das dem Kenner ermoeglicht den
+Wein genau einzuordnen und dem Weinbauern die Freiheit laesst zu
+panschen was das Zeug haelt. Franzoesische Weine werden in der Regel mit
+Zucker versetzt, dass es nur so kracht. Man nennt das dort allerdings
+"chaptalisieren". Bei uns ist das Chaptalisieren nur bei Weinen ohne
+Praedikat erlaubt. In eine Spaetlese darf also kein Zucker rein.
+Ein echter Bordeaux besteht aus ca. 3 verschiedenen Weinen, die
+assembliert werden. Dadurch befinden sich soviele Aromen in dem Stoff,
+dass man mit seiner Geschmackseinschaetzung nie voellig daneben liegen
+kann. Gut klingen immer: Cassis (schwarze Johannisbeere), Zimt,
+Vanille, Zigarrenkistenholz, Kaffeebohne; aber so ziemlich jede
+Geschmacksrichtung die Sie auch von der Eisbude kennen, koennen sie
+nennen (Vorsicht mit "Straciatella").
+
+Wenn sie nicht die Flasche gesehen haben beschweren sie sich nicht
+ueber den korkigen Geschmack, der Wein koennte aus einem Schlauch
+abgefuellt sein (PVC-Behaelter mit integriertem Zapfhahn) und nichts ist
+peinlicher wenn der Kellner den Besserwisser korrigiert. (schon selbst
+miterlebt, ehrlich).
+
+Sprechen sie nie vom Geschmack, sondern vom Bukett oder von den
+Aromen. Es gibt primaere, sekundaere, tertiaere Aromen. Am schoensten sind
+die postfermentativen Aromen, also diejenigen, die durch die Lagerung
+entstehen. Obacht: Wenn Sie sich darauf beziehen sollte nicht 2003 auf
+dem Etikett stehen.
+
+Weisswein sollte kalt, Rotwein bei Zimmertemperatur getrunken werden.
+Zimmertemperatur bedeutet nicht 22 Celsius, sondern 18 C. Frueher
+waren die Menschen nicht so verweichlicht wie wir heute. Mein
+Kuehlungstipp: Rotwein 1/4h vor den servieren in den Kuehlschrank legen,
+Weisswein 1/4h vor dem servieren herausholen.
+
+HTH
+
+Ciao/HaJo
+
+-----------------------------------------------------------------------------
+
+
+
+Der gruene Pfeil und der Untergang der Zivilisation (oder so aehnlich) (Ronda,  3. Aug 2008, 13:46:53):
+From: Ren <Kar98@The-Coalition.US>
+Subject: Re: Lustige Denglisch-Bluete
+Newsgroups: de.etc.sprache.deutsch
+Date: Sun, 27 Jul 2008 21:17:00 -0500
+Message-ID: <2008072721170050878-Kar98@TheCoalitionUS>
+
+>> >> Die Diskussion dort (und beim Thema Gruener Pfeil) erinnerten mich
+
+In vielen Laendern der Welt, unter anderem auch 
+in Texas und Restamerika gilt: an einer roten Ampel ist es ohne 
+weiteres erlaubt, nach Halt und unter Gewaehrung der Vorrangs der 
+Verkehrsteilnehmer, die gruen haben, nach rechts abzubiegen. Reduziert 
+Wartezeiten und beschleunigt den Verkehrsfluss erheblich, ist einfach, 
+unbuerokratisch und unkompliziert.
+
+In Deutschland: aus den kuerzlich angeschlossenen Provinzen kommt die 
+Idee, dies durch Anbringen eines Blechschildes an einigen besonderes 
+geeigneten Kreuzungen ausnahmsweise zu erlauben, und es erhob sich 
+Wehgeschrei und da war Heulen und Zaehneklappern. Zu kompliziert, weil 
+nicht kompliziert genug, hamma ja noch nie so gemacht, zu gefaehrlich, 
+der Verein der Dackelsammler und Briefmarkenliebhaber wendet ein, dass 
+sie ab sofort Blinde ueber den Haufen kegeln muessten, wenn dies 
+eingefuehrt wuerde, weil Regel ist Regel, und wenn sie duerften, dann 
+wuerden sie aber auch, und zwar ohne Ruecksicht auf Verluste. Die 
+Forschungsgesellschaft fuer Strassen- und Verkehrswesen (FGSV) gibt die 
+Teilfortschreibung 2003 der Richtlinien fuer Lichtsignalanlagen (RiLSA) 
+heraus, mit 25 Abbildungen und 18 Tabellen, und bei der ARD nimmt sich 
+das Wort zum Sonntag des Themas an: "Liebe Zuschauer, rechts abbiegen 
+bei rot: Vereinfachung durch mehr und kompliziertere Regeln. Will Gott 
+uns, schon wieder einmal, pruefen?"
+
+Ich seh's ja ein: Deutschland ist in etwa so gross wie Nordost-Texas, es 
+leben 800 Milliarden Menschen auf diesem Gebiet, da braucht man Regeln 
+und Vorschriften. Genau deswegen lebe ich nun mal in Texas, wo sich 
+Armadillo und Klapperschlange gute Nacht sagen. Und wenn einem mal 
+wieder die Baptistenweiber nachstellen, oder das Dach schon wieder 
+leckt, dann suche ich mir eine beliebige Diskussion auf der dt. 
+Wikipedia aus, oder schaue bei SPON vorbei, und schon langts mir mal 
+wieder fuer ein weiteres Jahr.
+
+Neulich hatte ich wieder einen Alptraum: ich musste ein Auto durch den 
+TUeV bringen, versichern und anmelden, und das, obwohl ich nirgendwo in 
+DE mehr gemeldet bin. Als ich schreiend aufwachte, guckte mich die 
+Rottweilerin gross an und es war eh schon wieder Zeit, sie rauszulassen. 
+Kaffee gekocht, auf die Veranda gesetzt, und den Kolibris, Gekkos, 
+Kardinaelen, Mexikanern, Eichhoernchen zugeguckt :-)
+
+-----------------------------------------------------------------------------
+
+
+
+Irgendwie wie hier im Mud... (Ronda,  3. Aug 2008, 13:49:01):
+... jedenfalls erinner ich mich noch heute an die Diskusson mit einem Magier,
+der "vorn" und "hinten" an einer gewissen Wueste "kreativ" umgesetzt hat - und
+meinen direkt daraus resultierenden Tod, weil ich deswegen einem Loewen direkt
+wieder in den Rachen spaziert bin.
+
+Amen,
+
+Ronda
+
+From: Thomas Schade <toscha@rrr.de>
+Subject: Re: Zukunft
+Newsgroups: de.etc.sprache.deutsch
+Date: Sun, 27 Jul 2008 12:54:10 +0200
+Message-ID: <488C53D2.2020406@news.toscha.de>
+
+> > Das kann man sich doch einfach merken: Im Fruehjahr stellt man die
+> > Gartenmoebel vor das Haus, im Herbst wieder nach hinten.
+
+Das finde ich verwirrend. Bei uns stehen die Gartenmoebel im Sommer auf
+der Terrasse. Die aber befindet sich *hinter* dem Haus. *Vor* dem Haus
+ist der Gehweg, der zur Haustuer fuehrt.
+
+Mir ist klar, dass vielfach 'vor' und 'hinter' vom Standpunkt des
+Betrachters abhaengen.[1] Aber wo noch wird der Bereich des Gartens und
+der Terrasse als 'vor dem Haus' empfunden?
+
+[1] In meiner Pruefung zum PKW-Fuehrerschein wurde ich vom Pruefer
+angewiesen 'und jetzt parken Sie noch vor dem Auto da vorn'. Ich
+passierte also den parkenden Wagen, unter Aktivierung der Schweissdruesen,
+als sich herausstellte, dass die Luecke vor dem Wagen nur marginal groesser
+war als der Fahrschul-Peugeot. Dennoch gelang mir ein passables
+Einparkmanoever, zur Freude des Fahrlehrers und zum Entzuecken des
+Pruefers. Der allerdings meinte dann recht trocken, warum haben Sie es
+sich so schwer gemacht und haben hinter dem Wagen geparkt? Mir haette die
+grosse Luecke vor dem Wagen gerreicht. Da ich das Fuehrerscheindokument
+noch nicht in den Haenden hielt, ersparte ich mir in der Situation die
+Diskussion darueber, wieso fuer ihn 'vor dem Auto' zum Einparken dahinter
+haette fuehren sollen.
+
+Klar ist mir das uebrigens bis heute nicht.
+
+-----------------------------------------------------------------------------
+
+
+
+Aachener Ingenieure (Ronda,  3. Aug 2008, 13:51:10):
+From: Matthias Botzen <matthias.botzen@rwth-aachen.de>
+Newsgroups: rwth.general
+Subject: Re: Semesterticket nicht bezahlen ?
+Date: Sun, 27 Jul 2008 12:47:47 +0200
+Message-ID: <6f323cF9j8n0U1@mid.dfncis.de>
+
+Marco Lierfeld schrieb:
+> > 
+> > Am Samstag, den 26.07.2008, 08:38 -0700 schrieb pir@p3-solutions.de:
+>> >> Hallo Leute,
+>> >>
+>> >>    ich zahle wie alle andere den Studentenbeitrag + Studiengebuehren im
+>> >> Hoehe von etwa 650. Dabei ist mir eingefallen dass ich jede Semester
+>> >> fast 100 ? fuer das Semesterticket zahlen muss, obwohl ich waehrend
+> > 
+> > Du studierst auch E-Technik, nicht wahr? Oder zumindest was
+> > ingenieurmaessiges. Du rundest jedenfalls recht grosszuegig: 81,65 EUR [1]
+> > sind eher "fast 80 EUR" als "fast 100 EUR", finde ich.
+> > 
+
+Ich wuerde ja eher auf Physik tippen, die Zehnerpotenz stimmt.
+
+mfg
+matthias
+
+-----------------------------------------------------------------------------
+
+
+
+Verkaufsautomaten in Schulen (Ronda, 23. Aug 2008, 18:08:38):
+[SN: leicht gekuerzt]
+
+From: gerrit.brodmann@gmx.de (Gerrit Brodmann)
+Newsgroups: de.etc.beruf.selbstaendig
+Subject: Re: Verkaufsautomat in der Schule
+Date: Wed, 20 Aug 2008 11:20:27 GMT
+Message-ID: <48b1fdd5.606175078@news.arcor.de>
+
+Martin Hentrich <taxcel@aol.com> wrote:
+
+> >On Tue, 19 Aug 2008 15:07:29 -0700 (PDT), Kai
+> ><kai.hartmann@googlemail.com> wrote:
+> >
+>> >>Gibt es beim Aufstellen von Automaten in Schulem,
+>> >>Universitaeten, Hochschulen besondere Huerden, auf die
+>> >>man achten sollte? Besondere
+>> >>Richtlininen oder so etwas?
+
+[...]
+
+> >Was soll der Automat denn verkaufen? Getraenke, Suesskram oder
+> >Kondome?
+
+Loesungsblaetter fuer Klausuren, Hausaufgaben und
+Entschuldigungsschreiben/Atteste
+
+Das waere eine Goldgrube 8-)
+
+-----------------------------------------------------------------------------
+
+
+
+Oh ja, oh ja... DAS kennt man... (Ronda, 23. Aug 2008, 18:09:08):
+From: Dieter Bruegmann <dieterbruegmann@gmx.net>
+Subject: Re: Deutsch - Microsoft Gold Certified!
+Newsgroups: de.etc.sprache.deutsch
+Date: Tue, 19 Aug 2008 17:23:46 +0200
+Message-ID: <g8evj3.2i0.2@funk.bruhaha.de>
+
+[SN: Auf den lustigen Teil eingedampft.]
+> > ... ist es eine sinnvolle Strategie, immer auf den ersten passenden 
+> > Knopf zu druecken, ohne sich durch Lektuere der uebrigen zu versichern, 
+> > dass es der passendste angebotene ist?
+
+Ein gestresster User soll mal auf die Frage nach der Fehlermeldung
+geantwortet haben: "Wir haben hier nicht die Zeit, alles zu lesen, was
+auf dem Bildschirm erscheint!"
+
+-----------------------------------------------------------------------------
+
+
+
+Kreisverkehre und Nationalitaeten (Ronda, 23. Aug 2008, 18:10:32):
+... sagte ich schon, dass Belgier GANZ besonders Auto fahren...?
+
+Ronda
+
+Von: "Hans-Bernhard Broeker" <HBBroeker@t-online.de>
+Newsgroups: oecher.talk
+Betreff: Re: Vorfahrt am Suermondtplatz
+Message-ID: <g84rn0$nj1$00$1@news.t-online.com>
+
+Jeroen Thijs > wrote:
+
+> > Und wie waere es mit folgender Regelung beim Einfahren:
+> > erste raus->blinker rechts
+> > zweite raus (geradeaus)->kein Blinker
+> > dritte raus (links)->blinker links
+  > Beim Ausfahren immer rechts blinken.
+
+Das ist in auch in Frankreich (wohl einem der in Kreisverkehre
+vernarrtesten Laender ueberhaupt) so Vorschrift, und m.E. die optimale
+Loesung.  Damit sie optimal wirkt, braucht es allerdings zusaetzliche
+Annahmen, die nicht zuverlaessig erfuellt sind:
+
+1) die Mehrheit der Autofahrer muss ausreichend Alltagserfahrung mit
+Kreisverkehren bekommen, dass sie automatisch damit umgehen, statt sich
+erst mal zu erschrecken.  In Deutschland ist die Reaktion leider nur zu
+oft: "Huch!  Aehh --- warum ist denn da ein Erdhindernis auf der
+Kreuzung?"  Damit ist es voellig egal, wie die Blinkregeln lauten --- bis
+die dem Fahrer wieder eingefallen sind, atmet er schon durch Airbags.
+
+2) die Mehrheit der Autofahrer muesste sich ueberhaupt mal aktiv daran
+erinnern, dass Blinken nicht etwa nur eine verzichtbare Nettigkeit,
+sondern _Pflicht_ ist.  Dies ist der Punkt, in dem die Franzosen die
+Vorteile jeglicher Regelung zunichte machen, denn sie betrachten Blinken
+offenbar als eine im Ausland grassierende Geisteskrankheit, gegen die
+sie selbst gluecklicherweise immun sind.  Ich denke es hat schon seinen
+Grund, dass die Franzosen die letzten Autobauer in Europa waren, die
+selbsttaetig zurueckspringende Blinkerhebel einfuehrten: deren Vorteile
+konnte man zuhause einfach niemandem verstaendlich machen :-)
+
+-----------------------------------------------------------------------------
+
+
+
+Ich lese zu viel Englisch... (Ronda, 23. Aug 2008, 18:11:19):
+[Anm.d.Einr.: besonders pikant (Wortspiel beabsichtigt) ist, dass der
+ Absender ein Berufskoch ist.]
+
+Message-ID: <1illpfv.1vsmyai1qawqtlN%kscheller@ochs.franken.de>
+From: kscheller@ochs.franken.de (Konni Scheller)
+Newsgroups: de.alt.sysadmin.recovery
+Subject: ich lese zu viel englisch
+Date: Wed, 13 Aug 2008 07:44:43 +0200
+
+Hi,
+
+gestern hab ich mich ernsthaft gefragt, was fuer eine Taetigkeit wohl
+"brathering" ist. Kurz bevor ich mich ueber die Anglisierung der Plakate
+im Supermarkt aufregen konnte, ist es mir dann doch eingefallen. 
+
+Ich brauch dringend Urlaub. 
+
+Servus,
+Konni
+
+-----------------------------------------------------------------------------
+
+
+
+Mal was anderes: Schuhe zubinden. (Ronda, 23. Aug 2008, 18:14:53):
+Artikel ist nicht sonderlich witzig (oder?) aber praktisch. Die darin
+verlinkte Seite hat u.a. einen interessanten Artikel (
+http://www.fieggen.com/shoelace/slipping.htm ) in dem beschrieben wird, was
+"Granny Knots" sind - dabei stellte ich fest, warum meine Knoten nicht gut
+gehalten haben. Erspart mir Doppelknoten ;-)
+
+Ronda
+
+From: Bodo Moeller <bmoeller@acm.org>
+Newsgroups: de.alt.sysadmin.recovery
+Subject: Re: Was zum Daddeln....
+Date: 12 Aug 2008 23:13:43 GMT
+Message-ID: <slrnga4697.c2j.bmoeller@tau.invalid>
+
+Andreas Dau <dev.null@andreasdau.de>:
+> > Arnim Sommer schrieb:
+>> >> Ignatios Souvatzis schrieb:
+>>> >>> Bodo Eggert wrote: 
+
+>>>> >>>> Runde Schuhbaender sind selbstloesend.
+
+>>> >>> Ihr muesst nur den Kreuzknoten richtig machen - dann loest er sich
+nicht
+>>> >>> bei wechseldner Beanspruchung. (Ob man den nun auf Slip macht oder
+nicht,
+>>> >>> ist dabei nebensaechlich.)
+
+>> >> http://tinyurl.com/5ktquo zeigt, wie es geht...
+
+> > Ja, genau so, wie Ignatios schrub:
+> > ,---<ibd.>---
+> >| Die sicherste Schleife ist ein doppelt auf Slip gelegter Kreuzknoten:
+> >
+> > Du kannst einem Segler im Allgemeinen schon glauben, wenn er Dir was zu 
+> > Knoten sagt.
+
+Das mag ja im allgemeinen so sein - die sicherste Schuhschleife
+allerdings ist nicht ein doppelt auf Slip gelegter Kreuzknoten,
+sondern der Knoten mit Ashley-Nummer 1219 (doppelter Slipknoten); das
+ist ungefaehr das gleiche, aber mit einem doppelt auf Slip gelegten
+doppelten Ueberhandknoten als Abschluss statt des doppelt auf Slip
+gelegten einfachen Ueberhandknotens.
+
+Klingt kompliziert? Ist es aber nicht:
+
+http://www.fieggen.com/shoelace/secureknot.htm
+
+-----------------------------------------------------------------------------
+
+
+
+Mein Geschirrspueler redet nicht mit mir! (Ronda, 23. Aug 2008, 18:15:49):
+From: Thomas Heuving <heuving@gmx.de>
+Subject: Re: Geschirrspueler: Salz- und Klarspueler-Leuten brennen immer
+Date: Tue, 12 Aug 2008 21:06:22 +0200
+Message-ID: <ei39n5-6k8.ln1@ID-32009.user.uni-berlin.de>
+
+Martina Diel schrieb am Mon, 11 Aug 2008 15:33:21 +0200:
+
+> > was hat es eigentlich zu bedeuten, wenn die Salz- und
+> > Klarspueler-Leuchten am Geschirrspueler *immer* leuchten, egal, wieviel
+> > Salz und Klarspueler man nachfuellt? 
+
+"Ich weiss, dass du meine Bedienungsanleitung weggeworfen hast."
+
+-----------------------------------------------------------------------------
+
+
+
+Warum sind alte IBM Tastaturen so gut? (Ronda, 23. Aug 2008, 18:18:00):
+ 
+Signatur hat auch was... muss doch grad mal die Mentos im Dunkeln suchen und
+die Petshop Boys auflegen.
+
+Ronda
+
+Subject:     Re: Warum sind alte IBM-Tastaturen so gut?
+From:        Bjoern Guenther <bjoern@ebgonline.de>
+Newsgroups:  de.alt.folklore.computer
+Message-ID: <g7aap3.2bo.1@bjoern.ebgonline.de>
+Date:        Tue, 05 Aug 2008 19:47:47 +0200
+
+Hallo,
+
+Martin Peters <martin.peters@news.uni-stuttgart.de> schrieb:
+
+> >* hervorragendes Anschlagverhalten
+
+Deswegen solltest Du sowas nicht nach USA mitnehmen.
+
+Bjoe-SCNR-rn
+-- "Computer games don't affect kids; I mean if Pac-Man affected us as kids,
+we'd all be running around in darkened rooms, munching magic pills and
+listening to repetitive electronic music." --Kristian Wilson, Nintendo, Inc,
+1989. 
+
+-----------------------------------------------------------------------------
+
+
+
+Ich war gegen den Urknall, aber keiner hats gehoert! (Ronda, 23. Aug 2008, 18:18:36):
+From: Oliver Cromm <lispamateur@yahoo.de>
+Subject: Re: Gekrischen u.a.
+Newsgroups: de.etc.sprache.deutsch
+Date: Thu, 31 Jul 2008 14:06:49 -0400
+Message-ID: <udxesfq0kuzp$.dlg@mid.crommatograph.info>
+
+* Jakob Achterndiek <achterndiek@buzemann.net> wrote:
+
+> >Am 31.07.2008, 19:18 Uhr, schrieb Oliver Cromm <lispamateur@yahoo.de>:
+> >
+>> >>Andere Voelker (Koreaner, Islaender) kennen ihre Familiengeschichte fuer
+>> >>1000 Jahre oder mehr.
+> >
+> >Auch aus dem baltischen Adel wird der Satz kolportiert:
+> >"Als GOtt der HErr die Welt erschuf, da stand mein Ahn
+> >daneben - und der war schon degeneriert."
+
+Ich war ja damals strikt gegen den Urknall.
+-- Pentiums melt in your PC, not in your hand. 
+
+-----------------------------------------------------------------------------
+
+
+
+Makaber: Friedhofsmobil (Ronda, 23. Aug 2008, 18:19:14):
+Newsgroups: ka.lauer
+Subject: Sargkarren jetzt endlich auch in Karlsruhe?
+From: Michael Kauffmann <news@ikar.us>
+Date: Thu, 7 Aug 2008 19:50:58 +0200
+Message-ID: <g7fcl6$mv5$1@online.de>
+
+Seit einem Monat gibt es auf dem Hauptfriedhof einen Fahrdienst fuer
+gebrechliche Besucher. Der Aushang vor Ort drueckt das so aus:
+
+"Das Friedhofsmobil bringt Personen, die nicht mehr laufen koennen,
+zu ihrem Grab."
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Mal was anderes: Schuhe zubinden. (Zook, 25. Aug 2008, 08:50:46):
+~#! rn=Ronda rt=1219508093 rg=schmarrn.netdigest
+~#! tid=1219508093
+Is nich wahr, Ronda, oder? 
+Z
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Makaber: Friedhofsmobil (Darklor, 29. Aug 2008, 17:29:50):
+~#! rn=Ronda rt=1219508354 rg=schmarrn.netdigest
+~#! tid=1219508354
+Coole Werbung ;)
+
+Darklor
+
+-----------------------------------------------------------------------------
+
+
+
+Fuehrende Nullen in SQL und Oesterreich (Ronda, 21. Sep 2008, 01:53:40):
+Date: Sat, 20 Sep 2008 00:18:47 +0200
+From: Roland Spielhofer <rspiel@gmx.net>
+Newsgroups: de.comp.datenbanken.misc
+Subject: Re: PLZ als Text, dann als Zahl, dann noch Bedingung...
+Message-ID: <48d42541$0$10578$3b214f66@usenet.univie.ac.at>
+
+sim wrote:
+> > [...]
+>> >> SELECT num_plz FROM (SELECT TO_NUMBER(plz) AS num_plz FROM table
+>> >> WHERE TRANSLATE (plz, '0123456789', '.') IS NULL)
+>> >> WHERE TO_NUMBER(num_plz) > 1000 AND TO_NUMBER(num_plz) < 2000 ORDER BY
+>> >> num_plz;
+>> >>
+>> >> liefert auch das gewuenschte.
+>> >>
+>> >> *am kopf kratz und trotzdem freu*
+>> >> Roland
+
+> > Dumm nur, wenn PLZ mit 0 anfangen (neue Bundeslaender)...
+
+> > Joerg
+
+nicht schlimm, ich brauch die Bereich fuer Oesterreich. Wir haben keine 
+fuehrenden Nullen - jedenfalls nicht in den Postleitzahlen ;-))
+
+roland
+
+-----------------------------------------------------------------------------
+
+
+
+*hicks* (Ronda, 21. Sep 2008, 01:54:10):
+From: Dorothee Hermann <DorotheeHermann@gmx.net>
+Newsgroups: de.alt.fan.aldi
+Subject: Re: Der Vormarsch der H-Milch, jetzt leider auch bei Penny
+Date: Wed, 17 Sep 2008 22:52:51 +0200
+Message-ID: <6jd8trF2opfkU2@mid.individual.net>
+
+Matthias Langer schrieb:
+> > Henning Sponbiel schrieb:
+>> >> Zumindest fuer die Leute, die das nach Hause schleppen (oder auch
+>> >> mehrere Treppen hochschleppen) muessen, sind die leichten
+>> >> Kunststoffflaschen deutlich angenehmer als die Glasflaschen.
+
+> > naja meine Sorte die im meist drinke hat mein Haenler bloss in
+Glasflaschen,
+> > aber zum Glueck gibts ja Fahrstuehle
+
+;-) Mh - was war in der Flasche denn drin, die Du vor dem Schreiben
+schon getrunken hast?
+
+
+Dorothee
+
+-----------------------------------------------------------------------------
+
+
+
+MaxDude (Ronda, 21. Sep 2008, 01:55:14):
+From: Thomas Schade <toscha@rrr.de>
+Subject: Re: Penisvergroesserung Pillen
+Newsgroups: de.etc.sprache.deutsch
+Date: Wed, 17 Sep 2008 22:49:04 +0200
+Message-ID: <48D16D40.2040003@news.toscha.de>
+
+[SN: Zitat ergaenzt]
+On 17.09.2008 22:47, Dorothee Hermann wrote:
+> > happy00100frog@yahoo.com schrieb:
+
+>> >> MaxDude ist wirklich die beste Penisvergroesserung Pille Sie finden
+>> >> koennen. ...
+
+>> >> Verwenden Sie MaxDude regelmaessig und sehen den sichtbaren Unterschied
+>> >> in Ihrem Mitglied. 
+
+> > *schmunzel*
+> > Aus Versehen eine nette Umschreibung gefunden ;-) und (vielleicht)
+> > deshalb nicht ganz unpassend in dieser NG.
+
+Da finde ich das aber beunruhigender:
+| Gain Zoll und lassen Sie Ihre Sexualleben einfach ausschalten.
+
+-----------------------------------------------------------------------------
+
+
+
+Verkehrssicherheit mal anders (Ronda, 21. Sep 2008, 01:57:09):
+[SN: Das Zitat stammt aus einem Schreiben des Bundesverkehrsministeriums]
+
+
+Newsgroups: de.rec.fahrrad
+From: Hans Altmeyer <zoo666@web.de>
+Subject: Re: Radsymbol in Fussgaengerampel - gibts 
+Date: Mon, 15 Sep 2008 00:32:03 +0200
+Message-ID: <gak3d1$kqf$1@newsreader2.netcologne.de>
+
+Hans schrieb:
+> > Die Antwort war:
+> > 
+> > "[...] Die 
+> > sorge, dass Kraftfahrzeuge (Kfz) auf Radfahrer, die die Fahrbahn 
+> > benutzen, auffahren koennen, halte ich allerdings fuer unbegruendet. Denn 
+> > Kfz, die hinter einem Radfahrer fahren, muessen einen ausreichenden 
+> > Sicherheitsabstand zum Radfahrer einhalten. [...]"
+
+Das eroeffnet ganz neue Perspektiven fuer die Verkehrssicherheit: Unfaelle 
+werden in Zukunft verboten. Und an Unfallschwerpunkten werden sie 
+strengstens verboten. Dann kann nichts mehr passieren, weil ja in der 
+StVO steht, dass niemand einen Unfall verursachen darf. Wenn wir das 
+Ministerium nicht haetten!
+
+Gruss, Hans
+
+-----------------------------------------------------------------------------
+
+
+
+Nervige Fragen beim Einkaufen - und das Plopp im Baumarkt (Ronda, 21. Sep 2008, 01:59:13):
+Subject: Nervige Fragen beim Einkaufen...
+From: Uwe Weiss <uweiss@web.de>
+Date: Wed, 10 Sep 2008 22:59:01 +0200
+Message-ID: <6iqqo7F3g11U1@mid.individual.net>
+Newsgroups: de.talk.jokes
+
+Was ich schon immer mal antworten wollte - auf die nervigen Fragen beim 
+Einkaufen, aber mich nie getraut habe.
+
+
+In der Baeckerei:
+ICH: Ich haette gern 2 Koernerbroetchen, 2 Mohnbroetchen, 2 "normale" und 
+ein Rosinenbroetchen.
+VK: Wiederholt meine Bestellung, und dann: haben Sie sonst noch einen 
+Wunsch?
+ICH (trau mich nicht): Wieso? Bist Du 'ne Fee, oder was?
+
+Im Schuhgeschaeft:
+ICH ... sag gar nix. Ich schau mir die Regale an, passend zu meiner 
+Schuhgoesse. Und suche Schuhe, die mir gefallen.
+VK: Kann ich Ihnen helfen?
+ICH (trau mich nicht): wobei?
+
+Am Mc-Drive:
+Lautsprecher: Willkommen ... blabla ... Ihre Bestellung bitte?
+ICH: 2 Cheeseburger!
+LS: 2 Cheeseburger. ... (Ein) Getraenk dazu?
+ICH (trau mich nicht): Oh Mann! Super Idee! Warum bin ich da nicht 
+selber drauf gekommen? Ich Idiot verdurste hier fast, und bestell kein 
+Getraenk!!!
+
+
+Da lob ich mir die Baumarkt-Gespenster, die - wenn man sie mal zu 
+Gesicht bekommt - einem ein "Sie kommen zurecht!" (keine Frage, sondern 
+eine Feststellung) zurufen, und es dann irgendwie schaffen, sich in Luft 
+aufzuloesen, ohne dass es "Plopp" macht.
+
+-----------------------------------------------------------------------------
+
+
+
+Was fahrt Ihr denn fuer Autos? (Ronda, 21. Sep 2008, 02:00:29):
+From: marc.gerges@gmail.com (Marc Gerges)
+Subject: Re: Skoda Ocatvia neu: wie neu?
+Newsgroups: de.etc.fahrzeug.auto
+Date: Sun, 14 Sep 2008 11:21:06 +0200
+Message-ID: <2l1vp5-is.ln1@pascal.gerges.lu>
+
+Thomas Adams <thomas.o.adams@gmail.com> wrote:
+> > marc.gerges@gmail.com (Marc Gerges) wrote:
+> > 
+>> >> Du faehrst BMW?
+> > 
+> > Nein, VW.
+
+Naja,um innerhalb Deiner Argumentation zu bleiben, dass Image auf den
+Fahrer abfaerbt, bist Du also entweder:
+
+Eine Hausfrau mit zwei Kindern (Golf, aelteres Modell, hausfrauenrot,
+zwei Kindersitze, einige Schrammen rundum vom Aldi-Parkplatz)
+
+Papa einer Kleinfamilie (Touran, links und rechts in der Heckscheibe
+jeweils ein '$BLAG an Bord'-Aufkleber, diese Sonnenschutzblenden mit
+Comicfiguren in den Seitenfenstern)
+
+Waschmaschinentechniker (Golf Kombi, Weiss, mit Aufschrift Deines
+Arbeitgebers)
+
+Rasender Vertreter im schlecht sitzenden Anzug (Passat Variant,
+geleast, blaumetallic, Klimaanlage, alle zusaetzlichen Extras
+selbstbezahlt)
+
+Tussi, maennlich oder weiblich (Beetle, meist Cabrio, helle freundliche
+Farbe, Plastiksonnenblume im Armaturenbrett)
+
+Proll (alter Golf, auffaellig lackiert, tiefer, breiter, lauter, nicht
+unbedingt schneller)
+
+cu
+  .\\arc
+
+-----------------------------------------------------------------------------
+
+
+
+Alles billiger, ausser Tiernahrung (Ronda, 21. Sep 2008, 02:01:48):
+From: Wolfgang Groiss <wolfgang.groiss+nntp@gmail.com>
+Subject: Re: Das Luegensternchen
+Newsgroups: de.etc.sprache.deutsch
+Date: Tue, 09 Sep 2008 14:56:10 +0200
+Message-ID: <ga5rpa$paj$1@registered.motzarella.org>
+
+[SN: Zitat ergaenzt]
+
+> > Praktiker hat mal ganz gross geworben: Alles 20% billiger*
+> > *ausser Tiernahrung.
+
+> > Lustigerweise fielen Zigaretten wohl unter Tiernahrung, denn ein Kollege 
+> > bekam sie damals nicht billiger.
+
+> > Viele Gruesse von Dani,
+
+> > die immer noch raetselt, welche Tiere sich von Zigaretten ernaehren
+
+Lungenkrebse.
+
+Wol "im naechsten Leben werde ich Bionkologe" fi
+
+-----------------------------------------------------------------------------
+
+
+
+Walversprechen (Ronda, 21. Sep 2008, 02:03:56):
+From: Tobias J. Becker <tobias.becker@online.de>
+Newsgroups: de.etc.sprache.deutsch
+Subject: Re: Das Luegensternchen
+Date: Thu, 04 Sep 2008 18:50:51 +0200
+Message-ID: <g9p3kv$n4r$03$1@news.t-online.com>
+
+
+Volker Gringmuth schrieb:
+> > Hauke Reddmann wrote:
+>> >> Dann waere es etabliert und man koennte es sogar in
+>> >> der Wahlwerbung verwenden. :-)
+
+> > "Es ist unfair, Parteien an ihren Wahlversprechen zu messen" 
+> > - Franz Muentefering
+
+Ich denke dabei immer wie an eine Kaept'n-Blaubaer-Geschichte, die ich vor
+bestimmt 15 Jahren einmal gesehen habe: Kaept'n Blaubaer erzaehlt da, wie
+er vor vielen Jahren einmal auf hoher See in Notlage geriet und
+schliesslich von einem Wal gerettet wurde, nachdem er ihm dafuer etwas zur
+Belohnung versprochen hatte. Eingehalten hat er dieses Versprechen,
+nachdem er denn einmal gerettet war, natuerlich nicht mehr. Das sei
+naemlich ein sogenannes "Walversprechen" gewesen, wie es unter Seeleuten
+absolut ueblich sei, das muesse man nicht unbedingt einhalten. Nur zu
+haeufig duerfe man sowas nicht machen.
+
+Gruss,
+Tobias
+
+-----------------------------------------------------------------------------
+
+
+
+Ja, ja, der Zoll ;-) (Ronda, 21. Sep 2008, 02:05:02):
+From: Ole Jansen <remove.this.Kaspernasebaer@gmx.de>
+Subject: Re: Schicke 19" Gehaeuse fuer Kleinserie gesucht...
+Newsgroups: de.sci.electronics
+Date: Wed, 03 Sep 2008 11:55:55 +0200
+Message-ID: <6i759bFp12u0U1@mid.individual.net>
+
+Ja ja, die Amis. Von uns wollen sie eine genaue Packliste, alle
+Teile in Beutel mit SAP-Auftragsnummer, Gewichte und Masse,
+proforma invoice, Unbedenklichkeitsbescheinigung, eine Erklaerung
+dass wir keine Geschaefte mit Kuba machen usw.
+OK, haben wir alles.
+
+Auf dem Zollzettel steht dann nach der Zollbeschau in DE:
+
+1 Controller (ser. no. 1234567)
+2 Mounting kit (1 cradle, 8 washer, 8 bolts, 4 _nuts_)
+
+So, und jetzt haengt die Sendung seit drei wochen beim US-Zoll,
+weil sie offensichtlich Nuesse enthaelt.
+
+-----------------------------------------------------------------------------
+
+
+
+Mehdorn-Kaugummiapparat (Ronda, 21. Sep 2008, 02:07:55):
+From:Hans Bonfigt <bonfigt.ses-koeln@t-online.de>
+Subject: Re: Bedienzuschlag kommt
+Newsgroups: de.etc.bahn.tarif+service
+Date: Fri, 29 Aug 2008 22:50:48 +0200
+Message-ID: <g99ne6$kmd$00$1@news.t-online.com>
+
+Ferdi Albers:
+
+>> >> Und nein, es ist uns *nicht* gelungen, dem verdammten Automaten
+>> >> einen passenden Fahrschein zu entlocken, beim besten Willen
+>> >> nicht.
+> > 
+> > Kaugummiautomat?
+
+Ja, aber es war ein Mehdorn-Kaugummiautomat.
+
+
+Es wurden 68 Sorten angeboten, aber nur 14 waren verfuegbar.
+
+Die Preise variierten, je nachdem, ob man das Kaugummi sofort essen
+wollte oder spaeter.  Eine besonders guenstige Option sah vor, dass
+zwischen Verzehr des ersten und letzten Blaettchens ein Wochenende
+liegen musste.
+
+Es wurde auch differenziert, *wer* die Kaugummis wuerde essen wollen.
+Es gab Erwachsenenkaugummis, Kinderkaugummis und Familienkinderkau-
+gummis.
+
+Bei Zahlung mit einem speziellen Zahlungsmittel gab es einen ZUsatz-
+rabatt.
+
+Manche Sorten befanden sich zwar im Automat, aber dieser wollte sie
+nicht herausruecken.
+
+Es gab auch Antrittskaugummis, die bei Bedarf in vollwertige umge-
+tauscht werfen konnten.  Die bekam man nur mit einem Geheimcode,
+der nirgendwo aufgeschrieben war.
+
+Natuelich ist dem Mehdorn-Kaugummiautomaten nicht nur wichtig, wann
+der Kaugummi verzehrt wird, sondern auch *wo*.  Deswegen gibt es
+beispielsweise in Soligen-Ohligs die Kaugummiautomatenauspraegungen
+DB, VRS und VRR, die in Abhaengigkeit vom zu erwartenden Kaugummi-
+entsorgungszielort zu waehlen sind.
+
+Sehr gerne zeigt der Kaugummiautomat auch schon einmal einen blauen
+Schirm, auf dem gemeldet wird, ein unerwarteter Fehler an einer
+komischen Adresse (sieht sehr amerikanisch aus) sei aufgetreten
+und man solle den Hersteller benachrichtigen, wenn dieses Problem
+fortbestehe.
+
+Ab und zu nimmt der Automat keine Geldscheine, manchmal behaelt er das
+Wechselgeld ein, was besonders oft bei den Automaten passiert, wo
+man die Rufnummer der Stoerungsannahmestelle mit einer gluehenden Ziga-
+rette unkenntlich gemacht hat.
+
+Besonders klug sind die Muenchner Kaugummiautomaten programmiert:
+Mit der "GeldKarte" erhaeltst Du Rabatt, aber es muss sich mindestens
+ein Betrag in Hoehe des Barpreises auf der Karte befinden, dass diese
+akzeptiert wird.
+
+Tja ...  Was soll ich sagen, wir haben auf die Dienste des Kaugummi-
+automaten verzichtet und sind "ohne" gefahren.
+
+-----------------------------------------------------------------------------
+
+
+
+Ich suche Suse! (Ronda, 21. Sep 2008, 02:11:19):
+Newsgroups: alt.linux.suse
+From: Dieter Intas <dieter.intas@web.de>
+Subject: Re: Ich suche Suse!
+Date: Sat, 23 Aug 2008 05:40:49 +0200
+Message-ID: <g8o04o$p0u$00$1@news.t-online.com>
+
+Patrick Lions wrote:
+
+> > ich suche eine Frau fuer mein Leben. Ich bin 28, schlank, ein bisserl
+> > vom Sueden, haben wir Bayern so an sich und schlank. I bin gebildet und
+> > bin a sexy. Welche Frau moechte meine Prinzessin werden?
+
+Dann ist openSUSE genau das Richtige fuer dich - du kannst sie ganz
+deinen Vorstellungen anpassen. Ob Mollig oder Schlank, sie ist Sexy,
+zwar auch manchmal zickig, aber das bekommt man in den Griff. Auf
+langer Sicht ist sie durchweg zuverlaessig, so was wie Eifersucht kennt
+sie nicht und ist auch nicht nachtragend. Hat man sich einmal in sie
+verliebt, dann will man sie nicht mehr loslassen oder missen.
+
+Du musst dich allerdings damit abfinden - sie steht auch fuer einen jeden
+zur Verfuegung ...
+
+-----------------------------------------------------------------------------
+
+
+
+Nix Zollstock! (Ronda, 12. Okt 2008, 15:54:09):
+From: Martin Trautmann <t-use@gmx.net>
+Subject: Re: Warum sind alle Zollstoecke falsch bedruckt ?
+Newsgroups: de.rec.heimwerken
+Date: Mon, 6 Oct 2008 06:35:15 +0000 (UTC)
+Message-ID: <slrngejcd2.18b.t-use@ID-685.user.individual.de>
+
+On Mon, 06 Oct 2008 00:28:00 +0200, Dirk Lucas wrote:
+> >  Martin Trautmann schrieb:
+> >
+>> >>Und obendrein sind es keine Stoecke, sondern faltbar - sprich
+>> >>"Gliedermassstab, faltbar, Holz, metrisch, 200 cm"
+> >
+> >Falshc. Man soll mit dem Ding doch messen koennen, es muss als 
+> >   GliederMESSstab heissen. Und Holz ist auch viel zu beliebig, welches 
+> >   Holz? Ganz zu schweigen von der fehlenden Toleranz, kein 
+> >   Gliedermessfaltstab ist exakt 200cm lang.
+
+Hm, ich habe noch nie einen Gliedermassstab mit Toleranzangabe gesehen.
+Gibt's auch solche?
+
+Der Schlosser misst auf den Millimeter,
+der Zimmermann auf den Zentimeter,
+und beim Maurer ist man froh, wenn er auf dem Grundstrueck bleibt...
+
+Schoenen Gruss
+Martin
+
+-----------------------------------------------------------------------------
+
+
+
+Deutschlehrer als Eltern sind sooooo fies! (Ronda, 12. Okt 2008, 15:55:05):
+From: Ulrich G. Kliegis <Ulli.usenet@kliegis.de>
+Newsgroups: de.etc.sprache.deutsch
+Subject: Re: duerfen + Objekt?
+Date: Wed, 08 Oct 2008 12:42:16 +0200
+Message-ID: <tt2pe4931npr4ao4b662e3e7oio0a4vfck@4ax.com>
+
+
+On Wed, 8 Oct 2008 03:07:07 -0700 (PDT), Ingo Menger
+<quetzalcotl@consultant.com> wrote in de.etc.sprache.deutsch:
+
+> >Die Antwort waere ja nur richtig, wenn er die Butter tatsaechlich bekaeme
+> >(von wem auch immer), was aber zum Zeitpunkt der Frage keiner wissen
+> >konnte. Eine manchmal gegebene Antwort hiess dann auch: "Sicher, wenn
+> >du jemanden bittest, sie dir zu geben, dann bekommst du sie auch."
+
+Also, ich gehe bei solchen Fragen, wenn nicht gerade wirklich dicke
+Luft am Tisch ist, immer davon aus, dass niemand ernsthaft einem
+anderen die Butter verweigern wuerde. Vorsichtiger waere ich z.B. bei
+dem letzten Kuchenstueck, auf das sich mindestens ein Kinderaugenpaar
+richtet.
+
+Viele Telefonate gehen bei uns so:
+
+Telefon toent.
+"Kliegis."
+"Ja, hallo! Hier ist Anja."
+"Guten Tag, Anja."
+"-"
+"-"
+"Hallo?"
+"Ja?"
+"Ich wollte fragen, ob Leon da ist."
+"Hmmm."
+"Hallo?"
+"Dann frag ruhig!"
+"Aehm, ja, ist Leon da?"
+"Ja."
+"Hallo?"
+"Ja?"
+"Darf ich mal mit ihm sprechen?"
+"Von mir aus ja, gerne."
+" - "
+" - "
+"Hallo?"
+"Ja, darf ich nun...?"
+"Wie gesagt, ja. (um es dann doch auf den Punkt zu bringen, uebernehme
+ich die Fragen spaetestens dann:)
+Moechtest Du denn mit ihm sprechen?"
+"Ja."
+"Soll ich Dich zu ihm durchstellen?"
+"Ja, das waere nett."
+"Gut, Tschuess"
+Klickediklack.
+
+Die Lernfaehigen machen es beim naechstne Mal gleich richtig.
+
+Gruss,
+U.
+
+-----------------------------------------------------------------------------
+
+
+
+Bahnfahren und Klassenunterschiede (Ronda, 12. Okt 2008, 15:57:19):
+From: "Lueko Willms" <l.willms@domain.invalid>
+Newsgroups: de.etc.bahn.tarif+service
+Subject: Re: Vor 80 Jahren: die Reichsbahn schafft die 4. Klasse ab
+Date: Wed, 8 Oct 2008 11:14:05 +0200
+Message-ID: <czd2LKcn8EGd-pn2-dTddRvOlZYtd@lueko.willms.dialin.t-online.de>
+
+Am Wed, 8 Oct 2008 06:09:02 UTC,  schrieb 
+Stefan+Usenet@Froehlich.Priv.at (Stefan Froehlich)  auf 
+de.etc.bahn.tarif+service :
+
+>> > > Die OeBB hat derzeit in manchen Zuegen "2." - "1." - "Business", 
+
+> > Vermutlich wird sich das dann mit den RailJets ueber kurz oder lang
+> > erledigen. Kennt sich ja sonst gar keiner mehr aus, vor lauter Klassen.
+
+  Die Klassen werden dann als 2., 1, und 0. numeriert. In letzterer 
+findet man dann die fuehrenden Nullen, die man beim Programmieren 
+unterdruecken muss. 
+
+  Dann gibt es natuerlich noch die Klasse 00. 
+
+
+MfG, 
+L.W.
+
+-----------------------------------------------------------------------------
+
+
+
+Jatz (Ronda, 12. Okt 2008, 15:59:56):
+From: Oliver Cromm <lispamateur@yahoo.de>
+Subject: Re: Bedrohte Sprachen
+Newsgroups: de.etc.sprache.deutsch,de.rec.musik.machen
+Date: Fri, 3 Oct 2008 13:21:42 -0400
+Message-ID: <cglerp43pmix$.dlg@mid.crommatograph.info>
+
+
+* Ewald Pfau <anderswo@gmx.net> wrote:
+
+> > (zur Ergoetzlichkeit usw. parallel abgestellt)
+> >
+> > Oliver Cromm <lispamateur@yahoo.de>:
+> >
+>> >> Nix da. Die Aussprache "Jatz" habe ich ueberwiegend im Zusammanhang mit
+>> >> Stilen gehoert, die vor 1950 entstanden sind, "Frie Jatz" (oder gleich
+>> >> "Freijatz"?) ist mir noch nicht begegnet (von "Saeurejatz" zu schweigen,
+>> >> aber das ist mir wiederum zu modern bzw. nicht jazzig genug [sagt man
+>> >> dann als Jatz-Sager auch "jatzig"? Das haette ja eine voellig andere
+>> >> Ikonizitaet]).
+> >
+> > Dass bei Deutschsprachigen, die beruflich damit geschlagen sind, fast nur
+> > 'jats' im Umlauf ist, kann ich bestaetigen (auch als 'free jats'), quasi
+als
+> > nicht-oeffentliche Behelfsvokabel.
+
+Dann - mal akzeptierend, dass dem so sei - scheint es sich um eine Art
+"Schraubendreher" zu handeln, in dem Sinn, dass dieses Wort, oder in
+diesem Fall, diese Aussprache, bei Insidern und Outsidern ganz andere
+Assoziationen weckt.
+
+Der "Schraubendreher" vermittelt bei Insidern Korrektheit und
+Zugehoerigkeit zur Gruppe, waehrend es fuer Normalbuerger die Anmutung der
+Penibilitaet oder Rechthaberei hat.
+
+Fuer "Jatz" sehe ich drei Moeglichkeiten, wie man es ausserhalb der Szene
+anders auffassen kann:
+- als ungebildet: meine Grossmutter sagt "Jatz", wie sie auch "Klohn" und
+"Buttikee" sagt, weil es ihr zuviel waere, eine zur Schreibung unpassende
+Aussprache zu verinnerlichen
+- als altmodisch: wie von mir ausgefuehrt, assoziiere ich den Jazz der
+ersten Importwelle der 20er Jahre, auch Wolframs Erwaehnung von
+"Dixieland" geht in die Richtung. Nur in diesem Zusammenhang (Dixie,
+Bigbands) erinnere ich mich an die Aussprache "Jatz" etwa im Radio,
+"normalerweise" war von "Dschaehs" die Rede
+- als provinziell: wie von Wolfram erwaehnt, der das Wort nur auf
+deutsche Musiker angewendet haben will.
+
+Dazu kommt bei mir persoenlich noch das, was ich Ikonizitaet genannt habe.
+Rein vom Klang her empfinde ich "Dschaehs" als warm, weich, erotisch, wie
+manche Jazzusik (die erotischste Musik ueberhaupt); "Jats" so erotisch
+wie eine Holzkiste.
+
+-----------------------------------------------------------------------------
+
+
+
+Warnung: Sehr lang. Fuer Mopped/Korsika-Fans nett zu lesen. (Ronda, 12. Okt 2008, 16:04:43):
+Newsgroups: de.rec.motorrad
+Subject: Korsika (mit Zwischenueberschriften)
+From: "hwicht" <lobotom@gmx.de>
+Date: Sun, 28 Sep 2008 19:45:31 +0200
+Message-ID: <6k9u9iF6pj81U1@mid.dfncis.de>
+
+Korsika
+(mit romanischen Zwischenueberschriften)
+
+Prooemium
+
+Wenn man nach Korsika reist - mit dem Motorrad und grossem Latinum zumal -
+dann stehen einem als Kradfahrer und Altsprachler bei der Reisevorbereitung
+zwei Hauptinformationsquellen zur Verfuegung. Primo freilich des Joerg Jonas'
+Reiseberichte hier in drm und secundo selbstverstaendlich Uderzos/Goscinnys
+"Asterix in Korsika". An den Bildern, die die drei von Korsika zeichnen,
+muessen nur minimale Retuschen und ein paar Ergaenzungen angebracht werden.
+Miniaturen gilt es hinzuzufuegen, kleine Stimmungsbilder, eine Sprechblase 
+der
+werten Sozia hie und da, und mitunter auch eine Gedankenblase (des Autors,
+vorausgesetzt, dass ihm ein Gedanke kam).
+
+
+Viae Corsicae
+
+Soweit die schiere Kradfahrerei betroffen ist, ist Korsika allemal eine
+Reise wert. Obwohl, das muss an dieser Stelle mal ganz offen und deutlich
+gesagt werden, es dort auch nicht anders ist als anderswo: es gibt nur zwei
+Sorten von Kurven - linksrum und rechtsrum. Ein Spezifikum der korsischen
+Kurven jedoch ist, das hinter ihnen des oefteren Schweinerotten die Strasse
+bevoelkern. Ueber die zutrauliche - um nicht zu sagen: zudringliche - Natur
+dieser beruesselten Paarhufer wird noch zu reden sein. Weitere
+Alleinstellungsmerkmale der korsischen Trassen: die weitgehende Abwesenheit
+von Geraden zwischen den Kurven, und der schier endlose Grip. Wenn nicht
+gerade Sand, Steine oder Schweinescheisse in der Kurve liegen, was nicht
+selten vorkommt.
+
+Anfangs, bei der Umfahrung des "Cap Corse" (das ist die "Nase", die im
+Norden aus der Insel hervorragt), wollt' ich den Jonas schon verfluchen, der
+Euch und uns riet, die Insel zu befahren: was fuer ein Geholper! Spaeter, im
+gebirgigen Zentrum und im Sueden der Insel wurden die Strassen dann immer
+besser.
+
+
+Poids lourdes
+
+Was ein Segen war. Denn die beste Sozia der Welt betrachet Motorradfahren
+als eine Art von kunstgewerblich/kulinarischer Speditionsunternehmung mit
+quasi unbegrenztem Gepaeckvolumen und keinerlei Limitationen der Nutzlast.
+Ausserdem, so hat sie im Laufe der Jahre gemerkt, fahre ich je langsamer um
+die Ecken, je schwerer die Kiste beladen ist. Das ist sehr in ihrem Sinne
+(geradaus will sie rasen, um die Ecken hingegen schleichen...). Ergo packte
+sie schon in Suedfrankreich, auf der Anreise, diverse dickwandige Toepferwaren
+in die grosse Gepaeckrolle. Ausserdem nie ohne Cola, Mineralwasser, Rotwein,
+Kaese- und Wurstkollektion im Tankrucksack. Weissbrot dazu. Baedeker Italien,
+Frankreich, Korsika. Fuer mich noch Julian Barnes' grandioser neuer Roman
+"Nothing to be Frightened of" - ein Buch ueber den Tod, dem man als
+Kradfahrer ja schliesslich in jeder schweinebeschissenen und sandbefleckten
+Kurve am Steilhang in's Auge schaut. Ausserdem (Geschenk vom Ignaz Schmucki,
+danke) ein Buch von Niklaus Meienberg, grandioser Schreiberling, dem die
+Daseinsfreude dermassen aus jedem Knopfloch herausschaute, dass er sich mit
+53 aufhaengte. Ich bin 50 .. kurz, es darf einem ja auch im Urlaub nicht zu
+wohl werden. Wo kaemen wir denn da hin, wenn wir auf Korsika die morbide
+Grundeinstellung verloeren?
+
+Das wiegt alles ziemlich, das ist nicht nur gedankenschwer, das ist auch in
+Dezi- und Kilogramm nicht so ganz ohne Gewicht. Zumal meine Holde auch noch
+ihr - wie sie sagt - "Buero" mitschleppt. Waehrend ich naemlich abends Rotwein
+trinke und Morbides lese, fuehrt sie ihr Reisetagebuch. Und wer meiner Frau
+Reisetagebuecher noch nicht gesehen hat, der glaubt es nicht - sie fuellen
+mittlerweile knapp 5 Regalmeter. Es sind grosse DIN A4-Hefte, in die -
+garniert von handgeschriebenen Texten - alle moeglichen und unmoeglichen
+Memorabilia des jeweiligen Reisetages eingeklebt werden: Postkarten, Photos,
+Restaurantrechnungen, Eintrittskarten, Wurstetiketten,
+Marmeladendoeschenfoliendeckel und Leckereienpappschachtelaufdrucke:
+Hauptsache bunt. Alles, schlicht alles, was ihr im 2D-Format auf der Reise
+unter die Finger kommt und aufbewahrenswert erscheint, wird dort eingeklebt
+und kommentiert. Aber nicht irgendwie - nein: akkurat (sie ist
+Schweizerin). Ergo sind stets Scheren, Bastelmesser, Metalllineal (wegen
+der geraden Schnitte) diverse Klebstoffe, Tipp-Ex (Schreibfehler werden
+sofort unsichtbar ausgebessert) und ein Arsenal verschiedener
+Schreibwerkzeuge mit an Bord. Ausserdem - man weiss ja nie, ob man vor Ort
+auch die Postkarten findet, die man gerne haette - wird eine Kollektion der
+wichtigsten Reiseprospekte, die schon VOR dem Urlaub zu Hause gesammelt
+wurden, mit auf die Reise genommmen. Abends, nach der taeglichen Besichtigung
+dessen, was die Prospekte als sehenswert empfahlen, werden jene
+zerschnippelt und - sofern das Gesehene der Verewigung im Reisetagbuch als
+wuerdig befunden wurde - auszugsweise ins Reisetagebuch eingeklebt. Oder
+gar - ganz buchbindermaessig - eingenaeht, denn oft reicht der Platz in den
+Heften gar nicht. Dann muessen eben Zusatzseiten eingebaut werden. Diese
+Reisetagebuecher sind ein Knaller: wenn wir irgenwo schon mal waren, dann
+findet sie noch nach Jahren mit traumwandlerischer Sicherheit in ihnen den
+Namen, die Telefonnummer und die Internetadresse desjenigen Baeckers, der die
+besten Kekse vor Ort buk, des Metzgers mit der besten Wurst, das Panforte
+mit den dicksten Nuessen.
+
+Aber das "Buero" wiegt und ist sperrig: einer der recht geraeumigen
+Seitenkoffer der Honda ist ihm vorbehalten. Voller Papier, sauschwer. Und
+wenn sie koennte, dann wuerde sie nicht nur die Adresse des Konditors, die
+Etiketten und die Verpackungen der Kekse ins Heft kleben, sondern auch noch
+die Kekse selbst. Aber das geht nicht denn, denn die sind 3D.
+
+Natuerlich ist ein Urlaub ganz ohne dreidimensionale Souvenirs undenkbar. Und
+ueberhaupt wollte sie vor allem aus einem Grund nach Korsika. Vor zwei
+Jahrzehnten war sie schon mal da. Im Reisetagebuch von damals findet sich
+der Eintrag, dass der Kastanienlikoer der "Domaine Orsini" ganz ausgezeichnet
+sei. Leider sind die zwei Flaschen von damals nun leer (haben 20 Jahre
+gehalten - sie trinkt so gut wie nichts) und der Laden verkauft nur direkt.
+Also muessen wir dahin, Likoer fuer den Rest ihres Lebens kaufen. Die "Domaine
+Orsini" ist dank perfekter Dokumentation von Lage und Anfahrtsweg rasch
+gefunden. Alldort kauft sie 5 Flaschen quietschsuessen Likoers aus Kastanien
+und Feigen (woraus ich dreisatzmaessig schliesse, dass sie an die Hundert zu
+werden gedenkt.) Ich hingegen kriege eine Flasche mit scharfem Myrtenschnaps
+(dem voraussichtlich - ebenso wie mir - ein deutlich weniger langes Leben
+beschieden sein wird).
+
+Dann macht sie Anstalten ("Du sagst doch immer, dass wir Gewicht auf'm
+Vorderrad brauchen...") die 6 Flaschen Schnaps im Tankrucksack zu verstauen
+("Schmeiss' halt das Kettenspray und das Werkzeug 'raus.."). Mein inniges
+Flehen, von diesem Ansinnen Abstand zu nehmen, zeigt erst Wirkung, als ich
+nachweislich die dermassen beladene Kiste nicht mehr vom Seitenstaender in
+die Vertikale kriege. Irgendwie schaffen wir es dann (sie hat die Kiste mit
+den Flaschen derweil unter dem Arm) auf's naechste Postamt. Es ist uebrigens
+gar nicht so einfach, in einem korsischen Dorf waehrend der Siesta
+Verpackungsmaterial fuer den Postversand von Schnapsflaschen aufzutreiben.
+Und ich weiss auch nicht, ob ein deutsch/schweizerisches
+Motorradfahrer-Paerchen, das korsische Altpapiercontainer auf der Suche nach
+Kartons und Stopfmaterial durchwuehlt, in den Koepfen der zusehenden Korsen
+das rechte Bild vom oekonomischen Zustand Mitteleuropas erzeugt. Egal. Karton
+und Stopfmaterial fanden sich, auch schmutzige Unterhosen, Socken und
+aehnlicher Detritus aus eigener Produktion konnte nutzbringend zwecks
+Pufferung untergebracht werden. Dann machte der Dorfladen auf, in dem es
+alles gab, sogar breites Klebeband, und der Schnaps wurde heimgeschickt.
+
+Schon ist er da. Ich trink jetzt einen Myrtenschnaps, um die Erinnerung
+wachzurufen, und mich fuer das folgende in Stimmung zu bringen.
+
+
+La Vie en Corse
+
+Doch, es ist schoen auf Korsika. Ob sie, die Insel, jetzt aber wirklich "ta
+kalliste" (= "die Schoenste") ist, aus welchem Wort der Griechen, wie mich
+der Baedeker lehrt, sich ihr Name ableitet: das weiss ich nicht. Es fehlt so
+ein wenig der "ultimative Kick". Es ist wie die Haute-Provence und die
+Riveria, auf Westentaschenformat zusammengeschrumpft. Nicht weniger schroff,
+nicht weniger idyllisch, aber viel kleinteiliger. Es fehlt der Kontrast von
+drangvoller Schluchtenenge und epischer Lanschaftsweite, den die Provence
+bietet. Manche Staedte (Bonifacio, Sartene) sind sehr schoen. Die meisten
+Doerfer auf dem Land und in den Bergen sind recht nullig, oft herrlich
+gelegen, aber architektonisch fad. Die wenigen Korsen, mit denen wir
+gebrochen franzoesisch in's Gespraech kamen, entpuppten sich als nette Leute.
+Keiner war beleidigt, keiner klappte ein Messer auf - ausser der Dame im
+Geschaeft in Sartene, der wir zwei korsische Klappmesser abkauften. Schoene
+Messer gibt es da...
+
+Eingedenk der Schiffsexplosion in "Asterix auf Korsika" hatten wir grosse
+Hoffnungen auf den korsischen Kaese gesetzt. Sie wurden enttaeuscht. Ich muss
+hinzufuegen, dass ich - dass wir beide, meine Holde und ich - was Kaese
+angeht, von einer Furchtlosigkeit sind, die mir im Alltagsleben und meiner
+Suessen in Schraeglagen (s.o.) ansonsten voellig abgeht. Bei mir komt noch der
+Hang zum Morbiden (s.o.) dazu. In Lyon zum Beispiel haben wir einen
+Weichkaese gefunden, der die Konsistenz und die Farbe von weichem Nasenpopel
+hatte (gruengelbblaubraeunlichrosapastellfarben-schleimig), der uns grossen
+Genuss bereitete. Von Korsika erwarteten wir entsprechend Explosiveres,
+fanden jedoch nur ziemlich fade Hartkaese. Und einen Ziegenweichkaese, dessen
+Farbe und Textur (braeunlicher Talgdruesenschmier, wie von eingebluteten
+Mitessern) zunaechst verlockend erschien, der sich dann aber als voellig
+versalzender, entfernt nach Ziege schmeckender Langweiler erwies, selbst
+wenn man ihn voellig stilecht mit dem Klappmesser auf Brot schmierte. Nein.
+Auch sonst, vom Schnaps mal abgesehen (s.o.) kein echter kulinarischer
+Fortschritt gegenueber der Provence. Von den Preisen her aber schon: eine
+teure Insel. Alleine die Klappmesser-Preise...
+
+
+La Vieh en Corse
+
+Abgesehen vom Klappmmesser (Modell "Vendetta") habe ich aus Korsika die
+Einsicht mitgebracht, dass ich, sollte ich mich je gezwungen sehen,
+auszuwaehlen, was ich auf Korsika sein moechte (was allerdings
+unwahrscheinlich ist) folgende Existenzen in folgender Reihenfolge der
+Praeferenzen annehmen moechte:
+
+1) Hund
+Uderzo und Goscinny haben nicht gelogen: ueberall Hunde. Klein bis
+mittelgross, undefinierte Rassen. Hundeleinen sind unbekannt: die grosse
+Freiheit. Die macht die Hunde offenbar erstens schlaefrig, zweitens friedlich
+und drittens schrullig. Lieblingsbeschaeftigungen sind: Herumliegen (die
+Funktion des korsischen Wachhundes scheint darin zu bestehen, dass er an
+unerwarteter Stelle querliegt, wo der Einbrecher dann ueber ihn stolpert und
+sich in dem oft aeusserst abschuessigen Gelaende oder auf den steinernen
+Treppen den Hals bricht). Gelegentlich ein Spaziergang, Baeume abpinkeln, den
+Kumpels "Wau" sagen. Den schrulligtsen aller Hunde haben wir in Sartene auf
+dem Marktplatz gesehen, derweil wir - Pastis trinkend - in einer Bar sassen.
+Abends, kurz nach Sonnenuntergang, als alle anderen Toelen schon weg waren,
+kam er schnurstracks von irgendwoher zur Mitte des leeren Platzes gedackelt.
+Dort, exakt in der Mitte, blieb er stehen. Und sagte etwa alle fuenf
+Sekunden, in grosser Ernsthaftigkeit und an niemanden gerichtet: "Wau".
+Manchmal auch "WauWau" oder "WauWuffWau". Wir haben versucht, ihn mit einem
+Stueck Wurst zu koedern, um freundlichen Streichelkontakt aufzunehmen. Das
+interessierte ihn gar nicht. Wir, die Wurst - er schaute durch uns hindurch,
+wie durch Luft. Er hatte eine Mission: mitten auf dem leeren Marktplatz in
+Sartene "Wau" sagen. Mitunter auch "WauWau". Mindestens eine halbe Stunde
+lang. Es sass noch, als wir gingen. Doch, Hund auf Korsika, seiner Freiheit,
+seiner Faulheit und seinen Schrullen leben: das waer's!
+
+2) Katze
+Im Prinzip wie 1), nur durch den Umstand erschwert, dass man weglaufen muss,
+wenn groessere und vor allem zufaellig aktive Exemplare von 1) erscheinen.
+Bonus allerdings: meine Frau, die neuerdings stets Katzenfutter in der
+Tasche der Motorradjacke hat, um, zwecks Verteilung von Streicheleinheiten,
+Katzenvolk anzulocken. Gelingt nicht immer.
+
+3) Schwein
+Wieder ein Punkt fuer Uderzo/Goscinny: "Ich mag diese Waelder! Sie sind voller
+Schweine..." (zit. Obelix). In der Tat. Die korsischen Hausschweine leben
+das Leben einer Wildsau: frei, kurz, aber heftig. Man treibt sie in die
+(Ess-)kastanien und Eichenwaelder, wo sie sich in voelliger Freiheit bewegen,
+maesten und vermehren, und nicht selten trifft man am Strassenrand oder auf
+der Strasse so eine Rotte, mit Dutzenden quiekender Frischlinge. Die
+Kontaktaufnahme gestaltet sich ganz einfach: man muss nur Katzenfutter in
+der Tasche haben. Die beste aller Sozias steigt ab, gibt einem der suessen
+Frischlinge ein wenig Katzenfutter, und sofort ist die ganze Bagage da. Ein
+Rucksack, abgesetzt und einen Moment aus dem Auge gelassen: zack, zwei
+Schweineruessel drin, der Katzenfuttervorrat wird samt Plastiktuete gefressen.
+Frischlingsruessel in allen Jackentaschen. Auch Motorradstiefel kann man
+probeweise mal anbeissen. Und aus dem Tankrucksack riecht es verfuehrerisch
+nach Korsenkaese. Ist nur ein bischen hoch oben ... vielleicht, wenn man das
+dickste Schwein vorschickt, das ein wenig an das Motorrad schubst,
+vielleicht faellt das Ding dann um, und man kommt 'ran...
+
+Eilige Flucht. (Unsererseits, die Schweine, hat man einmal ihr Interesse
+geweckt, sind nur schwer zu vertreiben).
+
+Doch, Schwein auf Korsika ist kein schlechter Job. Irgendwann ist man tot
+und wird verwurstet - aber das geht uns Menschen ja auch nicht anders. Nur
+dass wir im allgemeinen ERST im Berufs- und Alltagsleben verwurstet werden,
+und DANN tot sind, bei den Schweinen geht es andersrum: erst Leben in
+Freiheit, dann tot, und dann Wurst. Ich weiss nicht, was besser ist. Gute
+Ueberleitung zum 4. korsischen Daseinswunsch aber, und der lautet:
+
+4) Leiche.
+Zugegeben: es mangelt diesem Seinswunsch an Lebendigkeit, dafuer ist er
+preiswert, was auf Korsika (sagte ich schon, dass es teuer ist?) ein nicht
+zu verachtender Vorteil ist. Wie 1) und 2) hat man wenig zu tun, wie 3) die
+Verwurstung hinter sich, anders als jene aber wohnt man richtig nett. Nicht
+ueberall, aber doch vielerorts ersparen die Korsen ihren Toten die
+Kasernierung auf Friedhoefen. Statt dessen stellen sie kleine freistehende
+Granithaeuschen in die Landschaft, in denen sie ihre Angehoerigen, und spaeter
+auch sich selbst zur Ruhe legen (werden). An schoenen Stellen, mit netter
+Aussicht, neben dem Gemuesegarten, am Weinberg, im Olivenhain. Es fehlen zwar
+die Fenster - aber wollen wir doch hoffen, nehmen wir's doch als Symbol
+dafuer, dass die Innenansichten des Todes erfreulicher sind als all die
+Aussenansichten, die das Leben zu bieten hat. Jedenfalls sind die kleinen
+Nekrovillen (oder sagt man: "Nekrodome"? Oder "-domuli"? Wie von "domulus":
+"das Haeuschen") -- jedenfalls sind die kleinen Totenhaeuschen recht huebsch
+anzusehen.
+
+
+Peroratio
+
+Freilich waren wir auch noch ganz anderswo. In Burgund und der Provence
+(Toepferwaren und leckerste Kaese, s.o.), in Ligurien, der Toscana, in
+Umbrien, in der Emilia Romana und in der Lombardei (Suesswaren, Schinken,
+diverse vorzuegliche Hartkaese, Chianti, Trueffeln aus Aqualungha etc.etc. --
+irgendwer hat mal gesagt: "Das Essen ist der Sex des Alters." Wenn ich mir
+so den Inhalt des prallen Tankrucksackes und dann den meiner Unterhosen
+ansehe, dann muss ich zugeben: der Mann hatte recht.)
+
+In Bologna haben wir das Ducati-Museum verpasst, dafuer den Friedhof
+"Sertosa" angesehen, der jenes sicher aufwiegt, zumal wir dort das
+Familiengrab der "Cavaillere Ducati" fanden. Und ein Grabmal fuer die toten 
+Helden des Motorradsports, so etwa von 1935. Maranello haben wir links
+liegen gelassen, und in Mandello del Lario war das Guzzi-Museum wie ueblich
+zu. Dafuer haben wir beim oertlichen Baecker eine Leckerei entdeckt, die wir
+noch nicht kannten: klebriger Schokoladenkuchen mit Pinienkernen.
+
+Dann war endgueltig Schluss: der Tankrucksack reichte mir bis an's Kinn, ich
+konnte die Instrumente nicht mehr ablesen und die Fuhre schaukelte auf jeder
+Bodenwelle nach, als ob sie keine Stossdaempfer haette. Irgendwie hab' ich das
+Ding noch ueber den Spluegenpass gewuchtet, dann noch nach Chur und durch's
+Appenzell (sie fand DOCH noch Platz fuer drei Biber [ein Marzipangebaeck] und
+eine grosse Nusstorte) -- aber dann nichts wie auf der BAB nach Hause, via
+Stuttgart. Zum Maultaschenkauf hatte sie dann auch keine Lust mehr.
+
+Gelungener Urlaub also.
+
+Ach so, das hier ist ja drm, und nicht de.rec.mampf ... die Varadero
+brauchte unterwegs einen neuen Kettensatz (sehr merkwuerdig, der alten
+Kette/dem Kettenblatt war nichts anzusehen, war noch im "gruenen"
+Spannbereich - fing aber ploetzlich an, unter Last zu knarzen).
+Honda-Vertretung in Aix-en-Provence: danke fuer die flotte Arbeit! In Dijon
+haben wir die vollbeladene Karre umgeworfen - beim Rangieren, und zwar nach
+links. Jetzt sind die Koffer wenigstens links und rechts symmetrisch
+verkratzt, mit der rechten Seite bleib' ich daheim immer am Hoftor haengen.
+Sonst war nix auf 6tkm. Honda halt.
+
+
+Helmut Wicht
+sig. kaputt
+
+-----------------------------------------------------------------------------
+
+
+
+Wo kommt das hier eigentlich her? (Ronda, 30. Nov 2008, 13:27:17):
+Hallo,
+
+ 
+kleine Vorbemerkung, bevor ich meiner ueblichen Arbeit :-) hier nachgehe: Die
+Artikel, die Ihr hier in der Rubrik findet, sind nicht auf meinem eigenen Mist
+gewachsen, sondern entstammen der Newsgroup de.alt.netdigest. Dort kann jeder
+nette/witzige/freche/doofe Newsgroup-Artikel einreichen, das
+de.alt.netdigest-Team sucht daraus dann die schoensten 5 pro Tag raus und
+schiebt sie in die Newsgroup.
+
+Viele Gruesse
+
+Ronda
+
+-----------------------------------------------------------------------------
+
+
+
+Fuer Janne (Ronda, 30. Nov 2008, 13:31:52):
+Message-ID: <6nbq58Fj2etmU1@mid.individual.net>
+From: Jan Voelkers <jan+individual@voelkers.org>
+Newsgroups: de.rec.sport.segeln
+Subject: Re: Aegaeis-Toern 2009
+Date: 4 Nov 2008 20:38:00 GMT
+
+Am Tue, 04 Nov 2008 11:37:37 +0900 schrieb Michael Hess:
+
+> > ahh und dein Newsreader ist net in der Lage Content-Type: text/plain;
+> > charset="iso-8859-1"
+
+Asche auf mein Haupt. Kann er natuerlich. Und wenn ich "Wrap article body" 
+anschalte, kommt auch mehr als eine abgeschnittene Zeile plus viele 
+Zeilen HTML Muell.
+
+Aber "anblaff"? Wie sagst Du denn zB "klar zur Wende"? 
+"Werte Mitsegler, aufgrund nahenden Ufers wird es noetig, eine Wende 
+einzuleiten. Bitte bereitet alles Noetige vor und gebt mir Rueckmeldung, 
+damit ich dann die Pinne bewegen und dann statt "Ree!" "Bitte die Fock 
+auf dem alten Bug loesen und auf der anderen Seite dichtholen und belegen" 
+sagen kann." ?
+
+Jan
+
+ 
+[Eingesandt von is@beverly.kleinbus.org an de.alt.netdigest - vielen Dank!]
+
+-----------------------------------------------------------------------------
+
+
+
+Kommt man fuer so was in die Hoelle? :-) (Ronda, 30. Nov 2008, 13:33:29):
+From: Georg Kreyerhoff <georg@kreyerhoff.de>
+Newsgroups: oecher.talk
+Subject: Re: Zeichen des Friedens in der Kirche
+Date: Sun, 9 Nov 2008 07:46:14 -0800 (PST)
+Message-ID: <f1ba0364-a0d7-4cb2-85f0-7d80f931991d@b2g2000prf.googlegroups.com>
+
+On 8 Nov., 19:03, "Cecilia Heidenthal" <nos...@me.com> wrote:
+> > Hallo NG,
+> >
+> > irgendwann im Laufe der Messe reicht man sich die Hand zum "Zeichen des
+> > Friedens". Wie kann ich das hoeflich umgehen, wenn mein Banknachbar schon
+die
+> > ganze Stunde lang in seine Haende niest und hustet und folglich seine
+Haende
+> > mit bakteriellem Schmodder ueberseht sind? Ich brauche eine andere Loesung
+als
+> > Weglaufen.
+
+nach der Messe im Weihwasserbecken die Haende waschen?
+
+Georg
+
+> > Danke!
+
+[Eingesandt von tim@tim-landscheidt.de an de.alt.netdigest - vielen Dank!]
+
+-----------------------------------------------------------------------------
+
+
+
+Wollen wir das MG auch ISO9000-zertifizieren? (Ronda, 30. Nov 2008, 13:34:31):
+From: "Juergen P. Meier" <nospam-1984@jors.net>
+Newsgroups: de.comp.security.misc
+Subject: Re: Sicherheit bei sofort-ueberweisung.de
+Date: Sun, 09 Nov 2008 08:09:24 +0000 (UTC)
+Message-ID: <20483.4879.1226218164@news.jors.net>
+
+Bernd Hohmann <nixda@nixwill.de>:
+> > Juergen Ilse schrieb:
+> >
+> > [...]
+> >
+>> >> Irgendjemand behauptete mal "nach ISO9000 kann man auch
+>> >> Schwimmwesten aus Stahlbeton herstellen, mit denen garantiert auch
+>> >> der beste Schwimmer absaeuft, die gleichbleibende Qualitaet (komplett
+>> >> unbrauchbar) ist ja gegeben".
+> >
+> > Zumal ich bei keiner meiner Kunden oder Zulieferer gesehen habe, das 
+> > eine ISO 900x Zertifizierung irgendeine Verbesserung oder 
+> > Verschlechterung gebracht hat - ausser dass immer mal wieder der Betrieb 
+> > mit gezogener Handbremse gefahren wird.
+
+Es gibt auch ISO9000-Zertifizierte Sandstraende.
+
+Bei $FIRMA wurde z.B. mal dokumentiert, dass keine Dokumentation vorhanden
+ist, was der TUeV auch prompt fuer ISO9000 abgenommen und zertifiziert hat.
+
+[Eingesandt von usenet@bobok.org an de.alt.netdigest - vielen Dank!]
+
+-----------------------------------------------------------------------------
+
+
+
+Rosenkohl ernten fuer Koch-Newbies (Ronda, 30. Nov 2008, 13:35:57):
+Newsgroups: de.rec.garten
+Subject: Re: Wie Rosenkohl ernten?
+From: getuem@t-online.de (Manuela Pecks)
+Date: Sat, 15 Nov 2008 12:59:49 +0000
+Message-ID: <cjhth41tt9nv9s4tibrlq58pbuhvlpc099@news.t-online.de>
+
+
+Matthias Klodt schrieb 15 Nov 2008 in de.rec.garten:
+
+> >Moin Gartenfreunde,
+> >
+> >ich stelle mich zu bloede an, Rosenkohl zu ernten. Werden die Roeschen 
+> >abgeschnitten, ausgebrochen oder abgedreht?
+
+Mein Mann stand gerade verstaendnislos neben mir und meinte lapidar:
+"Tuete aufschneiden und rausnehmen!" ;-)
+
+Ich wuerd sie vorsichtig nach unten wegbrechen (die Rosenkoehler, nicht
+die Tuete).
+
+Gruss
+Manuela
+-- http://www.drg-faq.info/ 
+
+[Eingesandt von kathinka@rrr.de an de.alt.netdigest - vielen Dank!]
+
+-----------------------------------------------------------------------------
+
+
+
+Artikel und Signatur sind nett (Ronda, 30. Nov 2008, 13:37:51):
+From: Oliver Cromm <lispamateur@yahoo.de>
+Subject: Re: Um Erlaubnis fragen
+Newsgroups: de.etc.sprache.deutsch
+Date: Mon, 24 Nov 2008 19:32:12 -0500
+Message-Id: <f7bq9hrqfk1g.dlg@mid.crommatograph.info>
+
+* Wolfram Heinrich <info@theodor-rieh.de> wrote:
+
+> > Am Sun, 23 Nov 2008 15:58:34 +0100 schrieb Walter Schmid:
+> >
+>> >> Ich will mal aushelfen: Ein normaler Schweizer ist ganz gewiss
+>> >> kein 'normgemaesser' Schweizer. Umgangssprachlich meint man damit
+>> >> einen Durchschnittsschweizer. Per Definition weicht dieser vom
+>> >> Durchschnitt um 0.0% ab. Ein normaler Schweizer ist somit ein
+>> >> Mensch, der vom Durchschnitt unterdurchschnittlich viel abweicht.
+>> >> Also ist er/sie jemand, der/die in allen wesentlichen
+>> >> Eigenschaften im 2. oder 3. Viertel der Gaussverteilung
+>> >> (Glockenkurve) liegt.
+>> >> [...]
+
+> > Toll. Mit so einer Definition kann man sich wenigstens auf hohem Niveau
+> > nicht verstehen.
+
+Wenn zwei, die sich nicht verstehen, wenigstens verstehen, dass sie
+sich nicht verstehen, verstehen sie sich besser als wenn sie, obwohl
+sie sich nicht verstehen, nicht einmal verstehen, dass sie sich nicht
+verstehen.
+-- Java is kind of like kindergarten. There are lots of rules you have to
+remember. If you don't follow them, the compiler makes you sit in the corner
+until you do. - Don Raab 
+
+[Eingesandt von dieterbruegmann@gmx.net an de.alt.netdigest - vielen Dank!]
+
+-----------------------------------------------------------------------------
+
+
+
+Gibts auch doppellagiges Schleifpapier mit Bluemchenmuster? (Ronda, 30. Nov 2008, 13:39:38):
+Subject: Re: Einlagiges Toilettenpapier
+From: Michael Pachta <mipani@gmx.de>
+Date: Thu, 27 Nov 2008 13:48:01 +0100
+Message-ID: <6p7j7tF6h4tgU1@mid.individual.net>
+Newsgroups: de.alt.talk.unmut
+
+Erwin Schlonz schrieb/wrote/escribi:
+> > Immer noch besser als das Papier, das unser Facility Management
+> > besorgt. Geruechten zufolge soll es im hiesigen Baumarkt eingekauft
+> > werden; konkret in der Holzabteilung gleich neben den Hobeln und
+> > Stechbeitel.
+
+Sowas kenne ich. Auf der Toilette eines Uni-Instituts gab es mal einen
+Aushang, welcher besagte, dass es per Anweisung der Institutsleitung
+untersagt sei, das bereitgestellte Toilettenpapier als Schleifpapier zu
+verwenden und so dem vorgesehenen Zwecke zu entfremden.
+
+[Eingesandt von Manfred Russ an de.alt.netdigest - vielen Dank!]
+
+-----------------------------------------------------------------------------
+
+
+
+Amen! (Ronda, 30. Nov 2008, 13:40:12):
+From: Wolfram Heinrich <info@theodor-rieh.de>
+Newsgroups: de.etc.sprache.deutsch
+Subject: Re: 8))
+Date: Thu, 27 Nov 2008 11:23:44 +0100
+Message-ID: <udc2b5nu6j1e$.dlg@www.theodor-rieh.de>
+
+
+Matthias Opatz schrieb:
+> > Wolfram Heinrich schrieb: 
+>> >> Bibel ist Bibel. Der Autor ist eh immer derselbe. 
+
+> > Echt? Ich dachte, es waerer mehrere (zB Lothar Matthaeus, Lukas 
+> > Podolski, Johannes B. Kerner, Markus Wasmeier, Ed Moses und 
+> > die Typen um Peter Gabriel). 
+
+Dahinter steckt der Holy-Ghostwriter. Muss ich denn alles erklaeren!
+
+Ciao
+Wolfram
+
+[Eingesandt von DorotheeHermann@gmx.net an de.alt.netdigest - vielen Dank!]
+
+-----------------------------------------------------------------------------
+
+
+
+Besch... Nutzerinterface (Ronda, 30. Nov 2008, 15:09:57):
+[SN: Zitat ergaenzt]
+
+From: Helmut Barth <Helmut.Barth@arcor.de>
+Subject: Re: Das nenne ich mal einen Griff in's Klo :-)
+Message-ID: <4906cf4c$0$30225$9b4e6d93@newsspool1.arcor-online.net>
+Date: Tue, 28 Oct 2008 09:37:31 +0100
+Newsgroups: de.etc.bahn.misc
+
+Salut!
+
+Lueko Willms schrieb:
+
+> >Ralph A Schmidt, dk5ras schrieb:
+
+> > "Griff ins Klo: Ein Franzose hat sich beim Versuch, sein Handy aus der
+> > Zugtoilette zu angeln, den Arm eingeklemmt und musste von der
+> > Feuerwehr befreit werden. Der Zug stand wegen der Rettungsaktion fuer
+> > mehrere Stunden still."
+
+>> >> Le Figaro schreibt, dass auch nicht berichtet wurde, ob das 
+>> >> Mobiltelefon "gerettet" worden ist. 
+
+Man darf aber davon ausgehen, dass das Geraet im einen wie im anderen 
+Fall, ein beschissenes Nutzerinterface haben duerfte..
+
+SNCF, Helmut
+
+[Eingesandt von Edgar Sippel an de.alt.netdigest - vielen Dank!]
+
+-----------------------------------------------------------------------------
+
+
+
+Hmf!!! (Ronda, 30. Nov 2008, 15:10:41):
+Date: Wed, 29 Oct 2008 07:37:05 +0100
+From: Sara Roth <sroth@nospam.de>
+Newsgroups: de.rec.buecher
+Subject: Re: Moempelgard
+Message-ID: <4908048c$0$31344$9b4e6d93@newsspool4.arcor-online.net>
+
+Tassilo Halbritter schrieb:
+ > Wieviele Woerter mit -mf- gibt es eigentlich im Deutschen?
+
+Ich komme auf sechs: Semf, fuemf, Hamf, Sumf, stamfen und tot umfallen  ;-)
+
+
+Sara
+
+[Eingesandt von robin888@t-online.de an de.alt.netdigest - vielen Dank!]
+
+-----------------------------------------------------------------------------
+
+
+
+Einrad mit Lenker (Ronda, 30. Nov 2008, 15:11:45):
+[Submitter's note: Quoting ergaenzt]
+
+From: Andreas Braukmann <irgendwer@internet-adresse.de>
+Newsgroups: de.rec.fahrrad
+Subject: Re: Freihaendig verboten?
+Message-ID: <vp1nt5-a55.ln1@bitgate.unixxinu.de>
+
+
+Rainer Mai schrieb:
+> > Christian Steins <cs@invalid.invalid> schrieb:
+| >Peter de Leuw schrieb:
+| >
+| >>  23 (3) StVO:
+| >> "Radfahrer und Fuehrer von Kraftraedern duerfen sich nicht an Fahrzeuge
+| >> anhaengen. Sie duerfen nicht freihaendig fahren. 
+| >
+| >Ok, der Polizeiman haette trotzdem das "HAeNDE AN DEN LENKER"
+| >etwas freundlicher in den Lautsprecher rufen koennen.  ;-)
+| >
+| >Bleibt die Frage, nach den lenkerlosen Bikes (FlevoBike,
+|
+| Da gips Handgriffe, die du Kritikern problemlos als Lenker verkaufen kannst.
+|
+| >Einraeder)....
+|
+> > Niemand verbietet dir, beim Einradfahren einen Fahrradlenker mitzunehmen
+und
+> > dabei in mindestens einer Hand zu halten ;o)
+
+Was im uebrigen teils sehr interessante Blicke und
+andere Reaktionen nach sich zieht. Unsere Tochter
+schiebt beim Einradfahren gern mal ein "passendes"
+Vorderrad (20"-Rad, Gabel, Lenker) vor sich her. :-D
+
+-Andreas
+
+[Eingesandt von oxensepp@gmx.de an de.alt.netdigest - vielen Dank!]
+
+-----------------------------------------------------------------------------
+
+
+
+Wohlfuehlkneipe fuer Raucher gesucht (Ronda, 30. Nov 2008, 15:12:39):
+[SN: Qouting ergaenzt ... ]
+
+From: Richard <ricki.proxy@googlemail.com>
+Newsgroups: oecher.talk
+Subject: Re: Wohlfuehlkneipe fuer Raucher gesucht
+Date: Fri, 31 Oct 2008 12:56:18 +0100
+Message-ID: <6n0a35Fja8kfU1@mid.individual.net>
+
+Holger Jeromin schrieb:
+
+> > Christoph Schmitz schrieb am 31.10.2008 12:14:
+> >
+>> >> Holger Jeromin schrieb:
+>> >>
+>>> >>> Christoph Schmitz schrieb am 31.10.2008 11:52:
+>>> >>>
+>>>> >>>> Warum gibt es eigentlich keine Raucherkneipen mit
+>>>> >>>> vernuenftiger Belueftung, wenn die Nachfrage doch
+>>>> >>>> offenbar vorhanden ist?
+>>> >>>
+>>> >>> Schon mal eine Sporthalle mit ausreichender Belueftung gesehen?
+>> >>
+>> >> Ich habe sogar schon Atemschutzuebungsanlagen mit ausreichender
+>> >> Belueftung gesehen (von $KLEINE_SICHTWEITE in $KURZE_ZEIT auf
+>> >> $GROSSE_SICHTWEITE, falls noetig).
+> > 
+> > Ich meinte jetzt eher zivile Anlagen in den Sport und nicht nur
+> > Zeit-tot-schlagen das Ziel ist.
+
+Ahhhh, das Wort was  du suchst heisst "Windkanal mit Ausschank"
+
+[Eingesandt von schlu-do@gmx.net an de.alt.netdigest - vielen Dank!]
+
+-----------------------------------------------------------------------------
+
+
+
+Hatten wir den hier schon? (Ronda, 30. Nov 2008, 15:16:32):
+ 
+From: Walter Schmid <paulwalterschmid@vtxmail.ch>
+Subject: Re: Tod eines Kritikers
+Newsgroups: de.rec.buecher
+Date:Fri, 24 Oct 2008 14:57:28 +0200
+Message-ID: <4901c636$0$4034$5402220f@news.sunrise.ch>
+
+Wolfram Heinrich schrieb:
+
+> > Spaetestens, wenn du in der Innenstadt einparken musst, weisst du, dass
+ein
+> > Fiat 500 besser ist als ein Rolls Royce.
+> > Ausserdem haelt man dich in einem Fiat 500 nicht fuer einen Milliardaer,
+dein
+> > Ruf nimmt also keinen Schaden.
+
+Wer RR faehrt, hat einen Chauffeur und damit per Definition nie
+ein Parkplatzproblem. Der Luxus-Wagen fuer Selbstfahrer heisst
+Bentley. (Nur Ignoranten fahren selber einen RR - und werden von
+den richtigen RR-Fahrern prompt fuer den Chauffeur gehalten, der
+seine Muetze vergessen hat. Als Verkehrssoziologe bist Du
+durchgefallen.)
+
+Gruss
+
+Walter
+
+[Eingesandt von jhettler@web.de an de.alt.netdigest - vielen Dank!]
+
+-----------------------------------------------------------------------------
+
+
+
+Wer von Euch hat das auch so zuhaus? (Ronda, 30. Nov 2008, 15:18:12):
+From: "Sabine Sauer" <SabineSauer@web.de>
+Subject: Re: Der Hammer, kein Entertain weis ISDN-0 Anschluss
+Newsgroups: de.comm.technik.dsl
+Date: Thu, 30 Oct 2008 18:02:32 +0100
+Message-ID: <gecpbd$qin$1@online.de>
+
+[SN: Es geht um die Frage, zu welchem Zweck ein Privathaushalt einen
+Telefonanschluss mit Durchwahlmoeglichkeit braucht]
+
+>> >>Weil wir seit 15 Jahren einen ISDN-Anschluss mit Durchwahl (also keinen
+>> >>Home-ISDN-MGA 3-Nummern-Kastraten) haben
+
+> > Was ist an einem Mehrgeraeteanschluss mit bis zu 10 Nummern (kastriert mit
+> > max. 3 gibbet nicht) ein Kastrat?
+
+Die fehlende Durchwahlmoeglichkeit?? :-)
+
+Wie ein Kastrat, der weiss auch, wie es gehen koennte ...
+
+10 Nuemmerchen ist nicht wirklich viel.
+
+Wobei man evtl. mit MFV-Nachwahl was machen koennte, aber dann wird
+jedesmal eine Einheit faellig vom Handy :-(
+Speziell fuer die -4er Anwendungen und die sind erst am Anfang.
+
+-0 "Zentrale"  = Sammelruf tagsueber im
+WZ-SZ-Kueche-KZ1-KZ2-Keller-Werkstatt 
+diverse Schnullis etc.
+
+-xx  =  Erreichbarkeit fuer "Freunde" ausserhalb der ueblichen Zeit.
+-1x  =  Kind 1
+-1x  =  Kind 2
+-3x  =  Fax
+-3x  = "Homeoffice"
+-51 -59 diverse Handies
+-7xxx  ohne die - Angabe als Rueckrufnummer fuer Callcenter und andere 
+Vertriebsorganisationen, ebay, usw., von denen man was will. Nach
+Belieben vergeb- und wieder loeschbar.
+
+Ab jetzt alles mit CLIP Filter
+
+-4xx = zentraler Server ein
+-4xx = Garagentor auf
+-4xx = Kellertuer auf
+-4xx = Sauna an
+-4xx = Whirlpool Heizung an
+-4xx = KinoPC an 
+Der Scheiss-Beamer besteht auf seinen Knopf, und ich komm nicht ran...
+
+-4xx = Webserver Reset
+-4xx = kommt noch, daher gleich mal 3-stellig eingerichtet
+
+-6x = DISA fuer die Kinder von der Prepaid-Free-Home-Nummer vom Handy auf
+die Flat abgehend, somit Deutschlandflat fuer die Prepaid-Handies.
+
+Dazu diverse Rufnummern "eigentlich" nur intern.
+
+Na ja, 10 waere schon eng :-)
+
+Ich weiss, andere bauen Eisenbahnen, spielen Schach oder zuechten Hunde.
+
+Jeder spinnt auf seine Weise.
+
+[Eingesandt von martin.gerdes@gmx.de an de.alt.netdigest - vielen Dank!]
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Hmf!!! (Zephyr, 30. Nov 2008, 15:22:39):
+~#! rn=Ronda rt=1228054241 rg=schmarrn.netdigest
+~#! tid=1228054241
+Sie hat die Amfibien vergessen!
+*quak*
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Wohlfuehlkneipe fuer Raucher gesucht (Darklor, 11. Dez 2008, 18:28:08):
+~#! rn=Ronda rt=1228054359 rg=schmarrn.netdigest
+~#! tid=1228054359
+*rofl* Der war gut!
+
+Darklor
+
+-----------------------------------------------------------------------------
+
+
+
+Whisky (Mupfel,  5. Nov 2010, 10:49:29):
+Newsgroups: de.rec.motorrad
+Subject: Re: Die Wiederholung des Ewiggleichen
+From: Frank Kemper <sampler...@googlemail.com>
+Date: Tue, 02 Nov 2010 08:37:36 +0100
+Message-ID: <8j7qiqFnn6U1@mid.dfncis.de>
+
+Matthias Kohrs wrote:
+
+ > Whisky geht auch ohne Schafe, probier mal einen Oban oder Scapa.
+
+Gaengiger Diskussionsverlauf.
+
+Ich: "Ich mag keinen Whisky."
+Der andere: "Das muss daran liegen, dass du noch keinen richtig guten
+gefunden hast. Hier, probier mal $MERKWUERDIGER_GAELISCHER_NAME."
+Ich: "Na gut." (Wurrch)
+
+Nach knapp 30 Jahren, die das so geht, meine ich, mit einiger
+empirischer Erfahrung sagen zu koennen, was mir schmeckt und was nicht;-)
+Aquavit aus Nordeuropa geht immer, bei Grappa kommt's drauf an, und
+12-jaehriger oder aelterer Rum ist auch was ganz Feines. Aber geh' mir ab
+mit Whisky. Den saufen doch nur die Jungs von der Insel, weil ihre Kueche
+noch schlechter schmeckt;-) 
+
+
+-mupfel-
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Whisky (Amaryllis,  5. Nov 2010, 15:16:30):
+~#! rn=Mupfel rt=1288950569 rg=schmarrn.netdigest
+~#! tid=1288950569
+Hach, das spricht mir aus der Seele ;-)
+
+Ama*
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Whisky (Ark,  5. Nov 2010, 17:17:53):
+~#! rn=Amaryllis rt=1288966590 rg=schmarrn.netdigest
+~#! tid=1288950569
+Du saeufst Aquavit? Mein Meinungsbild von Dir faellt grad vom Haken hinter die
+Couch :-)
+
+
+              *** ARK * the * Magnificent ***
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Whisky (Vanion,  5. Nov 2010, 19:16:22):
+~#! rn=Ark rt=1288973873 rg=schmarrn.netdigest
+~#! tid=1288950569
+Och, bei 'ner Linie gelegentlich sag ich auch nicht nein. Vor allem mit
+Gruenkohl(*) harmoniert das ungemein.
+
+V*
+(*) Die Saison wird am Dienstag mit dem jaehrlichen Gruenkohlessen des
+    Berufsverbandes eroeffnet.
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Whisky (Gnome,  5. Nov 2010, 21:10:49):
+~#! rn=Mupfel rt=1288950569 rg=schmarrn.netdigest
+~#! tid=1288950569
+Ueber Geschmack laesst sich bekanntlich nicht streiten, deshalb an dieser
+Stelle nur ein Vergleich. Mit dem Verhaeltnis von gutem Rum zu gutem
+Whisky ist es so wie mit Vollmilchschokolade zu Zartbitter: der Gourmet
+laesst sich letztere im Munde zergehen, der Ruepel mampft Vollmilch ;)
+
+gnOme
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Whisky (Ark,  5. Nov 2010, 21:29:03):
+~#! rn=Gnome rt=1288987849 rg=schmarrn.netdigest
+~#! tid=1288950569
+So, das habt ihr nun davon ... das letzte bisschen Laphroaig Quarter Cask wird
+jetzt angegangen :)
+
+
+              *** ARK * the * Magnificent ***
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Whisky (Gnome,  5. Nov 2010, 21:29:48):
+~#! rn=Ark rt=1288988943 rg=schmarrn.netdigest
+~#! tid=1288950569
+Mach doch. Ich hab dafuer noch ne ganze Flasche Ardbeg im Regal. Aetsch! :)
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: Whisky (Ark,  5. Nov 2010, 21:57:18):
+~#! rn=Gnome rt=1288988988 rg=schmarrn.netdigest
+~#! tid=1288950569
+Nun, ich hab nen neuen 16 Jahre alten Std und einen dreiviertel vollen
+Uigeadail ... aetsch?
+Mwahaha.
+
+
+              *** ARK * the * Magnificent ***
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^5: Whisky (Ark,  5. Nov 2010, 21:59:05):
+~#! rn=Ark rt=1288990638 rg=schmarrn.netdigest
+~#! tid=1288950569
+Und wo wir grad die Ploerretrinker verdraengt haben ... dran denken:
+http://www.interwhisky.com/
+
+
+              *** ARK * the * Magnificent ***
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^6: Whisky (Amaryllis,  5. Nov 2010, 22:05:19):
+~#! rn=Ark rt=1288990745 rg=schmarrn.netdigest
+~#! tid=1288950569
+Jo...
+
+wenn man schon nix vernuenftiges zum Fressen hat, muss man kraeftig Werbung
+fuer was "Trinkbares" machen, was aber den Namen nicht verdient.
+
+ALs der liebe Gott die Inseln erschuf, wusste er schon, warum er die Eng-, Ir-
+und Schott-Laender darauf plaziert hat.
+
+Ama*
+
+-----------------------------------------------------------------------------
+
+
+
+Re^7: Whisky (Vanion,  5. Nov 2010, 22:13:17):
+~#! rn=Amaryllis rt=1288991119 rg=schmarrn.netdigest
+~#! tid=1288950569
+Alberner Whisk(e)y-Hype. An einen guten Rum kommt nix ran. Wenn man natuerlich
+Bacardy (mal abgesehen von dem 8jaehrigen) mit Rum verwechselt kommt man auf
+solch wunderliche Ideen.
+
+Ich sag nur, ich kenne Wisky-Trinker, die Cola-Rot trinken. Soviel zu deiner
+Zartbitter-Theorie.
+
+V*
+
+-----------------------------------------------------------------------------
+
+
+
+Re^8: Whisky (Amaryllis,  5. Nov 2010, 22:15:03):
+~#! rn=Vanion rt=1288991597 rg=schmarrn.netdigest
+~#! tid=1288950569
+ich hab nix mit zartbitter zu tun ;)
+
+Ama*
+
+-----------------------------------------------------------------------------
+
+
+
+Re^9: Whisky (Vanion,  5. Nov 2010, 22:16:48):
+~#! rn=Amaryllis rt=1288991703 rg=schmarrn.netdigest
+~#! tid=1288950569
+Hab nur klassisch auf den letzten Artikel geantwortet. Alte Angewohnheit.
+Gemeint war Gnome.
+
+V*
+
+-----------------------------------------------------------------------------
+
+
+
+Re^8: Whisky (Gnome,  5. Nov 2010, 22:17:04):
+~#! rn=Vanion rt=1288991597 rg=schmarrn.netdigest
+~#! tid=1288950569
+Ich kenne auch Zartbitter-Esser, die mal Vollmilch mampfen... das Niveau
+senken geht immer. Heben wird schwer ;)
+
+gnOme
+
+-----------------------------------------------------------------------------
+
+
+
+Re^9: Whisky (Vanion,  5. Nov 2010, 22:17:23):
+~#! rn=Gnome rt=1288991824 rg=schmarrn.netdigest
+~#! tid=1288950569
+qed
+
+-----------------------------------------------------------------------------
+
+
+
+Re^8: Whisky (Ark,  5. Nov 2010, 22:21:41):
+~#! rn=Vanion rt=1288991597 rg=schmarrn.netdigest
+~#! tid=1288950569
+Sagt das nun was ueber Whisky aus oder ueber Deinen Bekanntenkreis? *gruebel*
+:-)
+
+
+              *** ARK * the * Magnificent ***
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^10: Whisky (Alboin,  5. Nov 2010, 22:25:09):
+~#! rn=Vanion rt=1288991843 rg=schmarrn.netdigest
+~#! tid=1288950569
+Es stimmt es gibt sehr gute und sogar billige Rumsorten die es von der
+Qualitaet mit Whisky aufnehmen koennen. Ich tue es aber erst mal Gnome nach
+und hole meine Buddel Ardbeg, schon beim riechen scschlaegt mein Herz hoeher.
+al
+
+-----------------------------------------------------------------------------
+
+
+
+Re^11: Whisky (Vanion,  5. Nov 2010, 23:12:41):
+~#! rn=Alboin rt=1288992309 rg=schmarrn.netdigest
+~#! tid=1288950569
+Gerade beim falschen Ardbeg (ich hatte mal einen 10jaehrigen) koennen das auch
+Vergiftungserscheinungen sein.
+
+V*
+
+-----------------------------------------------------------------------------
+
+
+
+Re^12: Whisky (Alboin,  5. Nov 2010, 23:27:58):
+~#! rn=Vanion rt=1288995161 rg=schmarrn.netdigest
+~#! tid=1288950569
+Ja stimmt, das sind die Konservierungsstoffe.
+al
+
+-----------------------------------------------------------------------------
+
+
+
+Re^13: Whisky (Gwen,  6. Nov 2010, 14:25:03):
+~#! rn=Alboin rt=1288996078 rg=schmarrn.netdigest
+~#! tid=1288950569
+Was ist Cola-Brot?
+Gwen.
+
+-----------------------------------------------------------------------------
+
+
+
+Re^14: Whisky (Vanion,  6. Nov 2010, 16:19:29):
+~#! rn=Gwen rt=1289049903 rg=schmarrn.netdigest
+~#! tid=1288950569
+Cola-Rot, nicht Cola-Brot. Sei lieber froh, wenn Du nicht weisst, was das ist.
+Man muss wohl aus Speyer oder Karlsruhe kommen, um auf derartige
+Abscheulichkeiten zu stehen.
+
+V*
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Whisky (Gloinson,  7. Nov 2010, 03:14:39):
+~#! rn=Gnome rt=1288987849 rg=schmarrn.netdigest
+~#! tid=1288950569
+Als Ruepel kann man auch Zartbitter reinmampfen. Und als Geniesser Vollmilch
+zergehen lassen - die zergeht da auch etwas besser. Schau doch mal als
+Berliner haeufiger bei Rausch rein ;)
+
+Es gibt uebrigens einen sehr frauenkompatiblen Aquavit. Herrgards - mit Whisky
+verfeinert. Lecker :D
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^4: Whisky (Zook,  9. Nov 2010, 11:23:47):
+~#! rn=Vanion rt=1288980982 rg=schmarrn.netdigest
+~#! tid=1288950569
+Also das Gruenkohlessen des Berufsverbandes will ich mir gar nicht
+vorstellen muessen. Z
+
+-----------------------------------------------------------------------------
+
+
+
+Re^15: Whisky (Zook,  9. Nov 2010, 11:27:46):
+~#! rn=Vanion rt=1289056769 rg=schmarrn.netdigest
+~#! tid=1288950569
+Da haette ich ja nun einen Verdacht, wer der Banause ist. Kenn ich ihn/sie?
+Z
+
+-----------------------------------------------------------------------------
+
+
+
+Re^5: Whisky (Vanion, 10. Nov 2010, 21:35:25):
+~#! rn=Zook rt=1289298227 rg=schmarrn.netdigest
+~#! tid=1288950569
+Ich habe auch mehrfach bereuht, da zugeagt zu haben. Aber der Gruenkohl war
+schon lecker.
+
+V*
+
+-----------------------------------------------------------------------------
+
+
+
+Re^16: Whisky (Vanion, 10. Nov 2010, 21:36:09):
+~#! rn=Zook rt=1289298466 rg=schmarrn.netdigest
+~#! tid=1288950569
+Ein Karlsruher in dessen Vorgarten sich Fuchs und Hase gute Nacht sagen. Weiss
+nich, ob Dir das was sagt.
+
+V*
+
+-----------------------------------------------------------------------------
+
+
+
+Re^6: Whisky (Zook, 12. Nov 2010, 10:20:28):
+~#! rn=Vanion rt=1289421325 rg=schmarrn.netdigest
+~#! tid=1288950569
+Und der Aquavit ist geschmaeht worden?
+Z
+
+-----------------------------------------------------------------------------
+
+
+
+Re^7: Whisky (Vanion, 12. Nov 2010, 20:41:07):
+~#! rn=Zook rt=1289553628 rg=schmarrn.netdigest
+~#! tid=1288950569
+Ich musste fahren. Und hier oben gibts immer uebles Zeug (irgend ein Korn oder
+Kuemmel) oder uebles Zeug (irgendwas rotes, dass einem die Zaehne
+zusammenklebt). Vor allem wenn der Schnaps nach dem Gruenkohl fuer lau und so
+eisgekuehlt ist, dass man eh nicht merkt, was man da saeuft.
+
+Jofseidank ist "Ich muss noch fahren." immer eine halbwegs akzeptierte
+Ausrede.
+
+V*
+
+-----------------------------------------------------------------------------
+
+
+
+Re^8: Whisky (Gloinson, 12. Nov 2010, 21:20:24):
+~#! rn=Vanion rt=1289590867 rg=schmarrn.netdigest
+~#! tid=1288950569
+Reicht das Gewicht noch fuer "ich bin schwanger"? :)
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^9: Whisky (Vanion, 12. Nov 2010, 21:36:06):
+~#! rn=Gloinson rt=1289593224 rg=schmarrn.netdigest
+~#! tid=1288950569
+Gibt sicher einige Schwangere auf der Welt, die im 9. Monat die Haelfte des
+Gewichtes haben, das in Deutschland als Durchschnitt durchgeht.
+
+Bei mir passt jedenfalls die Bauchform. Vor allem nach einem Gruenkohl-Essen,
+welches ueblicherweise auf ewigen Fleischplatten und Schuesseln gereicht wird.
+
+V*
+
+-----------------------------------------------------------------------------
+
+
+
+Re^10: Whisky (Gloinson, 12. Nov 2010, 21:39:04):
+~#! rn=Vanion rt=1289594166 rg=schmarrn.netdigest
+~#! tid=1288950569
+Mh. Ich hab noch Sonne im Gemuet, bei mir braucht es noch eine Woche zur
+Pinkel+GK-Reife. Bekommen werde ich weder das eine noch das andere hier am
+Bodensee.
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^7: Whisky (Darklor, 17. Nov 2010, 19:49:29):
+~#! rn=Amaryllis rt=1288991119 rg=schmarrn.netdigest
+~#! tid=1288950569
+Hat er nicht...
+
+Darklor
+
+-----------------------------------------------------------------------------
+
+
+
+aus de.alt.netdigest (Amaryllis, 11. Apr 2012, 21:25:53):
+Subject: [arcor.misc] Re: Enkel des spanischen Koenigs schiesst sich in den
+Fuss
+From: Hans-Georg Bickel <hgbusenetmuell@gmx.de>
+Newsgroups: de.alt.netdigest
+Followup-To: de.talk.jokes.d
+
+Message-ID: <jm220d.1ec.1@stefan.msgid.phost.de>
+Date: Tue, 10 Apr 2012 19:34:37 +0200
+From: Stefan Reuther <stefan.news@arcor.de>
+Newsgroups: arcor.misc
+Subject: Re: Enkel des spanischen Koenigs schiesst sich in den Fuss
+
+Arcor Newsticker wrote:
+> DPA 2012-04-10 15:32:43
+> Der aeltester Enkel des spanischen Koenigs Juan Carlos, Felipe Juan
+> Froiln, hat sich mit einem Gewehr versehentlich in den Fuss
+> geschossen.
+
+Also ich mach das ja lieber mit C++.
+
+
+  Stefan	
+
+
+-----------------------------------------------------------------------------
+
+
+
