Programistyczne WTF jakie Was spotkały

2
not logged napisał(a):

Podczas próby kupienia biletu na pociąg pojawia się error

podczas kupowania biletu w biletomacie KŚ do lub z częstochowy na stronie potwierdzenia zamiast "częstochowa" widnieje "undefined"
Bilet drukuje się poprawnie

1

Cuda OS X-a (open dialog malejące sortowanie po dacie).
OsxOpenDialogBug.png
Zwróćcie uwagę jeszcze na scroll bara to jest koniec listy.

5

Tymczasem, gdzies na produkcji...

  class CanBuild21[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21](m1: M[A1 ~ A2 ~ A3 ~ A4 ~ A5 ~ A6 ~ A7 ~ A8 ~ A9 ~ A10 ~ A11 ~ A12 ~ A13 ~ A14 ~ A15 ~ A16 ~ A17 ~ A18 ~ A19 ~ A20], m2: M[A21]) {
    def ~[A22](m3: M[A22]) = new CanBuild22[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22](canBuild(m1, m2), m3)

    def and[A22](m3: M[A22]) = this.~(m3)

    def apply[B](f: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) => B)(implicit fu: Functor[M]): M[B] =
      fu.fmap[A1 ~ A2 ~ A3 ~ A4 ~ A5 ~ A6 ~ A7 ~ A8 ~ A9 ~ A10 ~ A11 ~ A12 ~ A13 ~ A14 ~ A15 ~ A16 ~ A17 ~ A18 ~ A19 ~ A20 ~ A21, B](canBuild(m1, m2), { case a1 ~ a2 ~ a3 ~ a4 ~ a5 ~ a6 ~ a7 ~ a8 ~ a9 ~ a10 ~ a11 ~ a12 ~ a13 ~ a14 ~ a15 ~ a16 ~ a17 ~ a18 ~ a19 ~ a20 ~ a21 => f(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21) })

    def apply[B](f: B => (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21))(implicit fu: ContravariantFunctor[M]): M[B] =
      fu.contramap(canBuild(m1, m2), (b: B) => { val (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21) = f(b); new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(a1, a2), a3), a4), a5), a6), a7), a8), a9), a10), a11), a12), a13), a14), a15), a16), a17), a18), a19), a20), a21) })

    def apply[B](f1: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) => B, f2: B => (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21))(implicit fu: InvariantFunctor[M]): M[B] =
      fu.inmap[A1 ~ A2 ~ A3 ~ A4 ~ A5 ~ A6 ~ A7 ~ A8 ~ A9 ~ A10 ~ A11 ~ A12 ~ A13 ~ A14 ~ A15 ~ A16 ~ A17 ~ A18 ~ A19 ~ A20 ~ A21, B](
        canBuild(m1, m2), { case a1 ~ a2 ~ a3 ~ a4 ~ a5 ~ a6 ~ a7 ~ a8 ~ a9 ~ a10 ~ a11 ~ a12 ~ a13 ~ a14 ~ a15 ~ a16 ~ a17 ~ a18 ~ a19 ~ a20 ~ a21 => f1(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21) },
        (b: B) => { val (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21) = f2(b); new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(a1, a2), a3), a4), a5), a6), a7), a8), a9), a10), a11), a12), a13), a14), a15), a16), a17), a18), a19), a20), a21) }
      )

    def join[A >: A1](implicit witness1: <:<[A, A1], witness2: <:<[A, A2], witness3: <:<[A, A3], witness4: <:<[A, A4], witness5: <:<[A, A5], witness6: <:<[A, A6], witness7: <:<[A, A7], witness8: <:<[A, A8], witness9: <:<[A, A9], witness10: <:<[A, A10], witness11: <:<[A, A11], witness12: <:<[A, A12], witness13: <:<[A, A13], witness14: <:<[A, A14], witness15: <:<[A, A15], witness16: <:<[A, A16], witness17: <:<[A, A17], witness18: <:<[A, A18], witness19: <:<[A, A19], witness20: <:<[A, A20], witness21: <:<[A, A21], fu: ContravariantFunctor[M]): M[A] =
      apply[A]((a: A) => (a: A1, a: A2, a: A3, a: A4, a: A5, a: A6, a: A7, a: A8, a: A9, a: A10, a: A11, a: A12, a: A13, a: A14, a: A15, a: A16, a: A17, a: A18, a: A19, a: A20, a: A21))(fu)

    def reduce[A >: A1, B](implicit witness1: <:<[A1, A], witness2: <:<[A2, A], witness3: <:<[A3, A], witness4: <:<[A4, A], witness5: <:<[A5, A], witness6: <:<[A6, A], witness7: <:<[A7, A], witness8: <:<[A8, A], witness9: <:<[A9, A], witness10: <:<[A10, A], witness11: <:<[A11, A], witness12: <:<[A12, A], witness13: <:<[A13, A], witness14: <:<[A14, A], witness15: <:<[A15, A], witness16: <:<[A16, A], witness17: <:<[A17, A], witness18: <:<[A18, A], witness19: <:<[A19, A], witness20: <:<[A20, A], witness21: <:<[A21, A], fu: Functor[M], reducer: Reducer[A, B]): M[B] =
      apply[B]((a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6, a7: A7, a8: A8, a9: A9, a10: A10, a11: A11, a12: A12, a13: A13, a14: A14, a15: A15, a16: A16, a17: A17, a18: A18, a19: A19, a20: A20, a21: A21) => reducer.append(reducer.append(reducer.append(reducer.append(reducer.append(reducer.append(reducer.append(reducer.append(reducer.append(reducer.append(reducer.append(reducer.append(reducer.append(reducer.append(reducer.append(reducer.append(reducer.append(reducer.append(reducer.append(reducer.append(reducer.unit(a1: A), a2: A), a3: A), a4: A), a5: A), a6: A), a7: A), a8: A), a9: A), a10: A), a11: A), a12: A), a13: A), a14: A), a15: A), a16: A), a17: A), a18: A), a19: A), a20: A), a21: A))(fu)

    def tupled(implicit v: VariantExtractor[M]): M[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21)] =
      v match {
        case FunctorExtractor(fu) => apply { (a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6, a7: A7, a8: A8, a9: A9, a10: A10, a11: A11, a12: A12, a13: A13, a14: A14, a15: A15, a16: A16, a17: A17, a18: A18, a19: A19, a20: A20, a21: A21) => (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21) }(fu)
        case ContravariantFunctorExtractor(fu) => apply[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21)] { (a: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21)) => (a._1, a._2, a._3, a._4, a._5, a._6, a._7, a._8, a._9, a._10, a._11, a._12, a._13, a._14, a._15, a._16, a._17, a._18, a._19, a._20, a._21) }(fu)
        case InvariantFunctorExtractor(fu) => apply[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21)]({ (a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6, a7: A7, a8: A8, a9: A9, a10: A10, a11: A11, a12: A12, a13: A13, a14: A14, a15: A15, a16: A16, a17: A17, a18: A18, a19: A19, a20: A20, a21: A21) => (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21) }, { (a: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21)) => (a._1, a._2, a._3, a._4, a._5, a._6, a._7, a._8, a._9, a._10, a._11, a._12, a._13, a._14, a._15, a._16, a._17, a._18, a._19, a._20, a._21) })(fu)
      }

  }

  class CanBuild22[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22](m1: M[A1 ~ A2 ~ A3 ~ A4 ~ A5 ~ A6 ~ A7 ~ A8 ~ A9 ~ A10 ~ A11 ~ A12 ~ A13 ~ A14 ~ A15 ~ A16 ~ A17 ~ A18 ~ A19 ~ A20 ~ A21], m2: M[A22]) {
  }

}
1

