Il codice + geniale della storia...

[^TiGeRShArK^]

Guardate cosa ho trovato ravanando nel codice....:mbe:


public static final boolean BEEP_DEBUG = false;

public static void beep() {
if (BEEP_DEBUG) {
try {
throw new NullPointerException();
} catch (Exception ex) {
System.err.println("BEEP !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
ex.printStackTrace();
}
}

java.awt.Toolkit.getDefaultToolkit().beep();
}

è o non è il pezzo di codice + geniale mai scritto da un essere umano? :fagiano:

[beppegrillo]

indubbiamente..
BEEEEEEEEEEEEEEEEEEEPPPPPPPPPP :D

[Energy++]

ravanando nel codice di??

[ianaz]

ravanando nel codice di??
*

[^TiGeRShArK^]

ravanando nel codice di??
non si può dire dove l'ho preso :O
da notare l'IF in cui non entra mai e SOPRATTUTTO l'eccezione lanciata e catchata subito dopo :mbe:

[akyra]

magari voleva solo fare una prova per veder come si lanciano le eccezioni....
.....e magari si sarà scervellato per giorni e giorni sul come mai quel pezzo di codice non scriveva mai "BEEEEEEEEEEP!!!!!!" pensando di aver sbagliato a lanciare l'eccezione :asd: :asd:

[ianaz]

non si può dire dove l'ho preso :O
da notare l'IF in cui non entra mai e SOPRATTUTTO l'eccezione lanciata e catchata subito dopo :mbe:
E bom ma non puoi non dire dove l'hai preso...
Vieni qui, credi un thread iasbcczbuacb j

potresti averlo fatto tu.... capisco se fosse la Microsoft ma altrimenti che c'é di strano? :)

edit ma poi lo usava come debug, cambiava il valore a quella variabile e via...
dove cavolo l'hai preso?

[PGI-Bis]

L'if in cui non entra mai è un classico dei debug vecchia maniera ed è una condizione esplicitamente citata forse nel Gosling o addirittura nelle specifiche del linguaggio. La storia è che il compilatore che normalmente dovrebbe dichiarare come irraggiungibile un percorso condizionato da un "false" non lo fa se quel false è il valore di una variabile boolean costante.

Suppongo inoltre che la condizione intercettata e rilasciata sia stata inserita per ottenere la traccia dello stack frame del Thread di esecuzione.

Probabilmente al creatore è sfuggito l'appiglio offerto da Thread.currentThread().getStackTrace() oppure ha scelto di non usarlo per brevità. Scelta che non condivido ma l'effetto è quello. Anche il beep potrebbe avere un senso se immaginiano che l'esecuzione del debug richieda tempi lunghi e magari i casi di invocazione di quel codice siano eventuali e sporadici.

Tutto questo per dire che un significato ce l'ha il che è molto: il vero "orendo" per me è ben altro :eek:

[^TiGeRShArK^]

E bom ma non puoi non dire dove l'hai preso...
Vieni qui, credi un thread iasbcczbuacb j

potresti averlo fatto tu.... capisco se fosse la Microsoft ma altrimenti che c'é di strano? :)

edit ma poi lo usava come debug, cambiava il valore a quella variabile e via...
dove cavolo l'hai preso?
è un pezzettino microscopico del software ke hanno scritto dove lavoro attualmente :muro:
Vabbè ke su diverse centinaia di migliaia di righe di codice ci si aspetta di trovare di tutto..
ma questo non me lo sarei mai aspettato :mbe:

[Andrea16v]

Simpatico questo codice.. :)

[ally]

...altrettanto notevole...

(from Usenet)

> I am new to java, and I really havent had time to do much work in it.
> However, I have a small project that is due next week for my class. Can
> anyone help me by providing some code? It should do the following;
>
> The program is simple. It should allow a user to input a string of digits,
> and then output the sum of those digits.
>
> For example; the user inputs 3563
> the program would then output 17 (3+5+6+3)

and one the answer was

public class Homework{public static void main (String[] OoO) {for (int
oOo=0;oOo<OoO.length;++oOo) main (OoO [oOo]);} public static void main
(String oOo){String Oo0="9876543210"; long o0o=oOo.length()*Oo0.length
();for(int OoO=oOo.length();--OoO>=0;) {int O0O=Oo0.indexOf(oOo.charAt
(OoO));o0o-=O0O<0?012:++O0O;} main(oOo,o0o);} public static void main(
String Oo0,long oOo){System.out.print("Sum of digits in ");for(int O0O
=0;O0O<Oo0.length();++O0O)System.out.print(Oo0.charAt(O0O));System.out
.print(" = ");System.out.println(oOo);}}

