Programistyczne WTF jakie Was spotkały

Heckle (jedno z narzędzi do testowania w Ruby) i wszystko staje się jasne:

...a to fragment wyniku testowanie modelu ? /???/???/????/±???/1.8/±???/?????????????-3.0.3/???/?????????????.??:225:?? ????????'
°??? /???/???/????/±???/1.8/±???/?????????????-3.0.3/???/?????????????.??:264:?? ?????????????'
°??? /???/???/????/±???/1.8/±???/?????????????-3.0.3/???/?????????????.??:224:?? ????????'
°??? /???/???/????/±???/1.8/±???/?????????????-3.0.3/???/?????????????.??:225:?? ????????'
°??? /???/???/????/±???/1.8/±???/?????????????-3.0.3/???/?????????????.??:264:?? ?????????????'
... 18 ??????...
°??? /???/???/????/±???/1.8/±???/??????-1.4.3/???/../???/???????????????.??:79:?? ?????????'

ids = (new_value or []).reject { |nid| nid.blank? }

• send("#{reflection.name}=", reflection.class_name.constantize.find(ids))
  oM$zyC├5]°KK@*␊@6)G─⎼#⎽M+0M%A┐08≥S", ⎼␊°┌␊␌├␋⎺┼.␌┌▒⎽⎽_┼▒└␊.␌⎺┼⎽├▒┼├␋≥␊.°␋┼␍(␋␍⎽))
  ␊┼␍

--- ⎺⎼␋±␋┼▒┌
+++ └┤├▒├␋⎺┼
␍␊° ┬▒⎼┼␋┼±␋␍⎽=(┼␊┬┴▒┌┤␊)
␋␍⎽ = (┼␊┬_┴▒┌┤␊ ⎺⎼ []).⎼␊┘␊␌├ π ≠┼␋␍≠ ┼␋␍.␉┌▒┼┐? £

• ⎽␊┼␍("#π⎼␊°┌␊␌├␋⎺┼.┼▒└␊£=", ⎼␊°┌␊␌├␋⎺┼.␌┌▒⎽⎽_┼▒└␊.␌⎺┼⎽├▒┼├␋≥␊.°␋┼␍(␋␍⎽))

• ⎽␊┼␍("#π⎼␊°┌␊␌├␋⎺┼.┼▒└␊£=", ┼␋┌.␌⎺┼⎽├▒┼├␋≥␊.°␋┼␍(␋␍⎽))
  ␊┼␍

--- ⎺⎼␋±␋┼▒┌
+++ └┤├▒├␋⎺┼
␍␊° ┬▒⎼┼␋┼±␋␍⎽=(┼␊┬┴▒┌┤␊)
␋␍⎽ = (┼␊┬_┴▒┌┤␊ ⎺⎼ []).⎼␊┘␊␌├ π ≠┼␋␍≠ ┼␋␍.␉┌▒┼┐? £

• ⎽␊┼␍("#π⎼␊°┌␊␌├␋⎺┼.┼▒└␊£=", ⎼␊°┌␊␌├␋⎺┼.␌┌▒⎽⎽_┼▒└␊.␌⎺┼⎽├▒┼├␋≥␊.°␋┼␍(␋␍⎽))

• ⎽␊┼␍("#π⎼␊°┌␊␌├␋⎺┼.┼▒└␊£=", ┼␋┌.°␋┼␍(␋␍⎽))
  ␊┼␍

--- ⎺⎼␋±␋┼▒┌
+++ └┤├▒├␋⎺┼
␍␊° ┬▒⎼┼␋┼±␋␍⎽=(┼␊┬┴▒┌┤␊)
␋␍⎽ = (┼␊┬_┴▒┌┤␊ ⎺⎼ []).⎼␊┘␊␌├ π ≠┼␋␍≠ ┼␋␍.␉┌▒┼┐? £

• ⎽␊┼␍("#π⎼␊°┌␊␌├␋⎺┼.┼▒└␊£=", ⎼␊°┌␊␌├␋⎺┼.␌┌▒⎽⎽_┼▒└␊.␌⎺┼⎽├▒┼├␋≥␊.°␋┼␍(␋␍⎽))

• ⎽␊┼␍("#π⎼␊°┌␊␌├␋⎺┼.┼▒└␊£=", ┼␋┌)
  ␊┼␍