przed chwilą popełniłem coś takiego

vector<pair<const wchar_t*,vector<pair<unsigned,const wchar_t*>>>>
0

Unity...

Byl kod ktory wykonywal sie 25tys razy (petla for). 25k razy porownywal stringi + dodawal odpowiednie rzeczy do Animacji (tak zwane klucze).
Czas wykonania 0.25s
Zostal zmieniony algorytm na mniej wiecej cos takiego (wykonywal sie jedynie 500 razy)

double[] values = new double[mTargetTransformations.Count];
Array.Clear(values, 0, values.Length);
HashSet<int> used = new HashSet<int>();

for (int mappingIdx = 0; mappingIdx < mAnimation.retargeting.get_number_of_blendshape_mappings(); mappingIdx++)
{
    string mappingSource = mAnimation.retargeting.get_blendshape_mapping_source(mappingIdx);
    string mappingTarget = mAnimation.retargeting.get_blendshape_mapping_destination(mappingIdx);

    int targetIdx;
    if (mBlendIndexLookup.TryGetValue(mappingTarget, out targetIdx))
    {
        int sourceIdx = mAnimation.clip.rig().shape_index(mappingSource);
        if (sourceIdx >= 0)
        {
            double mappingWeight = mAnimation.retargeting.get_blendshape_mapping_weight(mappingIdx);
            values[targetIdx] += mAnimation.clip[stateIdx].blendshape_coefficient(sourceIdx) * mappingWeight;
            used.Add(targetIdx);
        }
        else
        {
            Debug.Log("Could not find source blend shape '" + mappingSource + "'");
        }
    }
}