...il programma è stato presentato esattamente così...privo di ogni indentazione...un seguace della lotta contro la pappa pronta?...

...ciao..

[jappilas]

...
public class Homework{public static void main (String[] OoO) {for (int
oOo=0;oOo<OoO.length;++oOo) main (OoO [oOo]);} public static void main
(String oOo){String Oo0="9876543210"; long o0o=oOo.length()*Oo0.length
();for(int OoO=oOo.length();--OoO>=0;) {int O0O=Oo0.indexOf(oOo.charAt
(OoO));o0o-=O0O<0?012:++O0O;} main(oOo,o0o);} public static void main(
String Oo0,long oOo){System.out.print("Sum of digits in ");for(int O0O
=0;O0O<Oo0.length();++O0O)System.out.print(Oo0.charAt(O0O));System.out
.print(" = ");System.out.println(oOo);}}

...il programma è stato presentato esattamente così...privo di ogni indentazione...un seguace della lotta contro la pappa pronta?...

...ciao..altro che lotta contro la pappa pronta, questo è offuscamento voluto ... :mbe:
personalmente credo che uno, che distingue 5 variabili in una routine chiamandole
OoO
oOo
Oo0
O0O
o0o
lo fustigherei tenendolo inginocchiato sui ceci - ma voi non è detto dobbiate imitarmi eh :O

[thebol]

L'if in cui non entra mai è un classico dei debug vecchia maniera ed è una condizione esplicitamente citata forse nel Gosling o addirittura nelle specifiche del linguaggio. La storia è che il compilatore che normalmente dovrebbe dichiarare come irraggiungibile un percorso condizionato da un "false" non lo fa se quel false è il valore di una variabile boolean costante.


ho usato quest'espediente proprio l'altro giorno....
avevo bisogno di lanciare un eccezione in un metodo lungo 20 righe(per provare una cosa), e ho messo la throw in testa. Eclipse si è subito lamentato del fatto che ci fosse del codice irraggiungibile e l'ho fregato con un if(true) :asd:

[71104]

public class Homework{public static void main (String[] OoO) {for (int
oOo=0;oOo<OoO.length;++oOo) main (OoO [oOo]);} public static void main
(String oOo){String Oo0="9876543210"; long o0o=oOo.length()*Oo0.length
();for(int OoO=oOo.length();--OoO>=0;) {int O0O=Oo0.indexOf(oOo.charAt
(OoO));o0o-=O0O<0?012:++O0O;} main(oOo,o0o);} public static void main(
String Oo0,long oOo){System.out.print("Sum of digits in ");for(int O0O
=0;O0O<Oo0.length();++O0O)System.out.print(Oo0.charAt(O0O));System.out
.print(" = ");System.out.println(oOo);}} deoffuscamento:

public class Homework
{
public static void main(String[] arguments)
{
for (int i = 0; i < arguments.length; ++i)
{
main(arguments[i]);
}
}

public static void main(String singleArgument)
{
String digits = "9876543210";
long length = singleArgument.length() * digits.length();
for (int i = singleArgument.length(); --i >= 0;)
{
int index = digits.indexOf(singleArgument.charAt(i));
length -= index < 0 ? 10 : ++index;
}
main(singleArgument, length);
}

public static void main(String argument, long length)
{
System.out.print("Sum of digits in ");
for (int i = 0; i < argument.length(); ++i)
{
System.out.print(argument.charAt(i));
}
System.out.print(" = ");
System.out.println(length);
}

}

mi spiace ma nulla resiste al formatter di eclipse :asd:

mancherebbe solo da dare dei nomi decenti ai tre main, comunque orientativamente il tizio è un emerito coglione (algoritmo di complessità quadratica per quella cazzata?? :eek: ma che fesso :fagiano: )

[PGI-Bis]

Io la trovo una soluzione elegante e non banale. Sicuro che sia quadratico? A me sembra un O(n) ma potrei sbagliarmi.

[VegetaSSJ5]

...altrettanto notevole...

(from Usenet)

> I am new to java, and I really havent had time to do much work in it.
> However, I have a small project that is due next week for my class. Can
> anyone help me by providing some code? It should do the following;
>
> The program is simple. It should allow a user to input a string of digits,
> and then output the sum of those digits.
>
> For example; the user inputs 3563
> the program would then output 17 (3+5+6+3)

and one the answer was