--- ⎺⎼␋±␋┼▒┌
+++ └┤├▒├␋⎺┼
␍␊° ┬▒⎼┼␋┼±␋␍⎽=(┼␊┬┴▒┌┤␊)
␋␍⎽ = (┼␊┬_┴▒┌┤␊ ⎺⎼ []).⎼␊┘␊␌├ π ≠┼␋␍≠ ┼␋␍.␉┌▒┼┐? £

• ⎽␊┼␍("#π⎼␊°┌␊␌├␋⎺┼.┼▒└␊£=", ⎼␊°┌␊␌├␋⎺┼.␌┌▒⎽⎽_┼▒└␊.␌⎺┼⎽├▒┼├␋≥␊.°␋┼␍(␋␍⎽))
  ␊┼␍

• U⎽␊⎼#┬▒⎼┼␋┼±⎽ ┌⎺▒␍␊␍ ┬␋├␤ 14 ⎻⎺⎽⎽␋␉┌␊ └┤├▒├␋⎺┼⎽

14 └┤├▒├␋⎺┼⎽ ⎼␊└▒␋┼␋┼±...
13 └┤├▒├␋⎺┼⎽ ⎼␊└▒␋┼␋┼±...
12 └┤├▒├␋⎺┼⎽ ⎼␊└▒␋┼␋┼±...
11 └┤├▒├␋⎺┼⎽ ⎼␊└▒␋┼␋┼±...
10 └┤├▒├␋⎺┼⎽ ⎼␊└▒␋┼␋┼±...
9 └┤├▒├␋⎺┼⎽ ⎼␊└▒␋┼␋┼±...
8 └┤├▒├␋⎺┼⎽ ⎼␊└▒␋┼␋┼±...
7 └┤├▒├␋⎺┼⎽ ⎼␊└▒␋┼␋┼±...
6 └┤├▒├␋⎺┼⎽ ⎼␊└▒␋┼␋┼±...
5 └┤├▒├␋⎺┼⎽ ⎼␊└▒␋┼␋┼±...
4 └┤├▒├␋⎺┼⎽ ⎼␊└▒␋┼␋┼±...
3 └┤├▒├␋⎺┼⎽ ⎼␊└▒␋┼␋┼±...
2 └┤├▒├␋⎺┼⎽ ⎼␊└▒␋┼␋┼±...
1 └┤├▒├␋⎺┼⎽ ⎼␊└▒␋┼␋┼±...

T␤␊ °⎺┌┌⎺┬␋┼± └┤├▒├␋⎺┼⎽ ␍␋␍┼'├ ␌▒┤⎽␊ ├␊⎽├ °▒␋┌┤⎼␊⎽:

--- ⎺⎼␋±␋┼▒┌
+++ └┤├▒├␋⎺┼
␍␊° ┬▒⎼┼␋┼±⎽(*⎻▒⎼▒└⎽)

• °⎺⎼␌␊_⎼␊┌⎺▒␍ = ⎻▒⎼▒└⎽.°␋⎼⎽├ ┤┼┌␊⎽⎽ ⎻▒⎼▒└⎽.␊└⎻├≤?

• °⎺⎼␌␊⎼␊┌⎺▒␍ = ⎻▒⎼▒└⎽.°␋⎼⎽├ ┤┼┌␊⎽⎽ ┼␋┌
  ▒⎽⎽⎺␌␋▒├␋⎺┼ = ▒⎽⎽⎺␌␋▒├␋⎺┼␋┼⎽├▒┼␌␊±␊├(⎼␊°┌␊␌├␋⎺┼.┼▒└␊)
  ┤┼┌␊⎽⎽ ▒⎽⎽⎺␌␋▒├␋⎺┼ ├␤␊┼
  ▒⎽⎽⎺␌␋▒├␋⎺┼ = ▒⎽⎽⎺␌␋▒├␋⎺┼⎻⎼⎺│≤␌┌▒⎽⎽.┼␊┬(⎽␊┌°, ⎼␊°┌␊␌├␋⎺┼)
  ▒⎽⎽⎺␌␋▒├␋⎺┼␋┼⎽├▒┼␌␊⎽␊├(⎼␊°┌␊␌├␋⎺┼.┼▒└␊, ▒⎽⎽⎺␌␋▒├␋⎺┼)
  ␊┼␍
  ▒⎽⎽⎺␌␋▒├␋⎺┼.⎼␊┌⎺▒␍ ␋° °⎺⎼␌␊⎼␊┌⎺▒␍
  ▒⎽⎽⎺␌␋▒├␋⎺┼
  ␊┼␍

--- ⎺⎼␋±␋┼▒┌
+++ └┤├▒├␋⎺┼
hckle i już wszystko wiem :D

