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	


-----------------------------------------------------------------------------