foreach (int i in used)
{
    if (curves[i] == null) curves[i] = new AnimationCurve();
    curves[i].AddKey(time, (float)values[i] * mBlendShapeWeightGlobalScale);
}

czas wykonywania 0.30 sec. WTF jakim cudem?
Zakomentowanie linijki addKey... 0.19 sec
Czyli addKey wykonuje sie 0.1sec...
Nigdy nie zgadniecie co pomoglo... przeniesienie tego foreacha (tych dwoch linijek) do tego ifa

if (sourceIdx >= 0)

czas wykonywania 0.19 sec

zeszlismy jeszcze do 0.05s wiec nie tak zle zakladajac ze unity robi dziwne optymalizacje ...

0

Podsumowanie dnia z poprawianiem kodu... Mamy sobie raport w TeamCity, który wypluwa nam listę testów oznaczonych @Ignore. Zazwyczaj są to rzeczy, które mają ADHD i nie wiadomo dlaczego. Zastanowił mnie jednak jeden z testów na tej liście. Otóż nazwyał się jak się nazywał, ale nazwa kończyła się na UnitTest. rzadko spotykana konwencja. Zazwyczaj wyróżnia się testy integracyjne czy seleniowe, a unity to po prostu Test. Wchodze do środka, a tam na dzień dobry 100 linii javadoca z dokładnym opisem co też ten nasz UnitTest robi.

Po czym okazuje się, że test jednostkowy:

  • podnosi kontekst springa w wersj full-wypas (20 plików jakieś 80% aplikacji)
  • przygotowuje pełną testową bazę danych
  • wywołuje raptem dwie metody na krzyż z testowanego obiektu i w dodatku bez uwzględnienia warunków brzegowych.

Myślę sobie, że pewno jakiś hindus się rozpędził, zostawił nazwę i polecial dalej... SVN log, a tam... pewien gość z londynu, anglik od 40 pokoleń co najmniej...

Wniosek - robienie geolokacji kodu na bazie jakości nie daje 100% gwarancji poprawnego wyniku... hej!

0

http://msdn.microsoft.com/en-[...]le.epsilon%28v=vs.110%29.aspx
WTF zawsze mi się wydawało, że epsilon powinien mieć taką praktyczną definicję "Difference between 1 and the least value greater than 1 that is representable." taki jest powszechny standard definicji EPSILON a MS zafundował taką niespodziankę.
Nie widzę zastosowania Epsilon podanego przez MS, a co gorsza nie ma stałej, która pasowała by do normalnej definicji Epsilon.

C# http://ideone.com/u4yaiC
C++ http://ideone.com/kEwmMQ
Python http://ideone.com/2cZ1u8

2

Pobije ktoś to, co znalazłem w kodzie od podwykonawcy z Dalekiego Wschodu?

user image

0

Wczoraj widziałem metodę na 1200 linijek kodu. Strukturę też miała ciekawą: zagnieżdżone ify, elsy case-y.
Po tolkienowskiemu można by to ująć, że ten kod jest tak stary że kości ludzi którzy go pisali już dawno zamieniły się w proch.

0

Spotkane w kodzie źródłowym pewnej biblioteki - skróciłem, bo piszę z pamięci.

public long jakasFunkcja(int ax, int bx, int cx, [...], int xx, int yx, int zx) {
if (ax < 0 || bx < 0 || cx < 0 || [...] || yx < 0 || zx < 0) {
 return -1;
}
else {
 for (int ay = 0; ay < ax; ay++) {
  for (int by = 0; by < bx; by++) {
    [...]
     for (int zy = 0; zy < zx; zy++) {
      return ay - by + cy - dy + [...];
     }
  }
 }
}
}

Nie mam najmniejszego pojęcia, czemu miałby służyć ten kod ani komu by się on przydał.

EDIT:
Znalazłem "rewelacyjne" zastosowanie tej funkcji: jeśli dowolny z argumentów jest mniejszy od zera, zwraca -1, w przeciwnym wypadku zwraca... zero.

1 użytkowników online, w tym zalogowanych: 0, gości: 0, botów: 1

Robot: Bingbot