Chyba nagle zniknął cały dziwny kod, bo nikt tu nie pisał od trzech miesięcy. :)

Zadanie jest banalne - napisać funkcję, która dla podanej liczby znaków zwróci liczbę bajtów jakie zajmą po upakowaniu w GSM7 (bo każdy znak zajmuje 7 bitów, dzięki czemu 160 znaków SMSa == 140 bajtów).

W projekcie służył do tego taki kod:

int countGsm7Size(int l)
{
    return l * 7.0f / 8.0f + 0.9f;
}

Niech mi ktoś wyjaśni po co tak? :|

http://4programmers.net/Forum/viewtopic.php?id=158586

return l * 7.0f / 8.0f + 0.9f;

może dla wydajnosci?

Taaa, + 0.9f dla wydajności...

+0.9f jest dlatego że po obliczeniu następuje obcinanie do inta, a przecież jeśli coś zajmuje 6.4 bajtów to nie zapiszemy tego w 6 bajtach. W zasadzie ten sposób liczenia jest kiepski i lepiej aby zrobić to tak:
return ((l * 7) + 7) / 8
To +7/ 8 służy temu samemu co +0.9f powyżej.

Może nie tyle WTF, ale podzielę się refleksją jaka mnie ostatnio naszła. W dobrym tonie jest aby funkcja mieściła się na ekranie... dlatego też każdy kolejny rocznik programistów kupuje coraz większe monitory. Nie żebym na stare lata narzekał, że młodzi w tym fachu coraz gorszy kod produkują.

donkey - jak ktoś chce szybko to powinien to zrobić np tak:

result:=l-(l shr 3);

Skoro jesteśmy przy "wyszukanych" optymalizacjach to mam dla was kawałek GIMP-a:

#define INT_DIV(a, b) ((a)/(b) + (((a) % (b)) > ((b) / 2)))

Dwa przykłady idiotyzmów, za które powinno się pracę/dostęp do kompilatora tracić. Optymalizacje na najniższym poziomie to zadanie dla kompilatora, takie sztuczki tylko je utrudniają.

Świętowit:
To nie idiotyzm. Podaj jakiś łatwiejszy sposób na dzielenie intów z zaokrąglaniem, czyli np:

5 / 3 = 2
8 / 7 = 1
15 / 6 = 3

No dobra, tylko generalnie inty i dzielenie z zaokrągleniem to lekka sprzeczność. Poza tym na preprocesorze?

Wydaje mi się, że jeśli mamy do wykonania zadanie: "Daną liczbę zmniejsz o tyle, ile razy mieści się w niej 8", to zapis:

return l * 7.0f / 8.0f + 0.9f;

słabo to odzwierciedla.
Myślę, że lepiej byłoby tak:
return l - l / 8;
I tak ca 15 razy wydajniej (co rzecz jasna nie ma znaczenia w tej sytuacji). Bardziej bałbym się jakichś błędów w obliczeniach dla większych liczb przez te "f".
No, ale mogę nie mieć racji.

http://4programmers.net/Forum/621818 napisał(a)

if ($_POST['pass'] == $password) {} else echo '<b>Bd. Haso jest nieprawidowe</b><br>';

No co? Ja też tak kiedyś pisałem, tylko że z !=, bo nie działał mi warunek:

if ($a = $b) {

}

A przyzwyczajony do Delphi nie wiedziałem o co chodzi...

WTF newbie nie są aż takie fajne...

Przykład kodu od pewnego wykładowcy na jednej z polskich uczelni:

<?
//prosty formularz dodawania zmiennych
//sprawdzenie, czy zostaly zmienne zostaly już zainicjowane, czy formularz zostal juz wyslany
if (empty($_POST[a]) || empty($_POST[b])) {
//jesli nie, to jest wyswietlany sam formularz
echo '
<FORM NAME="dodawanie" ACTION="dodawanie.php" METHOD="POST">
<INPUT TYPE="text" NAME="a" VALUE=""> + <INPUT TYPE="text" NAME="b" VALUE="">
<INPUT TYPE="submit" VALUE="Dodaj">
</FORM>
' ;
}
//jesli zmienne zostaly juz zaincjowane, to wykonywane jest dzialanie i wyswietlany wynik
else
{
$c=$_POST[a] +$_POST[b] ;

//oraz formularz do ponownych obliczen
echo "<B>Poprzedni wynik:</B> $c";
echo '
<FORM NAME="dodawanie" ACTION="dodawanie.php" METHOD="POST">
<INPUT TYPE="text" NAME="a" VALUE=""> + <INPUT TYPE="text" NAME="b" VALUE="">
<INPUT TYPE="submit" VALUE="Dodaj">
</FORM>
' ;
}