public class Homework{public static void main (String[] OoO) {for (int
oOo=0;oOo<OoO.length;++oOo) main (OoO [oOo]);} public static void main
(String oOo){String Oo0="9876543210"; long o0o=oOo.length()*Oo0.length
();for(int OoO=oOo.length();--OoO>=0;) {int O0O=Oo0.indexOf(oOo.charAt
(OoO));o0o-=O0O<0?012:++O0O;} main(oOo,o0o);} public static void main(
String Oo0,long oOo){System.out.print("Sum of digits in ");for(int O0O
=0;O0O<Oo0.length();++O0O)System.out.print(Oo0.charAt(O0O));System.out
.print(" = ");System.out.println(oOo);}}

...il programma è stato presentato esattamente così...privo di ogni indentazione...un seguace della lotta contro la pappa pronta?...

...ciao..
o_O

[marco.r]

Io la trovo una soluzione elegante e non banale. Sicuro che sia quadratico? A me sembra un O(n) ma potrei sbagliarmi.
Forse si riferisce al ricorso a "indexOf" (son poco pratico di Java, potrei sbagliarmi).
Elegante secondo me no, non so in Java, ma in altri linguaggi bastano 2-3 righe :mbe:

[PGI-Bis]

E' per via della sottrazione. Non che non si possa fare tutto più sintetico e c'è qualche bizzarria ma io non avrei pensato ad una soluzione simile. Ha tanto dell'hack. Tutto qua.

[thebol]

Io la trovo una soluzione elegante e non banale. Sicuro che sia quadratico? A me sembra un O(n) ma potrei sbagliarmi.
anche a me sembra O(n).

Le cose da "ottimizzare" a occhio, sono il ciclo for per stampare la stringa(si stampa da sola :asd: ) e la stringa digits che funziona anche come String digits = "987654321"; a patto di sostituire digits.length() con 10.

Per il resto la trovo anche io una soluzione elegante(e ci ho messo un po a capirla fra l'altro...)

[71104]

la soluzione migliore che riesco a pensare:

public class Homework
{
private static final int DIGITS[] = {0,1,2,3,4,5,6,7,8,9};

public static void main(String[] arguments)
{
for (int i = 0; i < arguments.length; ++i)
{
processArgument(arguments[i]);
}
}

public static void processArgument(String argument)
{
long result = 0;

for (int i = 0; i < argument.length(); i++)
{
try
{
result += DIGITS[argument.charAt(i) - '0'];
}
catch (IndexOutOfBoundsException e)
{
return;
}
}

System.out.print("Sum of digits in " + argument + " = ");
System.out.println(result);
}

}


:fagiano: :fagiano: :fagiano:

comunque si, il fatto che la complessità fosse quadratica (o almeno così mi pare) era riferito all'uso di indexOf.

[phoenixbf]

non si può dire dove l'ho preso :O
da notare l'IF in cui non entra mai e SOPRATTUTTO l'eccezione lanciata e catchata subito dopo :mbe:

ehm... guarda che lo dice la variabile stessa "BEEP_DEBUG" :rolleyes:

Sicuramente a sto tizio gli serviva per debuggare quella porzione di codice attivando e disattivando quel booleano e testare le eccezioni forse.

E cmq ve lo dico io qual'e' il codice + geniale della storia, il non plus ultra, er mejo, the best, il + paura, insomma, in una riga:

while (1) fork();

Vi sfido a trovare una riga piu bella di questa.

[trallallero]

while (1) fork();

Vi sfido a trovare una riga piu bella di questa.
preferisco questa:

while( !sbronzo )
birra++;

[marco.r]

preferisco questa:

while( !sbronzo )
birra++;

:nonsifa:
Prima incrementi il numero di birre sul tuo tavolo, e poi te le bevi
Senza contare che non e' necessario essere sobri per bere :D

while ( ! fusto.empty() )
++birra;

:p

[marco.r]

Comunque per tornare al topic originale, ci sono un sacco di esempi di codice "interessante" anche nell'open source
Il seguente e' tratto dal codice di YUM (o perlomeno lo era un po' di tempo fa):

symbols = ['', # (none)
'k', # kilo
'M', # mega
'G', # giga
'T', # tera
'P', # peta
'E', # exa
'Z', # zetta
'Y'] # yotta

# ... snip ...

thresh = 999

depth = 0

while number > thresh:
depth = depth + 1
number = number / 1024

# just in case someone needs more than 1000 yottabytes!
diff = depth - len(symbols) + 1

if diff > 0:
depth = depth - diff
number = number * thresh**depth