?>

Tra-ge-dia! Aczkolwiek to się nadaje bardziej do tematu "ogólny żal polskiego systemu nauczania" ;)

IMHO. To zależy w jakim celu ten kod powstał. Może gość demonstrował niezawodny przepis na spaghetti.

echo "<B>Poprzedni wynik:</B> $c";
echo '
<FORM [...]
';

I niezawodny przepis na stworzenie buga rodem z mailera UPC:

Imo zmiennych nigdy nie powinno być wewnątrz stringa, to masakra...<font color="white"></php></span>

donkey7 napisał(a)

Świętowit:
To nie idiotyzm. Podaj jakiś łatwiejszy sposób na dzielenie intów z zaokrąglaniem, czyli np:

5 / 3 = 2
8 / 7 = 1
15 / 6 = 3
LOL

int roundDiv(int a, int b) {
    return (a+(((a^b)>=0?b:-b)>>1))/b;
}

te zamieszanie z "?" jest potrzebne dla liczb ujemnych. Dla liczb bez znaku masz proste: (a+b>>1))/b

Dla liczb bez znaku masz proste: (a+b>>1))/b

I cudowne przepełnienie :D

#define INT_DIV(a, b) ((a)/(b) + (((a) % (b)) > ((b) / 2)))

Wywołanie INT_DIV w asemblerze dla liczb bez znaku będzie wyglądać np tak:

mov ebx, b
mov eax, a
xor edx, edx
div ebx
shr ebx, 1
cmp ebx, edx
adc eax, 0

Wynik w eax.

Dla liczb ze znakiem nawet nie wiem czy ta wstawka INT_DIV będzie dobrze liczyć i w którą stronę zaokrąglać, nie chce mi się sprawdzać.

EDIT:
No chyba, że zastosuje się rozszerzenie wielkości reprezentacji dla Twojej wstawki. No ale wtedy kod wygląda tak:

mov ebx, b
mov eax, ebx
shr eax, 1
cdq
add eax, a
adc edx, 0
div ebx

Ii tak ten kod się chyba wolniej wykonuje.

Jeśli nie przemujesz się przypadkami brzegowymi to polecam zajrzeć np na:
http://en.wikipedia.org/wiki/Pentium_FDIV_bug
http://www.netjeff.com/humor/item.cgi?file=PentiumJokes
:]

Dziś chciałem napisać coś takiego (C#):

product.VatRate = info.VatRate == "-1" ? null : byte.Parse(info.VatRate);

WTF jak dla mnie, że to się nie kompiluje. Czyżbym robił krzywdę Billowi? Typy prawidłowe, po przeróbce na if-else działa. Chore ograniczenie operatora ?:.

Pewnie null nie jest wyrazeniem, a gdyby tam bylo cos, co zwraca nulla to by poszlo

byte (zwracany z byte.Parse) jest value type, podczas gdy null moze byc przypisany do reference type. Co napisal kompilator?

Dzisiejsze facepalm. Rozwiązanie zadania http://main.edu.pl/user.phtml?op=showtask&task=ukr&con=OIG4 przez jednego z gimnazjalistów:

     #include<iostream>
     using namespace std;
     int nie=0;
     int a, b, c=0, d;
     long long suma=0;
    int liczba[7];
     string slowo;
     void sprawdz(char x)
     {
         if(x=='0'||x=='1'||x=='2'||x=='3'||x=='4'||x=='5'||x=='6'||x=='7'||x=='8'||
       x=='9')
        {
            liczba[c]=x;
            liczba[c]=liczba[c]-48;
            c++;
        }
       else
        {
            switch(c)
          {
                case 6: suma=suma+liczba[5]+liczba[4]*10+liczba[3]*100+liczba[2]*1000+liczba[1]*10000+liczba[0]*100000;
                liczba[0]=0;
               liczba[1]=0;
               liczba[2]=0;
                liczba[3]=0;
                liczba[4]=0;
                liczba[5]=0;
               c=0; break;
               case 5: suma=suma+liczba[4]+liczba[3]*10+liczba[2]*100+liczba[1]*1000+liczba[0]*10000;
                liczba[0]=0;
                liczba[1]=0;
                liczba[2]=0;
                liczba[3]=0;
                liczba[4]=0;
                liczba[5]=0;
             c=0; break;
            case 4: suma=suma+liczba[3]+liczba[2]*10+liczba[1]*100+liczba[0]*1000;
                liczba[0]=0;
                liczba[1]=0;
                liczba[2]=0;
                liczba[3]=0;
                liczba[4]=0;
                liczba[5]=0;
                c=0; break;
                case 3: suma=suma+liczba[2]+liczba[1]*10+liczba[0]*100;
                liczba[0]=0;
                liczba[1]=0;
                liczba[2]=0;
                liczba[3]=0;
               liczba[4]=0;
               liczba[5]=0;
                c=0; break;
                case 2: suma=suma+liczba[1]+liczba[0]*10;
                liczba[0]=0;
               liczba[1]=0;
                liczba[2]=0;
              liczba[3]=0;
                liczba[4]=0;
              liczba[5]=0;
                c=0; break;
               case 1: suma=suma+liczba[0];
               liczba[0]=0;
                liczba[1]=0;
            liczba[2]=0;
               liczba[3]=0;
            liczba[4]=0;
                liczba[5]=0;
               c=0; break;
                default: c=0; break;
            }
        }
    }
    int main()
    {
        cin>>a;
        cin.ignore();
        getline(cin, slowo);
        for(b=0; b<=a; b++)
        {
            sprawdz(slowo[b]);
       }
        cout<<suma;
       return 0;
    }

Formatowanie oryginalne i bez moich zmian.

johny_bravo napisał(a)

byte (zwracany z byte.Parse) jest value type, podczas gdy null moze byc przypisany do reference type.

Właśnie dziwne dla mnie jest to, że w przypadku operatora ?: kompilator sprawdza czy argumenty na lewo i prawo od dwukropka są jednego typu, w ogóle nie biorąc pod uwagę typu zmiennej, do której podstawiamy. Rozwiązanie jest proste, trzeba rzutować null na byte?, ale to niepotrzebna upierdliwość IMHO.

duży skrypt bashowy odpalany z root'a zawierał :
rm -rf $BACKUP_PATH/*
Zmienna środowiskowa BACKUP_PATH nie była sprawdzana czy istnieje...

@winerfresh: bez przesady, widziałem kupę głupszych kodów, a czepianie się kodu gimnazjalisty to trochę przesada - ma pisać jak ktoś z 10. letnim doświadczeniem?

Analizuję sobie kod, który w firmie działa już od lat, ale wyszedł jakiś błąd, no i nikt nie chce zaglądać w te stare śmieci więc zlecają mi. Dostaję od razu informację, że (powiedzmy) Kuba R. już ten kod kiedyś analizował, więc z pytaniami to do niego.
Dodam jeszcze, że w firmie jest taki zwyczaj, że jak się poprawia cudzy kod, to należy przy komentarzu dopisać swoje inicjały, żeby jakby co, to wiadomo było do kogo się zwrócić.

Chodzi o narzędzia edytorskie do Worda, więc aplikacja w VBA jest wieloszablonowa, latam se po tych szablonach pod debugerem, skaczę od funkcji do funkcji, obserwuję uważnie ale zakumać nie mogę. Wygląda na to, że całość sterowania tym co się dzieje wewnątrz RÓŻNYCH funkcji odbywa się na podstawie zawartości tajemniczej zmiennej z. Tak, nazywa się ona z. Do funkcji w której wykryłam błąd jest ona przekazywana jako parametr, więc wyszukuję wywołania tej funkcji. Tu to samo, więc krok powtarzam. Tu już nie jest przekazywana jako parametr i nie jest zadeklarowana wewnątrz funkcji, więc jazda prawym klikiem -> Definition i mym oczom ukazuje się taki o to kod:

Public z         'KUUURRRWAAAAA!!!!!!!       - K.R.

zwątpiłam...

rozsadek napisał(a)

@winerfresh: bez przesady, widziałem kupę głupszych kodów, a czepianie się kodu gimnazjalisty to trochę przesada - ma pisać jak ktoś z 10. letnim doświadczeniem?

Ale chociaż podstawy pętli wypada znać. A z resztą sam niedawno brałem w tym udział i jakoś takie spaghetti mi nie przechodziło nawet przez głowę.

rozsadek napisał(a)

@winerfresh: bez przesady, widziałem kupę głupszych kodów, a czepianie się kodu gimnazjalisty to trochę przesada - ma pisać jak ktoś z 10. letnim doświadczeniem?

Prawdziwe WTF polega na tym, że brakuje #include<string> dla getline().