Quando si dice pensare avanti ! :D

[trallallero]

:nonsifa:
Prima incrementi il numero di birre sul tuo tavolo, e poi te le bevi
Senza contare che non e' necessario essere sobri per bere :D

while ( ! fusto.empty() )
++birra;

:p
:cincin:

[^TiGeRShArK^]

ehm... guarda che lo dice la variabile stessa "BEEP_DEBUG" :rolleyes:

Sicuramente a sto tizio gli serviva per debuggare quella porzione di codice attivando e disattivando quel booleano e testare le eccezioni forse.
:muro:
ma l'avevo capito subito che era per debug.:doh:
Ma ora tu lasci quello schifosissimo codice IN PRODUZIONE???
Se vuoi fare delle schifezze del genere, (dato che x me quella è una schifezza, non c'è molto da dire, in quanto è codice INUTILE ai fini del FUNZIONAMENTO del software) te la fai sul tuo hard disk, non la vai certo a committare sotto n-mila branch del CVS cosicchè anche gli altri si ritrovano codice del genere.
E' x me ESATTAMENTE allo stesso livello di quello che ha committato un file in cui c'era un percorso assoluto che puntava ad un file sul suo hard-disk :doh:
Mah..
forse sarò coglione io che le cose UTILI (e non sta cavolata che ci metti TRE sec a scriverla SE ti dovesse servire) che faccio x il debugging me le tengo sul mio HDD e le metto nell'area condivisa piuttosto che insozzare così il repository :doh:

[marco.r]

Infine un'ultima perla per gentile concessione di The Daily WTF (http://www.thedailywtf.com)

link: http://thedailywtf.com/Articles/How_Not_to_Parse_Command_Line_Arguments.aspx

public static void main (String args[])
{
// Get a hash value for the first argument
int hash = getHashValue(args[0].toCharArray());

switch(hash)
{
case 972346: // The first argument was "help"
...
break;
case -91058: // The first argument was "single"
...
break;
case -4830672: // The first argument was "multi"
...
break;
// etc
}
}

[RaouL_BennetH]

o_O

:mbe:

cos'è... un suggerimento per il nome delle variabili al posto delle "oOo" ?

:D

Scherzi a parte, quando leggo questi 3d mi sento male, perchè mentre voi siete esperti e vi divertite, io mi sento mortificato perchè scrivo codice peggiore del loro :( e nemmeno lo capisco.

[PGI-Bis]

Non cominciamo com gli insulti: esperto a me non l'ha mai detto nessuno! :D

Circa lo scrivere cialtronerie sono certo di non esserne esente. Giusto l'altro ieri volevo scrivere un tutorial sul disegno bitmap. Ho creato l'applicazione e poi ho iniziato a spiegarla. Be', appena sono arrivato a dover dire qualcosa del codice che ho scritto la prima frase che m'è venuta in mente è stata "questa roba qui l'ha fatta un maccabeo". E l'avevo finita si e no 24 ore prima :D.

[k0nt3]

questo codice è il migliore :fagiano:

/* If you are a third party developer and you need a quick fix, add
* #define I_AM_A_THIRD_PARTY_DEVELOPER_WHO_NEEDS_TO_BE_KICKED_IN_THE_HEAD_BY_CHUCK_NORRIS
* to your code.
*
* - nenolod, 05/09/2006
*/
#ifndef I_AM_A_THIRD_PARTY_DEVELOPER_WHO_NEEDS_TO_BE_KICKED_IN_THE_HEAD_BY_CHUCK_NORRIS
#pragma GCC poison xmms_cfg_new
#pragma GCC poison xmms_cfg_open_file
#pragma GCC poison xmms_cfg_write_file
#pragma GCC poison xmms_cfg_open_default_file
#pragma GCC poison xmms_cfg_write_default_file
#pragma GCC poison xmms_cfg_read_value
#pragma GCC poison xmms_cfg_write_value
#pragma GCC poison xmms_cfg_read_string
#pragma GCC poison xmms_cfg_read_int
#pragma GCC poison xmms_cfg_read_boolean
#pragma GCC poison xmms_cfg_read_float
#pragma GCC poison xmms_cfg_read_double
#pragma GCC poison xmms_cfg_write_string
#pragma GCC poison xmms_cfg_write_int
#pragma GCC poison xmms_cfg_write_boolean
#pragma GCC poison xmms_cfg_write_float
#pragma GCC poison xmms_cfg_write_double
#pragma GCC poison xmms_cfg_remove_key
#endif
...
...