title: Odziedziczyłem 200 000 linijek kodu spaghetti - co teraz?

text: Mam nadzieję, że nie jest to zbyt ogólne pytanie; Naprawdę przydałaby mi się wytrawna porada. Zostałem niedawno zatrudniony jako jedyny "inżynier SW" w dość małym sklepie naukowców, którzy spędzili ostatnie 10-20 lat na szyciu ogromnej bazy kodu. (Był napisany w praktycznie przestarzałym języku: _G2_ \-- pomyśl o Pascalu z grafiką). Sam program jest fizycznym modelem złożonego zakładu przetwórstwa chemicznego; zespół, który go napisał, ma niesamowicie głęboką wiedzę domenową, ale niewiele lub wcale nie ma formalnego szkolenia z podstaw programowania. Niedawno nauczyli się trudnych lekcji na temat konsekwencji nieistniejącego zarządzania konfiguracją. Ich wysiłki konserwacyjne są również znacznie utrudnione przez ogromne nagromadzenie nieudokumentowanego „szlamu” w samym kodzie. Oszczędzę wam „polityki” sytuacji (zawsze jest polityka!), ale wystarczy powiedzieć, że nie ma zgody co do tego, co jest potrzebne na drodze przed nami. Poprosili mnie, abym zaczął przedstawiać zespołowi niektóre zasady współczesnego tworzenia oprogramowania. Chcą, abym przedstawił niektóre ze standardów branżowych i strategii dotyczących konwencji kodowania, zarządzania cyklem życia, wzorców projektowych wysokiego poziomu i kontroli źródła. Szczerze mówiąc, to dość trudne zadanie i nie wiem, od czego zacząć. Początkowo jestem skłonny uczyć ich niektórych głównych koncepcji _Pragmatic Programmer_ lub _Refactoring_ Fowlera ("Code Smells" itp.). Mam również nadzieję, że wprowadzę kilka metodologii Agile. Ale ostatecznie, aby być skutecznym, myślę, że będę musiał doskonalić 5-7 podstawowych podstaw; innymi słowy, jakie są najważniejsze zasady lub praktyki, które mogą realistycznie zacząć wdrażać, a które dadzą im najwięcej „huku za grosze”. Oto moje pytanie: Co _ty_ zawarłbyś na swojej liście najskuteczniejszych strategii, aby pomóc w prostowaniu spaghetti (i zapobieganiu mu w przyszłości)?


title: Reengineering projektu od podstaw

text: > **Możliwy duplikat:** > Kiedy przebudowujesz aplikację lub naprawiasz istniejącą, obecnie pracuję nad projektem, który był rozwijany przez ostatnie kilka lat i używanym w całej organizacji, ale sposób, w jaki projekt został zakodowana jego konserwacja jest całkowicie zastrzelona. Odczytywanie kodu przedstawia strony i strony Anti-Patterns i próba zidentyfikowania ścieżki biznesowego przepływu pracy trwa czasami kilka dni. W tym momencie prawdopodobnie zaklasyfikowałbym oprogramowanie w jego obecnym stanie jako „Działa przez przypadek”, a nie zgodnie z przeznaczeniem. Więc szukam trochę mądrości w następujących kwestiach: W którym momencie rozważyłbyś po prostu zrzucenie projektu na stos porzuconych programów i rozpoczęcie od zera? PS Rozumiem, że w wielu przypadkach organizacja uznałaby za tańsze utrzymanie istniejącego projektu.


title: Skąd wiesz, czy napisałeś czytelny i łatwy w utrzymaniu kod?

text: Skąd można wiedzieć, czy stworzony przez niego kod jest łatwy w utrzymaniu i czytelny? Oczywiście z twojego punktu widzenia (tego, który faktycznie napisał kod) twój kod jest czytelny i łatwy w utrzymaniu, ale powinniśmy być tutaj wierni sobie. Skąd mielibyśmy wiedzieć, czy napisaliśmy dość niechlujny i niemożliwy do utrzymania kod? Czy istnieją jakieś konstrukcje lub wytyczne, o których należy wiedzieć, jeśli opracowaliśmy niechlujny kawałek oprogramowania?


title: Samoocena: Skąd mam wiedzieć, czy rzeczywiście „dobrze rozumiem” OOP?

text: Jeśli pominę poprzednią historię i jakiekolwiek myśli, które mam na ten temat, tak naprawdę pozostaje tylko jedno pytanie do zadania: **Jak mogę dowiedzieć się, czy mam "dobre zrozumienie" OOP?** (konkretnie używam PHP , ale to prawdopodobnie nie będzie miało znaczenia...) W tej chwili myślę o klasach jako o zbiorze funkcji z pewnymi zmiennymi globalnymi dostępnymi dla wszystkich tych funkcji. Pomaga to ponownie wykorzystać kod, zachować krótkie pliki i czystą przestrzeń nazw. Niektórzy z was wspomnieli o dziedziczeniu: dla mnie to znowu oznacza, że mogę rozszerzyć istniejącą klasę o więcej funkcji i więcej zmiennych globalnych. To jak dodatek do mojej istniejącej klasy. I przychodzą te same korzyści: ponowne wykorzystanie kodu, krótkie pliki. Mam złowieszcze uczucie, że za chwilę będę tu rozczarowany...


title: Jak wytłumaczyć osobie nietechnicznej, dlaczego zadanie potrwa znacznie dłużej niż myśli?

text: Prawie każdy programista musi odpowiedzieć na pytania ze strony biznesowej, takie jak: Dlaczego dodanie tego prostego formularza kontaktowego zajmie 2 dni? Kiedy programista oszacuje to zadanie, może podzielić je na kroki: * wprowadzić pewne zmiany w bazie danych * zoptymalizować zmiany bazy danych pod kątem szybkości * dodać frontendowy HTML * napisać kod po stronie serwera * dodać walidację * dodać javascript po stronie klienta * użyć testów jednostkowych * upewnij się, że ustawienia SEO działają * zaimplementuj potwierdzenie e-mail * refaktoryzuj i zoptymalizuj kod pod kątem szybkości * ... To może być trudne do wytłumaczenia osobie nietechnicznej, która zasadniczo postrzega całe zadanie jako po prostu złożenie kodu HTML i stworzenie tabela do przechowywania danych. Dla nich może to być 2 godziny MAX. Czy istnieje lepszy sposób na wyjaśnienie, dlaczego szacunek jest wysoki dla osoby niebędącej deweloperem?


title: Jak edukować menedżerów biznesowych w zakresie złożoności dodawania nowych funkcji?

text: Utrzymujemy aplikację webową dla klienta, który wymaga dodawania nowych funkcji w zawrotnym tempie. Zrobiliśmy co w naszej mocy, aby nadążyć za ich wymaganiami, w wyniku czego baza kodu wzrosła wykładniczo. Obecnie jest tak wiele modułów, podsystemów, kontrolerów, bibliotek klas, testów jednostkowych, interfejsów API itp., że za każdym razem, gdy dodajemy nową funkcję, zaczyna zabierać więcej czasu. Musieliśmy również wciągnąć do projektu dodatkowe osoby, które przejmą takie rzeczy, jak kontrola jakości i przygotowanie, aby główni programiści mogli skupić się na rozwoju. Niestety, klient denerwuje się, że koszt każdej nowej funkcji rośnie. Wydaje się, że spodziewają się, że będziemy mogli dodawać nowe funkcje _ad infinitum_, a koszt każdej funkcji pozostanie liniowy. Wielokrotnie próbowałem im tłumaczyć, że to nie działa w ten sposób – że baza kodu rozszerza się fraktalnie w miarę dodawania tych wszystkich funkcji. Wyjaśniłem, że najlepszym sposobem na obniżenie kosztów jest rozważenie, które nowe funkcje są naprawdę potrzebne. Ale albo nie rozumieją, albo myślą, że ich spuszczam. Po prostu przewracają oczami i wpadają w złość. Wszyscy są całkowicie nietechniczni i nie mają pojęcia, co robi z pisaniem oprogramowania. Czy mogę to wyjaśnić językiem biznesowym, który pomoże im lepiej zrozumieć? Czy są jakieś wizualizacje, które ilustrują wzrost bazy kodu w czasie? Jakieś inne sugestie dotyczące postępowania z tym klientem?


title: Jakie jest najskuteczniejsze podejście do nauki nieznanego złożonego programu?

text: > **Możliwy duplikat:** > Jak zagłębić się w duże bazy kodu? Mam spore doświadczenie z różnymi językami programowania i pisaniem małych i funkcjonalnych programów do różnych celów. Moje umiejętności kodowania nie są tym, z czym mam problem. W rzeczywistości napisałem od podstaw przyzwoitą aplikację internetową dla mojego startupu. Mam jednak problem z przeskakiwaniem do nieznanych aplikacji. Jaki jest najskuteczniejszy sposób podejścia do nauki struktury i/lub architektury nowego programu, aby móc efektywnie atakować kod? Czy istnieją przydatne narzędzia dla ich odpowiednich języków (Python i Java to moje dwa podstawowe języki)? Czy powinienem zacząć od przeglądania nazw funkcji lub dokumentacji? Jak wy weterani podchodzicie do tego problemu? Uważam, że musi to odbywać się przy minimalnej pomocy współpracowników lub współpracowników, którzy są już zaznajomieni z aplikacją i mają lepsze rzeczy do roboty niż pomaganie mi. Bardzo chciałbym ćwiczyć tę umiejętność w projekcie open source, więc wszelkie sugestie dotyczące punktów początkowych (może lekko złożone) również byłyby świetne!


title: Wkład w oprogramowanie open source (jak hakować)

text: > **Możliwy duplikat:** > Jak zagłębić się w duże bazy kodu? Obecnie jestem studentem i kilka lat temu zacząłem programować. Potrafię napisać kompletne działające oprogramowanie w wielu językach. Jednak jest coś, co mnie niepokoi w przyczynianiu się do projektów open source: jak rozumiesz, w jaki sposób organizacja ustrukturyzowała swój kod źródłowy? Próbowałem dodać funkcjonalność do Apache Tomcat i miałem trudności z odnalezieniem się we wszystkich tych plikach źródłowych. Czy brakuje mi czegoś, co ułatwia zrozumienie organizacji wykonywanej pracy?


title: Jakie jest najlepsze podejście do badania projektów Open Source lub dowolnej dużej bazy kodu?

text: Istnieje projekt Open Source, którego muszę użyć w moim projekcie. Wszystkie inne funkcje są na nim zbudowane. Jestem nowy w programowaniu i uważam to za bardzo trudne. Istnieje wiele projektów i interfejsów API Open Source. W pewnym momencie musimy użyć ich w naszych projektach, ponieważ nie chcemy wymyślać tego ponownie. Istnieje mnóstwo linii kodu napisanych w tych projektach Open Source przez innych programistów. Naprawdę trudno to zrozumieć. Jak wybrać bibliotekę lub API i szybko je zrozumieć, aby użyć ich w moim projekcie? Czy muszę rozumieć każdy wiersz kodu, czy po prostu mieć ogólny przegląd tego, jak to działa? Podziel się swoimi doświadczeniami z tego, jak do tego podchodzisz i wszelkimi wskazówkami, jak na to patrzeć.


title: Rozwijanie tempa w projektach open source

text: Walczyłem o rozwój, przyczyniając się do projektów open source. W przeszłości próbowałem z gcc i wniosłem poprawkę do libstdc++, ale było to jednorazowe i mimo że spędziłem miesiące w wolnym czasie na liście dyskusyjnej programistów i czytaniu rzeczy, po prostu nigdy nie nabrałem rozpędu z kodem . W końcu zrezygnowałem z subskrypcji, odzyskałem swój wolny czas i odświeżyłem swoją skrzynkę pocztową. Jak wielu ludzi, mam kilka nieistniejących projektów open source w sieci, ale nie są one duże i jestem jedynym współtwórcą. W tej chwili jestem bardziej zainteresowany współpracą w dużym projekcie open source i chcę wiedzieć, jak ludzie zaczęli, ponieważ ciężko mi pracować na pełny etat, aby rozwinąć jakikolwiek impet z bazą kodu. Inni, bardziej regularni współpracownicy, którzy pracują nad projektem w pełnym wymiarze godzin, są w stanie dowolnie wprowadzać zmiany i w rezultacie wejść w cykl pozytywnych opinii, w którym rozumieją kod i wiedzą, dokąd on zmierza. To sprawia, że bariera wejścia jest wyższa dla tych, którzy pojawią się później. Moje pytania kieruję do ludzi, którzy aktywnie uczestniczą w dużych projektach opensource, takich jak jądro Linuksa, gcc, clang/llvm lub cokolwiek innego, w których liczba programistów przekracza 10 osób. * Jak zacząłeś? Czy w twoim życiu był duży kawał czasu, który mógłbyś poświęcić na pracę nad projektem? Wiem, że w przypadku Linusa miał trochę czasu (6 miesięcy), aby zacząć. * Jakie bariery wejścia napotkałeś? * Czy możesz opisać początkowe etapy czasu spędzonego z projektem, od kiedy słabo rozumiałeś kod, do momentu, gdy rozumiałeś wystarczająco, aby regularnie zatwierdzać. Dziękuję


title: Przekonywanie kierownictwa, że refaktoryzacja kodu to dobry pomysł

text: > **Possible Duplicate:** > Najlepszy argument na poparcie refaktoryzacji Czy ktoś ma jakieś wskazówki, jak przekonać kierownictwo, że refaktoryzacja kodu to dobry pomysł? Zapytano mnie coś w stylu > "Czy po tej refaktoryzacji będę miał lepszy produkt? Jak czas poświęcony > na ten zysk dla firmy?" Albo coś w tym stylu. Rozumiem, dlaczego kierownictwo o to poprosiło, ale moja odpowiedź nie była fantastyczna. Powiedziałem coś o tym, jak dobrze zaprojektowane oprogramowanie sprawi, że dodawanie nowych funkcji w przyszłości będzie szybsze i łatwiejsze. Czy ktoś jeszcze ma jakieś wskazówki? Wielkie dzięki.


title: Jak obsłużyć klienta, który chce, abym używał kodu od Google w każdych okolicznościach?

text: Mam klienta, który był zdenerwowany faktem, że ukończenie funkcji / błędu w aplikacji internetowej zajmuje więcej czasu niż myśli. Jest bardziej kierownikiem projektu, który zatrudnił mnie jako podwykonawcę. Ciągle kwestionuje szacunki, które mu podałam, i zawsze stara się, abym zgodził się zrobić coś w krótszym czasie, niż szacowałem. Wyjaśniłem mu, że nie zawsze wystawiam rachunek za pełne oszacowanie, jeśli w rzeczywistości nie zajmie mi to dużo czasu. Powiedział mi też, że jeśli jest kod w google (w3schools), to powinienem go użyć, a nie sam go pisać. Prowadzę interesy z tą osobą od 12 miesięcy. Aby wyjaśnić, co mam na myśli przez „Google”, mam na myśli, że zawsze wolałby, abym kopiował / wklejał kod, który znalazłem w Google, niż sam pisać kod.


title: Jak zanurkować w wielką kulę błota?

text: > **Możliwy duplikat:** > Jak zagłębić się w duże bazy kodu? Pojawia się więc pytanie o zrozumienie kodu. Mój jest podobnym problemem. Zaczęło się, gdy dołączyłem do mojej obecnej organizacji. i jak zawsze na początku starałem się wyczuć kod, zaczynając od góry i schodząc do szczegółów. Tylko, że nie ma żadnych szczegółów, a mówiąc dokładniej, nie udało mi się doszukać w tej wielkiej kuli błota żadnego wzoru. Aplikacja jest pełna duplikatów/niepotrzebnych danych, nie ma próby enkapsulacji, abstrakcji lub hierarchii z tym samym kodem skopiowanym w wielu klasach/modułach dla tej samej funkcjonalności (oczywiście oznacza to, że zduplikowany kod jest wszędzie rozsynchronizowany). Większość kodu dotyczy manipulacji klasami w stylu POD całkowicie zasłaniając logikę biznesową pomiędzy nimi, DAO są strasznie zmutowane. Programowanie OO, przepraszam, niech to będzie jakiekolwiek programowanie, czym Freddy był/jest dla nastolatków z ulicy Wiązów. Teraz chciałbym stopniowo refaktoryzować to szaleństwo, ale do tego muszę jakoś złapać kod. Więc moje pytanie brzmi, czy ktoś zna jakieś systematyczne podejście do tej sytuacji, czy też muszę hakować, dopóki nie wykonam pracy. Aktualizacja: Wystarczy dodać kilka dodatkowych informacji. 1. Nasz zespół jest nowy, więc nie możemy rozmawiać z nikim, kto jest znajomy. 2. Przeniosłem się na nową domenę, w wyniku czego nie jestem z nią zaznajomiony. 3. Nie mamy bezpośredniej interakcji z klientem.


title: Inżynieria lepszego rozwiązania, pochodzącego z istniejącej bazy kodu

text: **Kod** Posiadam oprogramowanie o wysokiej wartości biznesowej, używane codziennie przez klientów, napisane w PHP i obejmujące około 600 000 linijek kodu. Klient od dawna potrzebuje, chce i domaga się nowych funkcji i funkcjonalności. Czas to zrobić _wczoraj_. Więc po prostu napisz nowe funkcje i zaimplementuj nową funkcjonalność i dostarcz ją klientowi, tak? Cóż, nie, oto kilka problemów, które przysporzyły znacznego bólu obecnym programistom: **Istniejąca baza kodu to... wielka kula błota.** Istotne problemy: * kod jest włochaty - jedna funkcja przenika wszystko, śledząc kod jest uciążliwy, a dodanie funkcji może potencjalnie wpłynąć na wszystko inne * nie ma testów * mieszanka kodu proceduralnego i obiektowego wykorzystywanego w złych praktykach programistycznych * pliki sięgające 6000 wierszy HTML, CSS, PHP, SQL, jQuery, JavaScript , komentarze * całkowite zignorowanie/nieistnienie wzorca MVC/separacji obaw. Kod jest przemieszany ze sobą * pewna logika biznesowa zależy od zmiennych, które nie mają związku z kodem (takich jak metadane bazy danych) * wartości zakodowane na sztywno, ścieżki i brak możliwości konfiguracji przyczyniają się do braku bezpieczeństwa obecnej architektury * duże powtarzające się bloki zasadniczo takich samych kod przyczynia się do tego, że podobne funkcje działają nieco inaczej. Aktualizacja jednego nie aktualizuje drugiego * kod jest powolny, brak dokumentacji., itp., itp. wiele innych rzeczy można zrobić lepiej **Działa...** Dobrze, że działa... Funkcjonalność, która tam jest, jest rozsądnie opracowana dla rzeczywistych przypadków biznesowych, ale… pójście dalej jest bolesne. **Problem** Łatwiej teraz (i szybciej) dodać nową funkcję przy użyciu istniejącego stylu kodu, głównie przy użyciu podejścia wytnij-n-wklej-n-modyfikuj, utrwalając w ten sposób zło, niż przepisać to rzecz z wykorzystaniem obecnie istniejących nowoczesnych najlepszych praktyk. **Rozwiązanie?** Mówi się o przepisaniu całości przy użyciu jednego z wiodących obecnie frameworków (np. ZF2), ale w ten sposób oznacza to ignorowanie wymagań klientów, zabieranie dużo czasu na zbudowanie oprogramowania, a w zasadzie tworzenie nowe oprogramowanie (wersja 0.0.1) dla klienta, ze wszystkimi błędami nowego oprogramowania i brakiem funkcjonalności i funkcjonalności oprogramowania dojrzałego. Inną myślą jest stopniowy rozwój. tj. Gdy pojawi się nowa funkcja, napisz ją, stosując nowe podejście. Obecnie to się nie udaje z powodu podanego w tytule „Problem” powyżej. Jeszcze innym pomysłem jest powolna refaktoryzacja istniejącej bazy kodu... Może to zadziałać przy czyszczeniu takich rzeczy, jak MVC i wiele innych rzeczy, i zajmie to dużo czasu, a zasadniczo będzie przypominać ciasne rozplątanie bałaganu -zwinięty kłębek przędzy. Ale zrobienie tego nie rozwiąże takich rzeczy, jak testowanie jednostkowe, wstrzykiwanie zależności, nowoczesne zasady ramowe i tak dalej. W końcu nadchodzą nowe funkcje, dodawany jest kod, a istniejąca baza kodu nie staje się lepsza. Co możesz zaproponować w takim przypadku?


title: Co zrobić, gdy masz do czynienia z nieznaną bazą kodu?

text: > **Możliwy duplikat:** > Jak zagłębić się w duże bazy kodu? Kiedy dołączasz do istniejącego wcześniej projektu, który ma dużą bazę kodu, co robisz, aby szybko zaaklimatyzować się i móc w nim porządnie kodować? Ile czasu spędzasz na czytaniu, robieniu diagramów itp. zamiast na nurkowaniu i kodowaniu?


title: Jak mam się uczyć bardzo dużej i złożonej aplikacji?

text: Będąc młodym i dość niedoświadczonym programistą zatrudnionym niedawno przez „prawdziwą” firmę programistyczną, chciałbym uzyskać kilka opinii i wskazówek, jak wykonać następujące czynności: ** Podejścia do zapoznania się z produktami firmy , zwłaszcza gdy nie masz pomysł, jak to wszystko działa**. Firma, w której pracuję, ma jeden OGROMNY produkt, nieustannie się rozwija i będąc tu od 2 tygodni, nadal nie mam pojęcia, jak to wszystko się skleja, poza specjalnym rodzajem kleju zrobionego ze łez i frustracji młodych programistów, to jest niesamowicie rozdrobniona i tylko 4 osoby w biurze znają wewnętrzne funkcjonowanie, wszystkie są stale zajęte **Daj pożyteczny wkład w produkt :** Teraz wiem, że jestem tylko dzieckiem w firmie i nie można się mnie spodziewać w pierwszych miesiącach dostarczać coś przełomowego, ale musisz dawać tyle, ile zapłaciłeś. Dostaję dwa razy więcej niż w mojej poprzedniej pracy, ale obiektywnie rzecz biorąc, nie zrobiłem jeszcze nic, by na to zasłużyć. Po prostu siedziałem i gapiłem się na ekran laptopa, próbując rozszyfrować kod. Teraz możesz powiedzieć, że po to tu jestem, przynajmniej na początek, ale w mojej poprzedniej pracy byłem kimś w rodzaju go-to-faceta, podejmując decyzje i przyczyniając się do prawie każdego aspektu codziennej pracy firmy . Chociaż było to dużo pracy, cieszyłem się uczuciem bycia „połączonym” w wewnętrznym funkcjonowaniu firmy, w której mam udział (symbiotyczny związek, jeśli wolisz). _proszę skrócić ten punkt, decydowanie pozostawię wam, co jest ważne_ _Będę publikować więcej rzeczy, jak o nich myślę, muszę wrócić do czytania i pisania czegoś tylko trochę przypominającego C#_


title: Jakiego procesu powinienem użyć, aby nauczyć się dużego systemu?

text: > **Możliwy duplikat:** > Jak zagłębić się w duże bazy kodu? Właśnie dołączyłem do nowej firmy i zacząłem studiować jeden z ich większych systemów. Aby być produktywnym, muszę zrozumieć cały system bez zbytniej pomocy. Inni programiści są bardzo zajęci i nie mają czasu trzymać mnie za ręce. Kiedyś używałem mapy mózgu, aby narysować obrazową reprezentację systemu. Jakieś zalecenia dotyczące właściwego podejścia do analizy dużego programu? Nawiasem mówiąc, jest to prgoram .net.


title: Jak oszacować długość zadania programistycznego?

text: Jakiego procesu używasz, aby oszacować, jak długo zajmie (znaczące) zadanie programistyczne. Czy używasz jednego lub więcej z poniższych: * intuicja/zgadywanie * odniesienie do podobnych zadań, których szacunkowa/rzeczywista długość zarejestrowałeś * odniesienie do długości podobnych zadań, które zarejestrowali inni twój menedżer)


title: Jak prawidłowo przejąć złożony projekt PHP

text: Otrzymałem zadanie poprawienia niektórych problemów na zapleczu dużego projektu strony internetowej, który od jakiegoś czasu jest zlecany na zewnątrz. Oryginalni deweloperzy i my nie są w dobrych stosunkach, więc nie można ich zaangażować. Stos technologiczny jest następujący: * MySQL 5.x * PHP 5.3 (i różne biblioteki pomocnicze) * Apache z mod_rewrite Problemy, z którymi się zmagam to: * Brak dokumentacji, nawet komentarzy * 4 pliki indeksu w katalogu głównym, plus 2 główne pliki w kombinacji php i html oraz 1 default.php, przywoływany plik indeksu w .htaccess odwołuje się do ich lokalnego serwera testowego. * Zduplikowane nazwy plików / pliki * Okropny układ systemu plików (ultiple foldery js, wiele folderów skryptów itp.) * Poleganie na oryginalnych funkcjach mysql (nie mysqli ani PDO) * wiele frameworków, JQuery, różne API marketplace itp. To było bardzo frustrujące kilka godzin próbując ustalić, od czego zacząć ten bałagan, nie mówiąc już o tym, jak naprawić rzeczy, których potrzebuję. Więc moje pytanie brzmi: jakie byłoby najlepsze miejsce do startu lub gdyby to spadło na twoje kolana, jak byś do tego podszedł? Wiem, że to subiektywne, a opinie są tym, czego szukam, więc każda porada jest mile widziana.


title: Jaka jest najlepsza metoda, aby zacząć rozumieć kod źródłowy projektu BIG?

text: > **Możliwy duplikat:** > Jak zagłębić się w duże bazy kodu? Czasami przed opracowaniem nowych produktów musimy zrozumieć niektóre istniejące produkty lub istniejący kod źródłowy. Czasami, aby napisać kolejny mały moduł tego dużego projektu, musimy zrozumieć ten duży kod źródłowy. **W naszym przypadku musimy przestudiować i zrozumieć projekt z dużą ilością plików i folderów. Jaki jest najłatwiejszy i najwygodniejszy sposób na zrobienie tego? (szczególnie dla C i C++ oraz pod Linuksem)**


title: Jak naprawić bardzo zły kod?

text: > **Możliwe duplikaty:** > Jak zagłębić się w duże bazy kodu? > Jak poradzić sobie z refaktoryzacją, która trwa dłużej niż jeden sprint? Mam 2 pliki, które obejmują 5000 linii kodu. Zostałem poproszony o naprawienie problemu. Kod jest zorientowany obiektowo, ale używa setek flag, jest wielowątkowy, używa nazw zmiennych bez znaczenia, ma problemy z rekurencją itp. Problem polega na tym, że przepisanie kodu zajmie kilka miesięcy i nie ma specyfikacji. Specyfikacje są zaszyfrowane w kodzie. Więc najważniejsze pytanie brzmi: czy masz jakieś sposoby lub techniki, aby naprawić/zrozumieć tak zły kod?


title: Jak zorganizować starszą wielostronicową aplikację internetową z mnóstwem spaghetti JavaScript?

text: Odziedziczyłem aplikację i muszę się zreorganizować i mam nadzieję, że będę w stanie zmodularyzować tony JavaScript, który jest wszędzie. Jest to **wielostronicowa aplikacja internetowa**. Każda strona ma w nagłówku tag skryptu, który obecnie zawiera **obsługę obsługi DomReady**, która inicjuje wszystkie procedury obsługi zdarzeń użytkownika dla tej konkretnej strony, a także bardzo często zawiera od **1 do 10 funkcji JavaScript, które są specyficzne** dla tej stronie (co oznacza, że nie są one przydatne nigdzie indziej w aplikacji). Następnie jest import jQuery na każdej stronie plus import czegoś takiego jak App.js, który jest po prostu **bardzo dużym zbiorem funkcji globalnych**, które są przydatne na wielu różnych stronach aplikacji. Strony aplikacji różnią się od siebie, więc wydaje się, że nie ma sensu, aby każda strona ładowała wszystko. Desperacko próbuję to wszystko uporządkować, a po zbadaniu nowoczesnych rozwiązań, takich jak RequireJS, Browserify, proste lekkie frameworki MVP, takie jak Riot.js, luźne sprzężenie poprzez wzorzec Mediator i tak dalej. Wiele z nich wydaje się atakować głównie jednostronicowe aplikacje internetowe. Trudno mi sobie wyobrazić, jak zreorganizować tę 40-stronicową aplikację, w której prawie każda strona wymaga **oddzielnej inicjalizacji, kilku specyficznych funkcji i dużej liczby ogólnych**... Można również zainstalować aplikację webową na własnym serwerze użytkownika i **zachowanie poszczególnych skryptów strony musi być konfigurowalne** poprzez nadpisanie niektórych funkcji (lub dodanie do inicjalizacji lub modułów, jeśli staną się modułami w przyszłości). Co zrobiłby ekspert JS?


title: Jeśli TDD dotyczy projektowania, po co mi go potrzebować?

text: Guru TDD coraz częściej mówią nam, że w TDD nie chodzi o testy, ale o projektowanie. Więc znam kilku programistów, którzy tworzą naprawdę świetny projekt bez TDD. Czy powinni więc ćwiczyć TDD?


title: Emocjonalne oderwanie się od złego kodu

text: Wszyscy chcielibyśmy pracować z dobrym, łatwym w utrzymaniu kodem, zgodnym z najlepszymi praktykami i wzorcami projektowymi. Jednak rzeczywistość jest daleka od ideału. W końcu treści na stronach takich jak The Daily WTF nie są wymyślone i wszyscy czasami musimy utrzymywać kod, delikatnie mówiąc, słabej jakości. Mam problem z pracą z tym kodem. Oczywiście praca ze złym kodem jest trudna z technicznego punktu widzenia, ale mam, cóż, problem emocjonalny. Kiedy muszę, powiedzmy, naprawić mały błąd w źle zaprojektowanej aplikacji, zwykle skupiam się na tym, jak zła jest ogólna aplikacja, zamiast na tym, jak naprawić prosty błąd. Myślę "jeez, jak można być tak głupim, żeby to napisać". Pracę traktuję raczej jako karę niż wyzwanie. Spowalnia moją wydajność pracy. Jak mogę zmienić swoje nastawienie, aby skupić się na zadaniu zamiast zastanawiać się, jak zła jest baza kodu, z którą mam do czynienia? W tym pytaniu zakładam, że oczywiste rozwiązanie, tj. naprawienie złego kodu nie jest możliwe/do zastosowania: działa, jest za duży, naprawienie go wymagałoby zbyt wiele wysiłku, wkrótce zostanie wycofane, zostało napisane przez twojego szefa itp. WYJAŚNIJ: Nie chcę wykorzystywać ogólnej jakości kodu, aby usprawiedliwiać dalsze jego psucie. Zakładam, że ogólna jakość kodu jest powszechnie znana, ale zdarzają się zadania o wyższym priorytecie. Rozważmy następujący przykład: print "<h1>", sql("SELECT tytuł FROM news WHERE id='$ID'"), "</h1>" Są dwa problemy: 1. Pomieszanie warstwy danych i prezentacji 2. Kod jest podatny na wstrzyknięcie SQL „#1” szkodzi łatwości konserwacji bazy kodu, ale sam nie powoduje żadnych błędów ani utraty funkcji. Co więcej, naprawienie go, na przykład poprzez przejście na odpowiednią architekturę MVC, wymaga znacznego wysiłku. Z drugiej strony `#2` może prowadzić do utraty danych i jest trywialną naprawą ro (poprzez uniknięcie `$ID`). Moje pytanie brzmi, pod warunkiem, że _przydzielono_ do naprawy `#2`, jak skupić się na zadaniu, zamiast życzyć sobie „ci faceci piszący aplikacje Ruby on Rails są tacy szczęśliwi”.


title: Czy TDD prowadzi do dobrego projektu?

text: Jestem w przejściu ze stanu "pisanie testów jednostkowych" do TDD. Widziałem, jak Johannes Brodwall tworzy całkiem akceptowalny projekt, unikając wcześniejszej fazy architektury. Niedługo go zapytam, czy to była prawdziwa improwizacja, czy też miał jakieś przemyślenia z góry. Rozumiem też wyraźnie, że każdy ma doświadczenie, które uniemożliwia pisanie jednoznacznych złych wzorców projektowych. Ale po udziale w odosobnieniu na temat kodu nie wierzę, że napisanie najpierw testu może uchronić nas przed błędami. Ale wierzę też, że testy po kodzie znacznie szybciej doprowadzą do błędów. Tak więc to nocne pytanie dotyczy osób, które używają TDD od dłuższego czasu, dzieląc się swoimi doświadczeniami na temat wyników projektowania bez wcześniejszego myślenia. Jeśli naprawdę to przećwiczą i uzyskają w większości odpowiedni projekt. Albo to moje małe zrozumienie TDD i prawdopodobnie Agile.


title: Jak zanurzyć się w dużych bazach kodu?

text: Jakich narzędzi i technik używasz do odkrywania i poznawania nieznanej bazy kodu? Myślę o narzędziach takich jak „grep”, „ctags”, testy jednostkowe, testy funkcjonalne, generatory diagramów klas, wykresy wywołań, metryki kodu, takie jak „sloccount” i tak dalej. Byłbym zainteresowany twoimi doświadczeniami, pomocnikami, których sam użyłeś lub napisałeś i rozmiarem bazy kodu, z którą pracowałeś. Zdaję sobie sprawę, że zapoznawanie się z bazą kodu to proces, który dzieje się z biegiem czasu, a znajomość może oznaczać wszystko, od „Jestem w stanie podsumować kod” po „Mogę go zrefaktoryzować i zmniejszyć do 30% rozmiaru”. Ale jak w ogóle zacząć?


title: Jak uzasadnić przepisanie/modernizację starszego oprogramowania w przypadku biznesowym?

text: Pracuję dla świetnej małej firmy programistycznej, która zarabia niezłe przychody z naszego głównego pakietu oprogramowania. Problemem jest dla mnie to, że jest prawie nie do utrzymania. Jest napisany w Delphi 7 (z biegiem czasu jest uaktualniany) i pracowało nad nim wielu programistów w ciągu ostatnich 20 lat. Oprogramowanie nie ma żadnej znaczącej architektury - nie ma żadnej orientacji obiektowej, okropne ilości cyklicznych zależności i nadmierne poleganie na zmiennych globalnych, by wymienić tylko kilka rzeczy. Kolejną ogromną rzeczą dla mnie jest to, że Delphi 7 NIE obsługuje 64-bitów. Problem polega na tym, że mój zespół zarządzający nie przejmuje się sprawami technicznymi, chcą wiedzieć, dlaczego powinni się tym przejmować. Oczywiście tego można się spodziewać, więc proszę o wskazówki, opowieści lub pułapki związane z tego rodzaju sprawami. Jest kilka rzeczy, które chciałbym uwzględnić, a mianowicie czas potrzebny na debugowanie/napisanie funkcji w „starym” kodzie w porównaniu ze spójnym, dobrze ustrukturyzowanym kodem obiektowym. Czy ktoś zna jakieś posty na blogu lub tym podobne, o których mówi się o tym? Dla nas w firmie to ogromny powód. Pomimo tego, że jesteśmy przyzwoitymi programistami, czujemy, że pisanie nowej funkcji to po prostu więcej śmieci. Co więcej, nawet dla mnie, który ma przyzwoity poziom zrozumienia kodu, zmienianie rzeczy jest irytujące – mała zmiana może wywołać śmieszny efekt domina. Czy ktoś ma jakieś doświadczenia, którymi chciałby się podzielić?


title: Kiedy BIG Rewrite jest odpowiedzią?

text: Po prostu przeczytałem pytanie o Big Rewrites i przypomniałem sobie pytanie, na które sam chciałem odpowiedzieć. Przekazano mi okropny projekt, napisany w starej Javie, przy użyciu Struts 1.0, tabel z niespójnymi relacjami lub w ogóle bez relacji, a nawet tabel bez kluczy podstawowych lub pól, które mają być kluczami podstawowymi, ale wcale nie są unikalne. Jakoś większość aplikacji „po prostu działa”. Większość stron jest ponownie wykorzystywana (skopiuj wklejony kod) i jest zakodowana na stałe. Każdy, kto kiedykolwiek pracował nad projektem, przeklinał go w takiej czy innej formie. Teraz od dawna rozważałem zaproponowanie wyższej kadrze zarządzającej całkowitego przepisania tej przerażającej aplikacji. Powoli próbuję wykorzystać czas osobisty, ale naprawdę czuję, że zasługuje to na dedykowane zasoby, aby to się stało. Po przeczytaniu artykułów na temat wielkich przeróbek mam wątpliwości. A to nie jest dobre, kiedy chcę przekonać przełożonych, żeby poparli moją przeróbkę. (Pracuję w dosyć małej firmie więc propozycja ma możliwość akceptacji) TL;DR Kiedy jest duże przepisanie odpowiedzi i jakimi argumentami można ją poprzeć?


title: Junior - Jak zrozumieć przepływ kodu?

text: _Młodszy pytający..._ **Najpierw spory kawałek tła** Załóżmy, że programowałeś już trochę, a teraz chcesz zrobić kolejny krok w prawdziwym świecie lub przynajmniej dowiedzieć się więcej. Nie mam mentora, w każdym razie jeszcze nie, ale nie mam zamiaru siedzieć w domu i kręcić kciukami. Moim pomysłem jest zbadanie ogromnego morza open source. Problemem jest zrozumienie projektu. Możesz zobaczyć pliki i odczytać kod linia po linii, ale jest to mało pomocne, ponieważ jest > 1000 plików z > 1000 linii kodu. To jak stanie w środku lasu o północy. Gdzie idziesz ? Internet ma wiele pomysłów, jak zaangażować się w open source. Jako programista zakłada się, że masz co najmniej > 2 lata doświadczenia. Czytasz kod jak gazetę. Płynnie iz dużą łatwością. Nie jest to zbyt pomocne, ponieważ nie mam jeszcze takiego doświadczenia. Moim pomysłem jest użycie UML na początek. Powinno to również wykazać zainteresowanie i wygenerować dobre pytania do zadawania. Zacznę od góry z paczkami, folderami. Dla danego pliku instrukcja include (lub import lub...) dostarcza wszystkich wymaganych zależności. Zależności można podzielić na zewnętrzne i wewnętrzne. Klasy są różnych typów, takich jak podklasa, abstrakcja, dane, fabryka, szablon i tak dalej. Zapewnia to więcej relacji między klasami. Kiedy już wiesz coś o strukturze, możesz zacząć rozumieć przepływ. Teraz możesz zacząć oglądać las. Diagram UML może być oczywiście generowany automatycznie, ale o wiele więcej nauczę się robiąc to ręcznie. Kluczem jest tutaj nauka. To jest mój pomysł na rozpoczęcie pracy z bazą obcego kodu jako junior. Właśnie zacząłem, więc byłbym bardzo szczęśliwy, gdybyś podzielił się swoim poglądem, pomysłami i doświadczeniem. **Moje pytanie:** _Wyobraź sobie, że stoisz przed obcą bazą kodu, co robisz, aby zrozumieć przepływ kodu?_ Dla mnie to po prostu ogromny zestaw plików, tak naprawdę nie mogę zobaczyć przepływ między nimi. Naprawdę chciałbym być dobrym programistą i wiedzieć, że wciąż muszę się wiele nauczyć. Nadzieję, że rozumiesz. **Dziękuję !! // Jim G**


title: Kiedy przebudowujesz aplikację lub naprawiasz istniejącą?

text: > **Możliwe duplikaty:** > Kiedy BIG Rewrite odpowiedź? > Czy kiedykolwiek brałeś udział w BIG Rewrite? Jestem u klienta, którego zadaniem było naprawienie szeregu problemów, które mają w istniejących systemach. Wszystkie te systemy są dość stare i zostały zbudowane w starszych technologiach na naprawdę niskich standardach rozwoju. Wszystko to sprawia, że prawidłowe utrzymanie tych systemów jest dość trudne i frustrujące, z powodu dwóch myśli, które często przychodzą mi do głowy podczas pracy nad tym: * A. Byłoby o wiele łatwiej / szybciej zrobić to w jednym z nowszych technologie. * B. Nie kodowałbym tej funkcji w ten sposób. Istnieje wiele lepszych sposobów na zaprojektowanie tej aplikacji, aby była łatwiejsza w utrzymaniu i wydajniejsza. (przykłady to zły projekt OO, kod jest często powtarzany, ustawienia są zakodowane na stałe itp. lista jest długa). Tak więc w tych okolicznościach staram się jak najlepiej wykorzystać i naprawić wszystko najlepiej, jak potrafię, nie narzekając zbyt wiele, ale teraz moje pytanie brzmi: jak zdecydować, kiedy nadszedł czas, aby przebudować system z nowszą technologią, w przeciwieństwie do utrzymywania na zatykanie dziur w starym? A jak zrobić argument za przebudową? Jak przekonać władze, które muszą odbudować system?


title: Jak zarządzać i szacować nieustrukturyzowane wymagania otrzymane od klientów

text: Często w fazie licytacji projektu otrzymuję wymagania dotyczące oprogramowania od naszych potencjalnych klientów w bardzo nieustrukturyzowanym formacie z różnych źródeł [e-mail, dokumenty Word, Excel]. Zazwyczaj jest to grupa ludzi od „rozwoju produktu” ze strony klienta, którzy wymyślają te „proponowane rozwiązania” problemów biznesowych, które mają. Chociaż są ekspertami w dziedzinie biznesu, często nie mają odpowiednich rozwiązań. Powoduje to * wiele wersji tego samego wymagania * mieszanie dwóch wymagań w jedno * kilka wersji wymagania w dalszej kolejności, wymagania, które zostały połączone razem, zostają ponownie oddzielone, a każde z nich zawiera kilka nowych dodatków Jak pracujesz z takimi wymaganiami przychodzącymi i sortujesz je we właściwe przypadki użycia i przed rozpoczęciem rozwoju? Jakich narzędzi możemy użyć do śledzenia historii konkretnego wymagania, od pierwszego powstania do momentu, gdy zostanie skrystalizowany we właściwym przypadku użycia? Szacowanie pracy na podstawie otrzymanych w ten sposób wymagań to koszmar, który kończy się błędami w prawidłowym zrozumieniu wymagania i poprawnym oszacowaniu nakładu na nie. Gdy wygramy projekt, klienci dokładniej zastanowili się nad swoimi wymaganiami i byli w stanie odpowiednio je sformułować. W tym przypadku pewne funkcje zostają porzucone, inne ulepszone, a inne nabierają zupełnie nowego charakteru. To w zasadzie może unieważnić niektóre szacunki elementu pracy, które zostały wykonane przed wygraniem projektu. Chciałbym wiedzieć, czy istnieje jakiś system, za pomocą którego możemy zbudować drzewo o określonym wymaganiu i jak każda gałąź dawała inne oszacowanie. Jakieś wskazówki, narzędzia, triki ułatwiające zarządzanie tą aktywnością? Po prostu próbuję uzyskać spostrzeżenia od kogoś bardziej doświadczonego niż ja w zarządzaniu wymaganiami i szacowaniu nakładu pracy.


title: Jak dokładnie tworzysz kosztorysy dla powierzonych Ci projektów programistycznych?

text: Szukam wglądu od was, mądrych ludzi na SO. Jestem stosunkowo nowym programistą (ponad 3 lata doświadczenia) głównie na frameworku .NET i jestem absolutnie kiepski w umiejętności prawidłowego oszacowania nawet najmniejszych projektów. Wiem, że będzie to dość duża przeszkoda w mojej mobilności w górę i mojej radości z programowania, jeśli nie wymyślę dobrych narzędzi, metodologii, podejść itp. Dlatego szukam Twojej wiedzy i mądrości na ten temat . Słyszałem o SWAG i przez większość czasu wykorzystywałem to do oszacowania w przeszłości, ale nie czuję się komfortowo, po prostu „wyczuwając to”. Oczywiście z mojego doświadczenia w wykonywaniu podobnych projektów pamiętam, jak długo mi to zajęło i podaję stosunkowo dokładne oszacowanie, ale nawet to nie zawsze jest bardzo dokładne. Dodatkowo wydaje się, że w każdym projekcie są nieodłączne wady i nieprzewidywalne sytuacje, które jeszcze bardziej utrudniają szacowanie. Myśli?


title: Ogranicz bezużyteczną złożoność kodu

text: Mam pytanie, żeby to wyjaśnić, co jest lepszego niż całkowicie fikcyjny przykład? Załóżmy, że jesteś młodym programistą zatrudnionym w firmie. Wszystkie dane są przechowywane w ogromnej bazie danych (powiedzmy ponad 500 tabel z miliardem wierszy). Twój szef prosi cię o zrobienie kilku zapytań konsolidacyjnych. Zaczynasz więc tworzyć swoje zapytanie i podczas procesu rozwoju poznajesz wiele warunków, które musisz dodać do swojego zapytania. Wynik? Twoje zapytanie działa całkiem dobrze, żądany wynik jest poprawny, ale jest powolny i niezbyt łatwy do zrozumienia. Czemu? Bo zapytanie, z powodu wielu modyfikacji, stało się bardzo skomplikowane. Potem, po sprawdzeniu tego z kolegą, który od lat pracuje w firmach, napisał to samo zapytanie niż Ty, ale... łatwiejsze do nauczenia i szybsze do wykonania. Tak więc właściwie głównym pytaniem jest: jak możemy ograniczyć tę bezużyteczną złożoność? Jak w rzeczywistości uczynić kod bardziej logicznym? Właściwie moim początkowym pomysłem było narysowanie diagramów aktywności kodu, aby zobaczyć, gdzie są wąskie gardła, ale myślę, że możliwe jest lepsze podejście. Szukam książek, linków, pomysłów, podejść, metodologii...


title: Czy istnieją dobrze znane podejścia ilościowe do oceny konkretnego projektu, czy spełnia on lub narusza zasady projektowania SOLID?

text: Zaprojektowałem framework aplikacji, biorąc pod uwagę zasady projektowania SOLID i wspierany przez wzorce projektowe. Zastanawiam się jednak, czy istnieją jakiekolwiek zautomatyzowane narzędzia lub znane podejścia do oceny, czy zasady projektowania SOLID są spełnione lub naruszone w proponowanym projekcie?


title: Jak nauczyć się dokonywać lepszych szacunków?

text: Jestem do bani z szacunkami. Kiedy ktoś pyta mnie, jak długo coś potrwa, nie śmiem nawet zgadywać, bo zupełnie mi się nie udaje. Zwykle jestem zbyt optymistyczny i prawdopodobnie powinienem pomnożyć swoje przypuszczenia przez jakiś duży współczynnik X... Jak mogę nauczyć się lepiej oszacować? Nie uczy się tego na moim uniwersytecie i chociaż mamy terminy wszystkich prac, nigdy nie zastanawiam się, jak długo coś potrwa. Które powinienem. Dla dobra wszystkich (zwłaszcza mojego).


title: Jak sprawić, by użytkownicy ocenili swoje potrzeby w zakresie ulepszania oprogramowania?

text: Odziedziczyłem starszy system oprogramowania i otrzymałem zadanie wykonania aktualizacji użyteczności i systemu. Chociaż nie ma nic złego w systemie, z dyskusji z użytkownikami, istnieją "małe" problemy z użytecznością, które należy rozwiązać. Na tym etapie jestem samotnym programistą w tym systemie i poza testowaniem w ogóle nie używam systemu, więc trudno mi wiedzieć, jakie problemy mogą istnieć lub są postrzegane. Będę miał trochę czasu, aby porozmawiać z nimi wszystkimi i przedyskutować, co postrzegają jako dobre/złe lub obojętne w stosunku do systemu. Ponieważ to w zasadzie tylko ja na razie mój czas jest limitem. Zastanawiałem się więc nad poproszeniem ich, aby wyobrazili sobie, że będę w stanie dokonać tylko jednej zmiany, aby wszyscy napisali prywatnie, co chcieliby, aby ta jedna zmiana była, a następnie pomóc im je uszeregować, ale mam nadzieję na inne wskazówki. Jakie istnieją techniki skłaniania użytkowników do wyjaśniania ich potrzeb, potrzeb i wymagań, a jednocześnie do oceniania ich według ważności lub atrakcyjności?


title: Entropia w systemach oprogramowania na dużą skalę

text: Pracuję na dość dużym systemie oprogramowania i przez lata nagromadziło się w nim sporo entropii. Istnieje wiele możliwości refaktoryzacji, ale zawsze istnieje presja, aby budować kolejne funkcje na podstawie tego, co już istnieje. Zwiększa to entropię, ponieważ wybory projektowe dotyczące implementacji nowych funkcji są zazwyczaj dokonywane przez zaakceptowanie tego, co tam jest i „obejście” wcześniejszego słabszego projektu, który w przeciwnym razie byłby gotowy do refaktoryzacji. Jakie są sposoby na zarządzanie tego rodzaju złożonością i budowanie funkcjonalności bez dalszego znacznego osłabiania struktury systemu. Wiem, że jest to bardzo szerokie pytanie, a podejścia/rozwiązania zależą od konkretnego systemu oprogramowania, ale wciąż mam nadzieję, że istnieją pewne ogólne sposoby radzenia sobie z problemem, który podkreślam.


title: Jak czysty powinien być nowy kod?

text: Jestem głównym projektantem w naszym zespole, co oznacza, że odpowiadam za jakość kodu; funkcjonalność, łatwość konserwacji i czytelność. Jak czysty powinien być kod członków mojego zespołu, jeśli nie brakuje nam czasu? Moim zdaniem powinniśmy wyczyścić stary kod, który modyfikujemy; dodanie linii do metody oznacza wyczyszczenie tej metody. Ale co z nowym kodem? Moglibyśmy sprawić, by był lśniąco czysty, tak że jeśli jutro pojawi się inny koder i dokona małej modyfikacji, w ogóle nie będzie musiał go czyścić. Ale to oznacza, że jeśli nikt nigdy więcej nie przeczyta tego fragmentu kodu, zmarnowaliśmy czas, aby był lśniący czystością. Czy powinniśmy dążyć do „prawie czystego”, a następnie sprzątać go dalej podczas przyszłych wizyt? Ale to oznaczałoby, że nie uzyskamy pełnej wartości zrozumienia, które mieliśmy, kiedy go pisaliśmy. W tej chwili wybieram „nieskazitelnie czysty”; częściowo jako samouczek dla moich kolegów, którzy nie są tak wybredni jak ja.


title: Kwantyfikowanie wartości refaktoryzacji w ujęciu komercyjnym

text: Oto klasyczny scenariusz; Zespół programistów buduje prototyp. Zarządzają biznesem, jak to się podoba i wprowadzają do produkcji. Zespół programistów musi teraz nadal dostarczać nowe funkcje, jednocześnie spłacając dług techniczny narosły, gdy baza kodu była prototypem. Moje pytanie jest takie (wybaczcie, to raczej otwarte); jak ująć wartość pracy refaktoryzacji w ujęciu komercyjnym? Jako programiści możemy jasno zrozumieć i przekazać wartość w kategoriach technicznych, takich jak usunięcie duplikacji kodu, uproszczenie modelu obiektowego i tak dalej. Ale to niewiele znaczy dla dyrektora skoncentrowanego na elementach komercyjnych. To, co będzie coś znaczyło dla tego dyrektora, to programista. zespół jest w stanie dostarczyć wymagania w szybszym tempie. Samo sformułowanie tego stwierdzenia bez żadnych mierników, które jasno określają zwrot z inwestycji (zwiększona prędkość w zamian za zasoby przeznaczone na refaktoryzację) ma niewielką wagę. Chciałbym usłyszeć od każdego, kto miał doświadczenie, pozytywne lub negatywne, w związku z powyższym. \----------------- EDYTUJ ---------------- Dziękuję za dotychczasowe odpowiedzi, z których wszystkie uważam za dobre. To, co chcę opracować, to metryka, która udowadnia (lub obala!) wszystkie te stwierdzenia. Raport, który wiąże szybkość z refaktoryzacją i wykazuje pozytywny efekt.


title: Jak przetrwać w świecie Wodospadu?

text: Obecnie pracuję w firmie, w której model Wodospadu jest głęboko zakorzeniony. Naciskamy zasady Agile, ale to długi proces. W międzyczasie muszę pracować w świecie wodospadów z sekwencyjnymi fazami projektów. Moje pytanie dotyczy fazy analizy. Muszę podać listę zadań i czas ich realizacji. Jakich technik mogę użyć, aby poprawić dokładność/precyzję moich szacunków, jednocześnie spełniając wymóg posiadania szczegółowego oszacowania z góry? Jednym ze znanych mi przykładów byłoby użycie prototypowania, aby uzyskać więcej wiedzy przed dokonaniem oszacowania.


title: Rozważania przed przepisaniem komponentu oprogramowania od podstaw?

text: Oprogramowanie to zlepek starych i nieudokumentowanych wysiłków. Nie ma żadnych komentarzy, dokumentacji, a kod jest niejasny — obejmuje _skrypty powłoki Unix, które sprawdzają fałszywe pliki, a następnie wywołują instrukcje SQL, które wywołują procedury bazy danych, które modyfikują dane._ Pierwotni programiści odeszli, a my otrzymujemy solidną 2. na teście Joela, ale mogę go podnieść do co najmniej 4 - yay... Kod jest w miarę wolny od błędów, ale ciągle musimy dodawać do niego nowe funkcje, które są bardzo podatne na błędy ze względu na stan kodu, więc terminy się przesuwają, a wysiłki rosną. **Chcemy przepisać to oprogramowanie, aby zmniejszyć nakłady związane z konserwacją i rozwojem.** W ramach przepisywania wprowadzimy specyfikacje, komentarze, przypadki testowe – wszystko, czego obecnie nie mamy. Później będzie to trochę skomplikowane, ale nie więcej niż to konieczne. To nie jest DUŻA przeróbka, ponieważ nie zamierzamy zmieniać języków ani frameworków; nadal będziemy potrzebować skryptów powłoki (ale mniej) i procedur bazodanowych (ale mniej). Konsekwencje są również dość proste, ponieważ kontrolujemy miejsca instalacji i możemy w pełni zastąpić stary kod nowym kodem jednym ruchem przełącznika. Wiem, że przepisywanie nigdy nie jest dobre, ale myślę, że są to rozsądne kontrargumenty. Niemniej jednak obawiam się typowego niebezpieczeństwa wprowadzenia zupełnie nowych błędów zamiast starych znanych, a także niebezpieczeństwa niewdrożenia niektórych szczegółów, ponieważ nikt nawet nie wie, że istnieją lub są potrzebne. **Jak mogę efektywnie podejść do tego przepisania?**


title: Ile czasu poświęcasz na analizę? Czy to paraliż analizy?

text: Nie jestem dobry w szacowaniu, ile czasu zajmie ukończenie jakiejś pracy. Jestem winny włożenia palca w powietrze i zgadywania. Zwykle rzeczy są później niż oczekiwano, ale czasami są wcześniej niż oczekiwano. Na przykład ostatnie indywidualne zadanie zostało wykonane w ciągu czterech miesięcy zamiast pięciu. Jednak zazwyczaj się spóźniam. Chcę być w tym lepszy. Jeśli powiem, że coś zajmie cztery miesiące, to chcę, żeby to potrwało cztery miesiące lub mniej, a nie cztery i pół miesiąca czy pięć miesięcy itd. Kolejne zadanie, do którego się zbliżam, zostało przeniesione na szczyt planu projektu w ciągu ostatniego tygodnia, ponieważ nacisków zewnętrznych (zewnętrznych na wydział). Obszar biznesowy chce dokładnie wiedzieć, ile czasu zajmie ukończenie. Trudno mi to oszacować z następujących powodów: 1. Tworzony przeze mnie system jest bardzo złożony. Odziedziczyłem go kilka lat temu, a poprzedni deweloper nie stosował dobrych praktyk m.in. SOLIDNY, warstwy rozdzielające (warstwa biznesowa itp.) itp. 2. Wymagania biznesowe nie są szczególnie dobrze rozumiane przez obszar biznesowy, ponieważ system jest bardzo złożony i musimy brać pod uwagę przepisy, które są jedynie wskazówkami i całkowicie otwarte na interpretację. 3. Brakuje nam odpowiednich narzędzi m.in. framework testowy, ciągła integracja itp. 4. Jestem samodzielnym programistą, więc nie mam do kogo naprawdę zwrócić się o wskazówki lub pomoc, np. z testowaniem itp. W każdym razie czytałem takie pytania: Jak odpowiedzieć, gdy zostaniesz poproszony o wycenę? i to: http://msdn.microsoft.com/en-GB/library/hh765979.aspx. Mój przełożony zasugerował, żebym poświęcił miesiąc na analizę następnej pracy (to skomplikowane). Myślę, że mógłbym to zrobić w tydzień (zwykle spędzam tylko kilka dni). Jaki powinien być wynik analizy Agile? Jak długo zazwyczaj poświęcasz na analizę?


title: Jak uzyskać od klienta istotne i przydatne informacje dotyczące pracy?

text: Krótkie tło dotyczące tego konkretnego pytania: > Po spotkaniu z klientem i wysłuchaniu wszystkich jego próśb, wymagań, > i innych uwag na temat konkretnej pracy związanej z oprogramowaniem, zaplanowaniu oprogramowania > funkcjonalności, projektu i podstawowego doświadczenia użytkownika, klient przychodzi powrót z komentarzem dotyczącym: „To nie jest to, czego szukamy. Nie możesz zrobić tego, co > my chcemy”. Teraz rozumiem koncepcję, że nie wszyscy rozumieją technologię i że niektórzy ludzie są bardziej wizualni niż inni i mogą potrzebować zobaczyć rzeczy, zanim będą mogli być czegoś pewni. Rozumiem również proces poprawek i innych modyfikacji w celu spełnienia określonych wymagań funkcjonalnych lub wymagań, które mogą pojawić się dopiero po rozpoczęciu składania rzeczy. Chodzi mi o to, że jeśli wszyscy mają rację w wersji 1.0, wyobraź sobie, jak wspaniały byłby to świat! **Dane** : Nie ma magicznej formuły na gwarantowany wskaźnik sukcesu, gdy wiele prac ma charakter artystyczny w tym sensie, że ten sam zestaw kierunków może być różnie interpretowany przez różne osoby. Zdaję sobie sprawę, że zadawanie **właściwych** pytań jest ważne i przeprowadziłem pewne badania dotyczące pytań zadawanych przez innych w podobnych zawodach. Mam też wcześniejsze doświadczenia z klientami (to nie jest moja pierwsza praca) i dzięki temu rozwinąłem swój własny mały system pozyskiwania tych informacji, który do tej pory miał 99% skuteczności. Zwykle, jeśli nie uda mi się za pierwszym razem, jest to naprawiane podczas procesu rewizji i modyfikacji. Wiem, że nie jestem idealna, ale nigdy tak naprawdę nie miałem klienta, który by odmówił tego, o co prosił... Więc ** w jaki sposób możesz uzyskać od klienta istotne i przydatne informacje dotyczące wymagań i specyfiki pracy? **


title: Najlepszy argument na poparcie refaktoryzacji

text: Obecnie pracuję nad kodem najlepiej opisanym jako kod C żyjący w ciele C++. Jednak nie byłem w stanie przekonać mocy, która byłaby do refaktoryzacji ze względu na łatwość konserwacji. Co Twoim zdaniem jest najlepszym argumentem za refaktoryzacją kodu.


title: Czy powinienem przekonać przełożonego, że porządkowanie kodu powinno mieć pierwszeństwo przed dotrzymywaniem terminów?

text: Mój menedżer ma napięte terminy do dotrzymania. Obecny projekt, nad którym pracuję, jest obecnie zgodny z harmonogramem, ale zauważyłem kilka dość znaczących obszarów w kodzie, które są naprawdę źle napisane. (Bity kodu są wywoływane dwa lub trzy razy, podczas gdy wystarczy je wywołać tylko raz.) Problem w tym, że dla mojego kierownika program działa. Według niego nie ma sensu dokonywać długich zmian w kodzie, które spowodują, że przegapimy datę premiery, bez widocznej poprawy. Ciągle powtarza: „To nie jest priorytet. Działa dobrze, jak jest”. Czy powinienem dalej próbować go przekonać, czy po prostu zrobić to, co sugeruje i zostawić to? Dlaczego lub dlaczego nie? Zauważ, że jak przekonać kierownictwo zostało już omówione.


title: Jaki jest sposób na zrozumienie cudzego gigantycznego kodu spaghetti bez komentarza?

text: > **Możliwy duplikat:** > Odziedziczyłem 200 tys. linii kodu spaghetti – co teraz? Niedawno miałem do czynienia z gigantycznym wielowątkowym programem bez komentarzy i zostałem poproszony o zrozumienie, co robi, a następnie o jego ulepszenie (jeśli to możliwe). Czy są jakieś techniki, których należy przestrzegać, gdy musimy _zrozumieć_ czyjś kod? CZY od razu zaczynamy od pierwszego wywołania funkcji i śledzimy kolejne wywołania funkcji? C++ (z wielowątkowością) w systemie Linux


title: Jak przekonać firmę do rozpoczęcia dokumentacji dla starszego oprogramowania?

text: Minął niecały rok odkąd dołączyłem do mojej obecnej firmy. Większość sprzedaży pochodzi z jednego produktu, który istnieje od 10 lat. Dokumentacja jest jednak minimalna (jeśli w ogóle). Programiści w firmie borykają się nie tylko z brakiem dokumentacji, ale także z dużą rotacją, przez co wszyscy tracą czas. Dzieje się tak, ponieważ doświadczeni programiści opuścili firmę i jest coraz mniej zasobów do komunikacji / burzy mózgów. Nie wchodząc w szczegóły, zasugerowałem poprzedniemu menedżerowi, że potrzebna jest jakaś dokumentacja (przynajmniej dokument architektury), która przedstawia zarys produktu. Zasugerowałem również użycie JavaDoc i innych narzędzi do automatycznej dokumentacji. Odpowiedzią na te sugestie były lekkie uśmiechy i wypowiedzi typu „Nie mamy wystarczająco dużo czasu”, „Potrzebujemy teraz krótkoterminowych ulepszeń”, a nawet „Sam kod powinien być dokumentacją” samych programistów. Zmarnowałem już wystarczająco dużo czasu, próbując dowiedzieć się, czy to, czego potrzebowałem na wymaganie/błąd, istniało w tej dużej (naprawdę) bazie kodu. Czekam na wszelkie sugestie dotyczące potrzeby dokumentacji. Lub raczej, jeśli jest to przegrana sprawa dla tego starszego systemu lub organizacji.


title: Co dokładnie sprawia, że kod jest „czysty”?

text: Jestem stażystą w małej firmie programistycznej, wykonując typową pracę gruntowną. Wiele zadań, które realizują programiści, jest ponad moją głową, jednak w końcu udało mi się zobaczyć prawdziwą "akcję" i napisać trochę kodu. Przyznam, że zadanie było może trochę za trudne dla mnie, ale dałem radę i mój kod w końcu zadziałał. Kiedy mój mentor robił przegląd kodu, powiedział mi: „Człowieku, ta część jest brzydka”. Kiedy powiedziałem: „Dlaczego? Czy jest z tym coś nie tak?” odpowiedział: „Nie, kod działa, ale to po prostu nie jest czysty kod”. Z pojęciem czystego kodu spotkałem się już kilka razy, zwłaszcza teraz, odkąd spotykam się z profesjonalnymi programistami. Ale co dokładnie sprawia, że kod jest „czysty”? Innymi słowy, jakie są kryteria? Słyszałem w matematyce formalnej, że „piękny” dowód to taki, który jest najlepiej jak najjaśniejszy i jak najkrótszy oraz wykorzystuje techniki twórcze. Wiele osób wie, że w literaturze „dobra” literatura to taka, która może wyrażać uczucia bez wysiłku i elegancko do tego stopnia, że można ją „poczuć”. Ale nie można "wyczuć" kodu (przynajmniej ja nie mogę) i myślę, że większość zgodziłaby się, że krótki kod niekoniecznie jest najlepszy (ponieważ może być bardzo nieefektywny) lub nawet, że zawsze preferowany jest najbardziej wydajny sposób ( ponieważ może być bardzo długi i złożony). Więc co to jest! Proszę, spróbuj oświecić mnie, co dokładnie sprawia, że kod jest „czysty”.


title: Jak uporządkować ogromny projekt spaghetti

text: Wcześniej pytałem o to na StackOverflow, ale poinformowano mnie, że jest to lepsze rozwiązanie dla programistów. Niedawno rozpocząłem pracę nad bazą kodu (jako programista Java) o następujących cechach: * Około 800 000 linii kodu źródłowego (w tym odstępy i komentarze). Przede wszystkim Java, ale także XML, PHP, skrypty powłoki, JSP, JS, HTML, CSS * Frameworki: Głównie Stripes, trochę Struts i trochę dość starego dostosowanego Hibernate (i spodziewam się wielu innych elementów). * Brak określonej metodologii dla opowiadań, sprintów itp. * Brak testów * Brak procesu budowania * Brak zarządzania zależnościami (wszystko jest po prostu skonfigurowane w IDEA) * Bardzo stary kod sięgający 2002 roku * Brak standardów kodowania * Masa nadmiarowości kodu, chociaż biorąc pod uwagę brak testów, jest to trudne do wyśledzenia * Wiele modułów i współzależności * Ogromny plik XML zawierający 10 000 wierszy zawierający nazwane zapytania Hibernate * Klasy „Dump-all” na szczycie drzewa dziedziczenia zawierające odniesienia do wielu usług, które może być używany tylko w kilku klasach potomnych (Na przykład jedna klasa jest rozszerzona o 573 klasy. Z konkretnej usługi w niej zawartej korzysta tylko 3 dzieci) * Demotywowani programiści Wiem, że to naprawdę otwarte pytanie: Od czego zacząłbyś, próbując uporządkować ten system?


title: Argumenty do nietechnicznego menedżera za uaktualnieniem programu

text: **Moja sytuacja:** Obecnie odbywam staż w dużej firmie, opracowując narzędzie do automatyzacji (tylko do użytku wewnętrznego firmy). W zespole jest około 30 osób, ale jesteśmy tylko 3 programistami, wszyscy praktykanci (w stopniu magisterskim). Rdzeń oprogramowania i interfejs użytkownika zostały wykonane przez doświadczonych pracowników, ale trzy lata temu. **Problem:** Wiele używanych technologii można zaktualizować (.net 3.5 do 4.0, używając LINQ do interakcji z bazą danych, Forms to WPF ...), a interfejs użytkownika naprawdę nie jest ergonomiczny. **Co chcę zrobić:** Chciałbym go zaktualizować i przerobić interfejs użytkownika, aby poprawić wydajność, łatwość konserwacji i ergonomię, ale moi menedżerowie — analitycy biznesowi — nie zaspokajają potrzeby ulepszania oprogramowania, które działa poprawnie. **Dlaczego nie mogę:** Chcą, abyśmy wykonali nowe zadania związane z automatyzacją, uważają, że aktualizacja byłaby stratą czasu i nie są pewni, czy uda nam się zrealizować w pełni to, do czego zmierzam. **Moje tymczasowe rozwiązanie:** Ponieważ jestem zmotywowany i naprawdę uważam, że aktualizacja jest konieczna, spędzam kilka wieczorów i weekendów na rozwijaniu nowej wersji, mając nadzieję, że po zakończeniu będę mogła im pokazać i spodoba się im. Ale cały ten _czas pracy_ nie jest płatny i nie mam tak dużo, więc nadal mam nadzieję, że będę miał w biurze cały tydzień pracy nad tym. **Moje pytanie:** W jaki sposób najlepiej przekonać moich menedżerów, że czas poświęcony na opracowanie aktualizacji nie będzie stratą czasu (wiedząc, że wszystkie argumenty techniczne nie zostaną zrozumiane)? Nie chcę też, aby oni i moi współpracownicy źle zrozumieli moją motywację, próbując się popisać lub mieć inne egoistyczne intencje.


title: Zrozumienie już istniejącej złożonej bazy kodu

text: > **Możliwe zduplikowanie:** > Jaki jest najskuteczniejszy sposób dodania funkcjonalności do nieznanego, > niepoprawnego strukturalnie kodu? Do tej pory pracowałem tylko nad projektami Java, które buduję od podstaw (głównie projekty kursów i trochę hobby). Ale teraz natknąłem się na ogromną bazę kodu składającą się z około 46000 wierszy rozłożonych na około 200 klas. Dodatkowo istnieje około 10 bibliotek zależnych. Problem polega nie tylko na tym, że nigdy wcześniej nie pracowałem z cudzym kodem, ale też nie pracowałem wcześniej z tak ogromną bazą kodu. Zostałem poproszony o pełne zrozumienie bazy kodu i zasugerowanie ulepszeń istniejącego projektu. Teraz trochę utknąłem. **Zaczynam od jakiejś części kodu, a kiedy dotrę do innej części kodu, straciłem robocze szczegóły z poprzedniej części.** Naprawdę przyda mi się Wasze sugestie i doświadczenia, aby poradzić sobie z tym problemem . Jak postępować/dokumentować szczegóły klas, aby lepiej zrozumieć kod? Edycja: jest to projekt badawczy na poziomie uniwersyteckim. Studenci rozwijali go przez kilka lat, a zła część: studenci, którzy to napisali, już ukończyli szkołę. Istniejąca dokumentacja (tylko w formie Javadocs, a nie rzeczy UML) jest dużo, ale nie jest pomocna w zrozumieniu projektu aplikacji.


title: Dlaczego terminy są zawsze tak krótkie?

text: Jestem młodszym programistą w małej firmie (w zespole 2 programistów). Za każdym razem jesteśmy proszeni o zaimplementowanie nowej funkcji: * termin jest ustalany tak, abyśmy mieli czas na rozwój: nie ma marginesu błędu (jeśli coś zajmuje trochę więcej czasu niż oczekiwano, jesteśmy spóźnieni); prawie nie ma czasu na testy (jesteśmy prawie pewni, że będą błędy) ; nie ma czasu na refaktoryzację czegokolwiek * jesteśmy proszeni o rozpoczęcie rozwoju, zanim funkcje zostaną całkowicie określone, więc pojawiają się nowe rzeczy do zrobienia, ale termin pozostaje taki, jak jest W rezultacie dostarczamy oprogramowanie, które ma błędy, a dług techniczny stale rośnie . Używamy technologii, która była uważana za najnowszą wersję w 2006 roku. Było jedno wydawnictwo, które bardzo dobrze pamiętam. Kiedy pokazaliśmy szefowi, powiedział nam: „Co!? Wyprodukowanie tego zajęło ci dwa tygodnie?!” i wszystko, na co mogliśmy odpowiedzieć, to „Nie, w rzeczywistości zajęło nam to trzy tygodnie”. Miałem spotkanie z nim i innym młodszym programistą (który odszedł z firmy z powodu tego wspomnianego spotkania!) i zasadniczo powiedział nam, że nie jest szczęśliwy, ponieważ to, co wydaliśmy, było gównem. Dług techniczny i konieczność refaktoryzacji były tak duże w częściach, które musieliśmy zmodyfikować (ale powiedziano nam, aby nie refaktoryzować, ponieważ nie mamy czasu), że: * musieliśmy dodać warstwę złego kodu na już zły kod; * zajęło nam dużo czasu próba zrozumienia kompletnie niezrozumiałego kodu. Nie czuję się odpowiedzialny za to złe wydanie, myślę, że obowiązkiem szefa jest zatrudnianie dobrych programistów, którzy przynajmniej rozumieją podstawowe zasady OOP. Ale zatrudnianie juniorów jest znacznie tańsze... Już mówi, że jesteśmy spóźnieni na rozwój, nad którym obecnie pracuję. Ponad rok poświęcił na „przeprojektowanie” narzędzia, które było już obecne w naszej aplikacji, ale teraz chce, abyśmy zaimplementowali je w dwa tygodnie. Osobiście uważam, że jeśli chcemy zrobić to poprawnie, potrzebujemy przynajmniej miesiąca, a może nawet 6 tygodni. Nie wiem co robić, bo myślę, że szef uważa, że jesteśmy po prostu powolni i nieskuteczni. Nie w taki sposób dostanę podwyżkę, na którą zasługuję. Dlaczego tak jest? Nie wydaje się to trudne do zrozumienia, że jeśli potrzebuję x dni na wykonanie zadania, nie mogę tego zrobić w x/2 dni, nawet jeśli powiesz „proszę” i zapytasz z uśmiechem. Wydaje się to tak oczywiste, że nie dotrzymamy terminu i/lub nie zostaną spełnione wymagania jakościowe. Nie muszę wiedzieć, jak mam wytłumaczyć mojemu szefowi, że tworzenie oprogramowania to dłuższy proces niż kliknięcie ikony. Bo mam nadzieję, że już to wie.


title: Szef nie wierzy w moje oszacowanie czasu... porada/kopia zapasowa?

text: Pracuję w firmie zajmującej się tworzeniem oprogramowania – 3 programistów, mniej niż 15 pracowników, w tym prezes. Zajmujemy się wyłącznie Windows Mobile, .NET CF i przekazywaniem informacji zebranych z naszej aplikacji na urządzenia przenośne do iz naszej strony internetowej. Mój dyrektor i ja właśnie mieliśmy spotkanie w sprawie pilnego projektu, który jeszcze się nie rozpoczął, ale prawdopodobnie niedługo powinien zacząć działać, jeśli mamy dotrzymać terminów dostaw dla potencjalnego, ale bardzo potężnego i wpływowego klienta. Wyjaśnił mi projekt w następujący sposób: * Nowy projekt będzie składał się głównie z aplikacji .NET CF, która pozwala klientowi na przeprowadzenie wielu próbek gleby podczas jednej sesji. * Obszar, z którego pobierana jest próbka, powinien być przedstawiony na mapie o odpowiedniej wielkości i skali. * Mapa powinna być dynamicznie podzielona na kwadraty siatki o wielkości ustalonej przez użytkownika (w akrach). * Na każdym kwadracie siatki użytkownik będzie miał możliwość robienia notatek i zaznaczania poszczególnych punktów za pomocą GPS w czasie rzeczywistym z pokładowego odbiornika. * Ponadto powinna istnieć funkcjonalność, która pomoże wskazać użytkownikowi dowolny kwadrat siatki, biorąc pod uwagę jego aktualną pozycję. * Wszystkie gromadzone informacje powinny być łatwo pobierane i odczytywane w bardzo przyjazny dla użytkownika sposób na urządzeniu przenośnym klienta – urządzeniu, które zapewniamy – w dowolnym momencie. * Wszystkie zebrane informacje powinny być łatwo przesyłane – przez ActiveSync, bezprzewodowo lub „co masz” – do naszej witryny internetowej, gdzie powinny być dostępne do przeglądania/edycji w interfejsie podobnym do interfejsu urządzenia przenośnego. Mając ten opis na uwadze, przemyślałem wszystko (choć dość szybko). Przy obecnej wielkości personelu, ograniczonym budżecie i ograniczonych zasobach przewidywałem, że takie przedsięwzięcie zajmie około 9 do 18 miesięcy. Wybacz mi, że jestem w lewym polu, jestem świeżo upieczonym absolwentem CS i całkiem nowy w „prawdziwym” świecie. Jednak projekt jest obecnie realizowany tylko w głowie mojego reżysera, bez dokumentacji projektowej i specyfikacji. Moje pytanie brzmi: jak daleko jestem naprawdę? Po raz kolejny mój dyrektor – który nie ma żadnego doświadczenia w oprogramowaniu ani informatyce, ale jest ekspertem w zakresie pobierania próbek gleby – określił czas trwania projektu na około 3 miesiące. Pamiętaj, że obecnie używamy nieobsługiwanego pakietu SDK dla pozostałych potrzeb GPS i GIS, a produkty ESRI są dla nas prawie zbyt daleko poza zasięgiem. Obecna funkcjonalność naszych innych aplikacji daje nam przewagę, dzięki możliwości rysowania obszarów, polilinii i punktów na mapie. Jestem tutaj trochę zdezorientowany/przestraszony, zastanawiając się, czy całkowicie się mylę, czy mam rację, ale po prostu nie mam pewności siebie. Wszelkie porady są mile widziane. Dziękuję!


title: Co zrobić ze źle zorganizowaną aplikacją?

text: Jestem świeżo upieczonym programistą i właśnie zostałem zatrudniony przed ukończeniem studiów. W biurze tworzyłem i poprawiałem moduły niektórych aplikacji opracowanych przez innych programistów w naszej firmie. Problemy, które napotkałem z ich aplikacjami to: 1. Nieznormalizowana baza danych w najlepszym wydaniu, złamali wszystkie zasady normalizacji bazy danych, Codd musi być zły. 2. 50% zawartości bazy jest dosłownie NULL (powinny mieć domyślną wartość, przysięgam). 3. We wszystkich transakcjach bazy danych używana jest jedna procedura składowana, pełna instrukcji „if-else”. 4. Na nowo wymyślają ustawienia aplikacji w .NET WinForms, tworzą własny plik, który zawiera wszystko, czego chcą. Myślę, że są wielkimi fanami VB6, a może tak naprawdę nie uczą się, tylko zgadują, jak coś osiągnąć. 5. Brak obsługi błędów! Klienci czasami zgłaszają „Wyjątki”, których nie powinni widzieć. 6. Pliki internetowe i formularze Windows Forms nie są zorganizowane ani pogrupowane według ich wykorzystania. 7. Konwencja nazewnictwa, istnieją litery Camel, czyste małe litery, z podkreśleniami i skrótami oraz bez nich. 8. Złe praktyki programistyczne, takie jak transakcja bazy danych w każdej iteracji pętli. 9. Opracowali stronę internetową z myślą o wstrzyknięciu SQL, witają ich. 10. Elementy HTML nie zostały użyte zgodnie z ich sematyką. 11. CSS nie są zoptymalizowane dla różnych przeglądarek. 12. Zawierają kilka wersji jQuery w jednym kodzie HTML! . . . N. O wiele więcej! Najgorsze jest to, że czułem się obwiniany za jego kruchość. Chodzi mi o to, że kiedy dodaję kod, zdarza się, że kończy się to błędem, czasami dlatego, że nie tworzyły ograniczeń lub pozwalały na powielanie danych. System jest tak delikatny i zależny od siebie, że to jak chodzenie po polu z minami lądowymi! (TO DZIEJE SIĘ CZASAMI, TO NIE JEST PRAWDZIWY PROBLEM) Co powinienem zrobić?


title: Co mam zrobić, jeśli nie mam formalnej specyfikacji?

text: Niedawno przydzielono mi zadanie, ale mówi tylko kilka słów, na przykład zrób to tak, jak zostało tam zrobione, bez dołączonej specyfikacji. Jaka jest najlepsza rzecz do zrobienia w takich okolicznościach?


(To jest ogólne pytanie, ale myślę, że jest ważne.) Jak szybko zrozumieć ogromny fragment kodu, powiedzmy, projekt z dziesiątkami tysięcy linijek kodu (napisany przez innych ludzi)? Czy istnieją przydatne narzędzia do analizy źródeł (na przykład wizualizator wykresów połączeń) lub IDE, które mogą być pomocne? Wszelkie techniki są również mile widziane. Dziękuję.


title: Kiedy systemy stają się coraz większe, jak zachować globalne zrozumienie swojego systemu?

text: Dziś boleśnie zdałem sobie sprawę, że do niektórych decyzji potrzebne jest dobre ogólne zrozumienie systemu. W przeciwnym razie ryzyko jest zbyt duże, że twoje założenie okaże się błędne. Wyobraź sobie, że jesteś programistą sklepu internetowego. Aby zrozumieć system, musisz zrozumieć wiele połączonych podsystemów, na przykład: 1. Jak otrzymywać i przetwarzać informacje o produktach od różnych dostawców 2. Jak klient może wyszukiwać i zamawiać produkty w Twoim sklepie internetowym 3. W jaki sposób zamówienia są przetwarzane i zarządzane przez dział obsługi klienta 4. Jak system SAP obsługuje proces fakturowania 5. ... Im większy staje się system, tym więcej musisz zrozumieć. Jeśli tej wiedzy brakuje, we współpracy wyspecjalizowanych zespołów powstawały nieoptymalne rozwiązania. Wyspecjalizowane zespoły, które tylko szczegółowo rozumiały swoją część systemu. Aby poradzić sobie z tym problemem, nasza firma zmieniła strategię, tak aby jeden zespół programistów zawsze był odpowiedzialny za wszystkie aspekty funkcji. Nawet jeśli obejmuje cały łańcuch procesów. (Jest to rodzaj zespołu ds. funkcji, ale nie z zespołów pracujących na różnych podsystemach.) **Jakie są skuteczne strategie dla programistów, aby aktualizować swoją wiedzę o systemie i procesach operacyjnych?** Myślę, że dobra dokumentacja systemu jest kluczem, ale obawiam się, że jest punkt, w którym ludzki umysł nie może skalować się tak szybko, jak wymaga tego system. W pewnym momencie trzeba po prostu, ale takie uproszczone założenia mogą okazać się kosztownymi błędami. Kiedy musisz zaimplementować i utrzymywać kod, wystarczy znać dokładne szczegóły. Jako programista mam obecnie do czynienia z trudnym konfliktem interesów: 1. Muszę poświęcić więcej czasu na zrozumienie naszego systemu i procesu operacyjnego. 2. Muszę rozwijać i utrzymywać nasz kod. Ponieważ czas jest ograniczony, 2) najczęściej wygrywa. W rezultacie w większości zdobywam głębszą wiedzę po drodze, a połowiczną wiedzę z luźnych rozmów. Czy wiesz, jak wielkie firmy, takie jak Amazon, rozwiązują ten problem? Przypuszczam, że żaden człowiek nie jest w stanie zrozumieć tak złożonego procesu i być w stanie wnieść kodu do wielu podsystemów jednocześnie.


title: Mam 200k linijek źle zaprojektowanego kodu, czy bardziej wartościowe będą testy jednostkowe czy integracyjne?

text: Odziedziczyłem dużo źle zaprojektowanego kodu; kod nie ma testów. Wprowadzam testy, zanim podejmę poważny refaktor, ale napotkałem problem z moimi testami jednostkowymi. Problem polega na tym, że przetestuję funkcję jednostkową, a później zdecyduję, że funkcja jest zobowiązaniem. Albo pozbędę się funkcji, albo zmienię jej przeznaczenie. Tak czy inaczej, oryginalna funkcja zniknęła, a testy jednostkowe nie powiodły się. Czy powinienem poświęcić dużo czasu na wprowadzanie testów jednostkowych do projektu, który radykalnie zmienię? Czy te testy jednostkowe nie będą bezużyteczne po gruntownym przeprojektowaniu? Czy testy integracyjne byłyby bardziej wartościowe? Mogę wybrać funkcje programu, o których wiem, że się nie zmienią, i stworzyć kilka testów integracyjnych, aby upewnić się, że rzeczywiście się nie zmienią. Mogę zmienić cały kod funkcji, ale funkcja powinna nadal działać, a testy integracyjne nadal powinny przejść. Wiem, że jest wiele pytań na podobne tematy. Pytam konkretnie o zastosowanie i wartość testów jednostkowych w porównaniu z testami integracyjnymi w niechlujnym, starszym kodzie.


title: Czy powinniśmy kodować pod kątem wydajności czy stabilności?

text: Jest moment, w którym dokonujesz wyborów projektowych i omawiasz je z kierownictwem. W moim przypadku muszę przedyskutować swoje stanowiska i wybory projektowe z kierownictwem wyższego szczebla, ale frustrujące jest to, że kierownictwo dąży tylko do wydajności, podczas gdy myślę, że stabilność jest koniecznością, podczas gdy wydajność można osiągnąć później. Np. Stoimy przed wyborem projektowym, aby wykonać mechanizm odzyskiwania ze względu na brak transakcyjności w niektórych procesach, tj. musimy zagwarantować transakcyjność tych procesów, aby były one kompletne lub cofnąć wprowadzone zmiany w bazie danych. Obecny kod utrudnia to, ponieważ używamy procedur składowanych, które zarządzają własnymi transakcjami. Oznacza to, że jeśli proces wywołuje 3 lub 4 procedury składowane, są 3 lub 4 transakcje i jeśli chcemy procesu odzyskiwania, musimy cofnąć te zmiany (tak, są one w tym czasie zatwierdzone, oznacza to, że musimy wykonać więcej transakcji do bazy danych, aby pozostawić ją w stanie spójnym lub przynajmniej w jakiś sposób „zignorować” te rekordy). Oczywiście chciałem usunąć transakcje z procedur składowanych i zatwierdzić transakcję w kodzie po zakończeniu procesu lub wycofać tam, jeśli proces ma wyjątki. Sprawa jest taka, że kierownictwo uważa, że takie podejście spowolni proces, a także będzie miało duży wpływ na nasz kod. Myślę, że to prawda, ale uważam również, że samodzielne wykonanie procesu przywracania jest po prostu wymyślaniem koła na nowo, podatnym na błędy i IMHO, którego stabilizacja zajmie zbyt dużo czasu. Tak więc, po poprzednim przykładzie, **Jakie podejście mogłoby być najkorzystniejsze w takich przypadkach?** Mam na myśli, że chcę sytuacji Win-Win, ale myślę, że po prostu nie da się na to zgodzić, ponieważ za każdym razem, gdy chcę mówię o tym otrzymuję odpowiedzi typu „powinna być inna droga”, „nie powinieneś mi mówić, że nie ma wyjścia”, „to nie jest faktyczna”, „wydajność ulegnie pogorszeniu” itp. i myślę, że skończę czyniąc ten fałszywy proces odzyskiwania tylko po to, aby był zgodny z zarządzaniem. OTOH mogę się mylić i powinienem robić to, co mi kazano, bez narzekania.


title: Ile kodu złej jakości powinien znosić junior?

text: Jestem młodszym programistą, który od kilku tygodni pracuje w nowej pracy. Pracuję z dużym frameworkiem dla naukowego oprogramowania desktopowego, dodając elementy funkcjonalności. Chociaż istnieją ogólne aspekty pracy, które są atrakcyjne (takie jak ludzie i wynagrodzenie), muszę przyznać, że uważam tę pracę za niewdzięczną i nudną. Czuję się zawiedziony, ponieważ ogólnie lubię programować. Obawiam się, że jeśli "zadowolę się" tą pracą - lub tym stanowiskiem w tej pracy - mogę stracić miłość do programowania. Myślę, że jestem sfrustrowany, ponieważ ciężko jest uzyskać informację zwrotną na temat poprawności mojego kodu, który piszę. Testowanie jednostkowe jest trudne. Testowanie polega na uruchomieniu programu i przejściu przez kod. Nie czuję, że mam mentora. Moje wrażenie co do bazy kodu jest takie, że nie wykorzystuje ona zbyt wiele zasad OOP. (Być może wiele osób, które z nim pracowało, ma większe doświadczenie jako naukowcy niż programiści.) Czy uważasz, że jestem miękki/naiwny/idealistyczny i powinienem kontynuować pracę z tym kodem przez rok lub dwa (i robić bardziej osobiste projekty z boku)? A może uważasz, że powinienem kierować się instynktem i spróbować znaleźć nową pracę, w której będę mógł pracować z kodem wyższej jakości (być może TDD)?


title: Najlepszy sposób na szybkie eksplorowanie/grok projektów open source C/C++?

text: Szukam sugerowanego przepływu pracy do szybkiego pobierania różnych projektów open source c/c++, a następnie inteligentnego nawigowania po źródłach. „Inteligentnie” oznacza możliwość przeskakiwania między zastosowaniami, definicjami, implementacjami określonego symbolu, zarówno w pobranej bazie kodu, jak i nagłówkach przywoływanych bibliotek, być może zainstalowanych w /usr/local lub /System/Frameworks itp. ten kod skoki mogą być napędzane przez etagi, ctags, gnu global, indeksator eclipse CDT, indeksator Xcode, jestem otwarty na wszystko, ale nie mam pojęcia, jakie jest najlepsze rozwiązanie w większości przypadków. Niedługo potem chciałbym zacząć przechodzić przez testy jednostkowe, przykłady, dema w debuggerze, abym mógł lepiej poznać, jak działa kod. Oczywiście nie będzie to możliwe dla każdego projektu.. ale większość projektów, które mam interesują mnie autotools lub cmake - ogólnie nie obchodzi mnie, jakiego IDE (emacs, vim, xcode, eclipse itp.) używam, i nie mam nic przeciwko uruchamianiu debuggera wiersza poleceń - ja po prostu chcesz szybko pobrać projekt C/C++, "wygłupiać się" na poziomie źródłowym, a następnie przejść dalej, jeśli nie jest to interesujące. Moje pytanie jest szczególnie skierowane do faceta lub dziewczyny super hakera, który rutynowo bada kilka różnych dużych projektów C/C++ co kilka dni/tygodni --> jak produktywnie to robisz? (Moje wykształcenie/doświadczenie jest takie, że wiem wystarczająco dużo o narzędziach c/c++, aby uzyskać rzeczy do zbudowania/lub debugowania uszkodzonej kompilacji w kilku różnych systemach operacyjnych, zwykle w ciągu kilku minut, ale może minąć kilka godzin, zanim dotrę do sedna gdzie mogę wziąć duży projekt i przejść do punktu, w którym przechodzę przez przykłady w debuggerze.Mam wrażenie, że dzieje się tak dlatego, że staram się używać nowoczesnych IDE, ale lepiej byłoby po prostu używać narzędzi „starej szkoły” .kiedy mamy do czynienia z rzeczami jvm -- zwykle dość szybko można dostać się do miejsca, w którym można uzyskać intellij do kodu grok i rozpocząć debugowanie -- chciałbym to powtórzyć jak najwięcej w C/C++) dzięki!


title: Jak udokumentować stary kod (skrypty powłoki)?

text: Zaangażowałem się w projekt, w którym przejmujemy część starszego kodu. Kod to w zasadzie skrypty powłoki i pakiety/procedury/funkcje PL/SQL. Nie ma dokumentacji jak działa kod, nie ma też komentarzy do skryptów powłoki. Myślałem, że pierwszą rzeczą do zrobienia jest zrozumienie zależności kodu, jak skrypty wywołują się nawzajem i tak dalej. Czy masz jakieś sugestie, jaki byłby najlepszy sposób na udokumentowanie zależności między skryptami a kodem PL/SQL? Jakie byłoby najbardziej sugerowane narzędzie do tego (być może dla diagramów)?


title: Jak ustalić, czy przepisać źle zaprojektowany kod, czy nie?

text: > **Możliwy duplikat:** > Kiedy BIG Rewrite odpowiedź? Należę do małego zespołu, któremu wręczono kiepsko napisaną, na wpół ukończoną grę Java 2D. Naszym celem jest zrobienie jak najwięcej, aby było lepiej w około 11 tygodni. Jestem prawie pewien, że kod nie jest możliwy do utrzymania i muszę zdecydować, czy powinienem przedstawić pomysł przepisania (w każdym razie w pobliżu przepisania). Na przykład klasa Main, która jest apletem, ma właśnie wrzuconą do niej większość logiki gry. Zdarzenia klawiatury i myszy są obsługiwane za pomocą ogromnych bloków if/else, żaden z nich nie jest skomentowany (jedyne komentarze to sekcje kodu, które zostały zakomentowane), a cały kod rysowania i animacji jest tylko jednym wielkim kawałkiem. Obrazy są ładowane w oddzielnej klasie, która po prostu przechodzi przez każdy plik, każdy w osobnym wierszu, i odczytuje obraz do statycznej zmiennej Image. To wszystko wydaje się kiepskim projektem. Mamy czas do końca semestru, około 11 tygodni, aby uczynić grę lepszą niż jest teraz. Jest grywalna, ale mocno zepsuta w miejscach. Obecnie przydzielono mi małą funkcję do zaimplementowania: klikalne menu główne zamiast tego, które można kontrolować tylko za pomocą klawiatury. Z jednej strony wiem, że jestem w stanie to zaimplementować, ale z drugiej boję się próbować dodawać nowe funkcje, ponieważ a) im więcej dodamy, tym większe prawdopodobieństwo, że program się zepsuje z powodu złych wyborów projektowych i b) tym więcej będę dodawać do bałaganu, który już tam jest. Spędziłem weekend, aby spróbować powielić podstawową funkcjonalność gry z innym projektem (by zobaczyć, czy da się to zrobić wystarczająco szybko). Jestem w stanie ładować i buforować sprite'y, tworzyć elementy gry i przenosić je, a także śledzić stan gry, aby określić, które wejście klawiatury obsłużyć i co narysować na ekranie. Następny na mojej liście był program do ładowania arkuszy sprite (odkryłem, że grafika gry nie jest w arkuszach sprite, ale każdy z nich znajduje się w osobnym pliku). Zaufany przyjaciel powiedział, że być może lepiej będzie utrzymywać stary kod, ale patrząc na niego jest on zbyt kruchy. Moglibyśmy dokonać refaktoryzacji na bieżąco, ale myślę, że to też byłoby trudne. Nasza grupa spotyka się w ten piątek. Planowałem przedyskutować pomysł remontu i przedstawić to, nad czym pracuję, ale teraz nie jestem tego taki pewien. Wydaje mi się, że jest to dość prosta gra Java 2D, w której po złożeniu solidnej podstawy znacznie łatwiej byłoby dodać funkcje, ale musielibyśmy dość szybko przeprojektować kod podstawowy, prawdopodobnie w ciągu dwóch do czterech tygodni lub mniej więcej . Chciałbym myśleć, że możemy to zrobić tak szybko, ale nie jestem do końca pewien. Myślę, że możesz sprowadzić moje pytanie do tego: jak najlepiej określić, kiedy zachować źle zaprojektowany kod, a kiedy poświęcić trochę czasu, zaczynając prawie całkowicie od zera?


title: Szacowanie wysiłków związanych z kodowaniem/rozwojem?

text: > **Możliwy duplikat:** > Jak jest możliwe oszacowanie czasu na projekty programistyczne? Zaprojektowaliśmy interfejs użytkownika (UI) w HTML dla aplikacji intranetowej. Wykonanie go zajęło prawie 30 dni, jak powinniśmy oszacować wysiłek programistyczny (kodowanie) dla niego, czy jest jakiś stosunek, którego możemy użyć do oszacowania, to jest potrzebne nie muszą być dokładne, ale niektóre szacunki mogą pomóc.


title: Co zrobić, gdy dziedziczysz niemożliwą do utrzymania bazę kodu?

text: > **Możliwe duplikowanie:** > Techniki na refaktoryzację śmieci i utrzymanie zdrowego rozsądku? > Odziedziczyłem 200 000 linijek kodu spaghetti -- co teraz? Obecnie pracuję w firmie z 2 innymi programistami PHP oprócz mnie i 1 młodszym programistą. Starszy programista, który pierwotnie zbudował system, nad którym wszyscy pracujemy, zrezygnował i będzie tu tylko przez kilka tygodni. Drugi programista, który jest jedynym facetem, który wie cokolwiek o systemie, jest tu niezadowolony i szuka nowej pracy. Jestem bardzo niebezpieczna, że zostanę w tyle jako jedyny doświadczony programista w tej bazie kodu. Odkąd dołączyłem do tej firmy, starałem się dążyć do lepszych standardów kodowania, dokumentacji projektowej itp. i myślę, że poczyniłem pewne postępy, ale zdecydowana większość kodu jest po prostu nie do utrzymania i niekomentowana. Wiele z tego ma związek z koniecznością szybkiego załatwienia spraw w punktach projektu, zanim dołączyłem, ale teraz dług techniczny jest ogromny, nawet z dwoma programistami, którzy rozumieją system na pokładzie. Bez nich po prostu nie da się z tym nic zrobić. Starszy programista stara się przynajmniej skomentować cały swój kod przed odejściem, ale myślę, że baza kodu jest po prostu zbyt obszerna, aby właściwie udokumentować w pozostałym czasie. Poza tym, kiedy komentuje, to nadal nie wyjaśnia sprawy tak jasno, jak mogłoby. Gdyby system był lepiej zorganizowany i udokumentowany, prawdopodobnie mógłbym zacząć go refaktoryzować stopniowo, ale całość jest tak ściśle powiązana, że bardzo trudno jest wprowadzić jakiekolwiek zmiany w jednym module bez niezamierzonych efektów domina w innych modułach. Oczywiście nie ma też testów jednostkowych i szczerze nie sądzę, że ta baza kodu mogłaby być testowana jednostkowo, biorąc pod uwagę sposób jej implementacji. Wydaje się również, że nigdy nie ma wystarczająco dużo czasu, aby załatwić sprawy, nawet z 3 programistami i 1 młodszym programistą. Mając jednego programistę i jednego juniora, z których żaden nie miał znaczącego wkładu we wczesne projektowanie systemu, nie widzę, jak moglibyśmy cokolwiek zrobić z utrzymaniem obecnego systemu, wdrażając nowe funkcje w razie potrzeby i rozwijając zamiennik dla bieżąca baza kodu, która jest lepiej zorganizowana. Czy mogę podjąć jakieś podejście, aby poradzić sobie z tą sytuacją, czy też powinienem w tym momencie uporządkować własne CV? Gdybym został tylko ja i młodszy projektant, wybrałbym tę drugą opcję prawie bez pytania. Jednak jest też zespół front-endowców i menedżerów treści i martwię się, co by się z nimi stało, gdybym odszedł i umieścił ich w sytuacji, w której nie byłoby programistów w ogóle. W takich okolicznościach departament mógłby zostać całkowicie zamknięty, a wtedy na sumieniu miałbym też ich bezrobocie!


title: Zapoznaj się z nieznanym kodem źródłowym

text: Muszę kontynuować rozwój funkcji, problem z naprawą w połowie ukończonej bazy kodu. Brak dokumentacji, wszyscy programiści opuścili firmę. Stos technologiczny jest mi trochę znajomy (Spring, Hibernate, Web Services (Rest, SOAP), MySQL). Istnieją również nieopisowe elementy JIRA, nad którymi zespół pracował przez ponad 3 lata. Wygląda na to, że kod został zaimplementowany w spójny sposób, taki jak warstwy, plik mrówek na projekt, klasy DAO. Chciałbym otrzymać informację zwrotną od wszystkich naszych ekspertów. Jakie powinno być podejście do zapoznania się z projektem? Czy polecasz używać profilerów, narzędzi do śledzenia błędów, takich jak Sonar, aby uzyskać wskazówki? Jakieś inne podejście, które mogę wypróbować?


title: Czy mogę dokonać „bezpiecznej” refaktoryzacji bez specyfikacji?

text: Od wielu lat odziedziczyłem przestarzałą aplikację internetową, która: * Nie korzysta z zasad zorientowanych obiektowo, nawet jeśli pozwala na to język * Nie ma testów jednostkowych ani żadnego rodzaju zestawu testów, zautomatyzowanych lub nie * Generalnie ignoruje różne ogólne najlepsze praktyki czyniące kod bardzo trudnym do odczytania i utrzymania * Dzieli jego działanie (w tym kod reguł biznesowych) na aplikację internetową, widoki bazy danych i procedury składowane. Część kodu jest nawet eksternalizowana, ponieważ aplikacje zewnętrzne (nie pod moją kontrolą ani moim zespołem) często odczytują _lub zapisują_ bezpośrednio do bazy danych * Ma tylko najświeższą dokumentację (w tym część, którą stworzyłem) * Brak udokumentowanych specyfikacji technicznych lub funkcjonalnych do mów o którymkolwiek * Zmienił zasady tak wiele razy i tak szybko, że nikt tak naprawdę nie wie, jak to ma działać. Reguły są nakładane, gdy codziennie odkrywane są brakujące funkcje lub konkretne przypadki. * Zdarza się, że jest to najbardziej krytyczna dla biznesu aplikacja firmy * Ciągle się rozwija Refaktoryzacja prawie zawsze zawiera główną sugestię dodania testów jednostkowych, aby upewnić się, że niczego nie zepsujesz. Jak to zrobić, kiedy nawet nie wiesz, jak ta rzecz ma działać (i nikt inny nie może ci powiedzieć _na pewno_)? Czy jest to przypadek, w którym musiałbyś wrócić do kwadratu 1 i powoli, iteracyjnie, w miarę zapotrzebowania na nowe funkcje, poprosić o specyfikacje skupione na zmodyfikowanej sekcji i _następnie_ refaktorować, co tam jest? Czy jest inny sposób na poradzenie sobie z tą sytuacją? To pytanie skupia się głównie na braku specyfikacji w opozycji do zasady bezpieczeństwa refaktoryzacji tworzenia testów jednostkowych, aby upewnić się, że zasady są przestrzegane podczas refaktoryzacji. To powiedziawszy, kilka dodatkowych informacji na temat sytuacji poza brakiem specyfikacji: * "Najlepszą" strukturą programistyczną znalezioną w kodzie do tej pory jest funkcja. Zwykle nie są one samowystarczalne i odwołują się do wielu zmiennych globalnych (nawet zmienne lokalne zostały błędnie ustawione jako zmienne globalne, co grozi nieoczekiwanym zachowaniem). Mam wrażenie, że pierwszym krokiem może być refaktoryzacja _this_, aby umożliwić nawet testowanie jednostkowe. * Wymienione kwestie dotyczą całej aplikacji, procedur bazodanowych, a nawet aplikacji siostrzanych. Wszystko przeplata się ze sobą i prawie nigdy przez interfejsy. Nadal można znaleźć * Kod ma tendencję do duplikowania się w różnych miejscach. Dzieje się tak z kodem reguł biznesowych, co oznacza, że możesz uzyskać różne wyniki w zależności od _gdzie_ w aplikacji, którą wywołujesz funkcję. Oczywista złożoność konserwacji i ryzyko.


title: Praca z dużym, niechlujnym obiektem

text: Dostałem bardzo zagracony obiekt „Jeden Pierścień” (jeden obiekt, który rządzi wszystkimi). Klasa OR ma 40 pól. Te pola są mapowane na 16 różnych obiektów (OR ma wszystkie pola z 16 obiektów połączonych razem. Niektóre pola są wspólne dla wszystkich obiektów, inne są unikalne dla poszczególnych obiektów [wszystkie 16 obiektów pochodzą od wspólnego rodzica] ). OR wskazuje na tabelę typu catch-all w zdenormalizowanej bazie danych SQL. Zostałem poproszony o napisanie do tego adaptera, który będzie pobierał losowe instancje 16 obiektów, mapował pola z danego obiektu na instancję OR i wysyłał go po drodze. Oj. Zmiana zaplecza lub kodu nie wchodzi w grę (próbowałem). Jak na pewno nie jest niespodzianką, ta bestia to paskudna rzecz do zarządzania. Chciałbym usłyszeć kilka przemyśleń na temat sposobów, aby praca z tym była łatwiejsza w zarządzaniu. Zajmuję się przede wszystkim utrzymaniem kodu: zrozumieniem i czytelnością. Wiem, że cokolwiek zostanie zaimplementowane, będzie dalekie od ideału, ponieważ zasadniczo staram się, aby śmieci wyglądały ładnie. To powiedziawszy, na razie muszę z tym żyć, więc staram się, aby moja strona wraku pociągu była trochę bardziej znośna.


title: Jak edukować menedżerów biznesowych w zakresie złożoności dodawania nowych funkcji?

text: Utrzymujemy aplikację webową dla klienta, który wymaga dodawania nowych funkcji w zawrotnym tempie. Zrobiliśmy co w naszej mocy, aby nadążyć za ich wymaganiami, w wyniku czego baza kodu wzrosła wykładniczo. Obecnie jest tak wiele modułów, podsystemów, kontrolerów, bibliotek klas, testów jednostkowych, interfejsów API itp., że za każdym razem, gdy dodajemy nową funkcję, zaczyna zabierać więcej czasu. Musieliśmy również wciągnąć do projektu dodatkowe osoby, które przejmą takie rzeczy, jak kontrola jakości i przygotowanie, aby główni programiści mogli skupić się na rozwoju. Niestety, klient denerwuje się, że koszt każdej nowej funkcji rośnie. Wydaje się, że spodziewają się, że będziemy mogli dodawać nowe funkcje _ad infinitum_, a koszt każdej funkcji pozostanie liniowy. Wielokrotnie próbowałem im tłumaczyć, że to nie działa w ten sposób – że baza kodu rozszerza się fraktalnie w miarę dodawania tych wszystkich funkcji. Wyjaśniłem, że najlepszym sposobem na obniżenie kosztów jest rozważenie, które nowe funkcje są naprawdę potrzebne. Ale albo nie rozumieją, albo myślą, że ich spuszczam. Po prostu przewracają oczami i wpadają w złość. Wszyscy są całkowicie nietechniczni i nie mają pojęcia, co robi z pisaniem oprogramowania. Czy mogę to wyjaśnić językiem biznesowym, który pomoże im lepiej zrozumieć? Czy są jakieś wizualizacje, które ilustrują wzrost bazy kodu w czasie? Jakieś inne sugestie dotyczące postępowania z tym klientem?


title: Kolejne kroki w rozwoju nowego produktu

text: Zostałem zatrudniony około rok temu jako główny (no cóż, naprawdę jedyny) programista nad nowym projektem/produktem, który nazwiemy produktem „B”. Produkt B został zaprojektowany w celu zdobycia nowego rynku dla firmy. Ta firma odniosła wielki sukces z podobnym produktem na inny rynek. Ten inny produkt nazwiemy „A”. „A” ma już prawie 5 lat i jest niezawodny. Te dwa rynki niekoniecznie nakładają się na siebie, ale wiele podstawowych funkcji w A można przeznaczyć do pracy dla B. Mój termin, by podążać za tym nowym rynkiem dla produktu B, był dość agresywny. Musieliśmy szybko zademonstrować potencjalnym klientom pewne możliwości i pokazać im, że jesteśmy poważnym konkurentem na nowym rynku. Aby przyspieszyć rozwój, wybraliśmy najkrótszą drogę do stworzenia nowego produktu. Zaczęliśmy od głębokiej kopii (gałęzi) produktu A firmy i zmieniliśmy go na B. Takie podejście miało sens, biorąc pod uwagę ograniczenia czasowe, ponieważ odziedziczyliśmy za darmo wiele nakładających się podstawowych funkcji i infrastruktury. Usunęliśmy wiele funkcji i opcji, które nie miały zastosowania, pozostawiliśmy niektóre rzeczy, które zostały przeniesione, i dodaliśmy kilka nowych funkcji, które były potrzebne do zabezpieczenia tych klientów. To nie było idealne przejście, ale było wystarczająco dobre. Produkt B istnieje już od około roku i wszystko wygląda dobrze, ponieważ pozyskaliśmy dwóch klientów z kilkoma potencjalnymi klientami na horyzoncie. Jakie są następne kroki? Z perspektywy „najlepszych praktyk” dalsze rozwijanie produktu B jako kopii produktu A nie wydaje się dobrą strategią. Nie jest to solidna podstawa do zbudowania nowego produktu. Cel bezpośredni osiągnęliśmy tworząc „produkt” i demonstrując go potencjalnym klientom. Czy nie powinniśmy teraz zrobić kroku wstecz, dowiedzieć się, czego naprawdę chcą użytkownicy i udoskonalić nasz projekt? Naprawdę nie mamy „nowego produktu”. Stworzyliśmy trochę „vaporware” dla kilku instalacji demonstracyjnych. Niestety odnoszę wrażenie, że kierownictwo uważa, że mamy nowy produkt do opracowania i sprzedaży, a nie ma czasu na krok wstecz, refaktoryzację i udoskonalenie. Po co mielibyśmy tracić czas i pieniądze na przeprojektowywanie, skoro mamy już coś, co możemy wykorzystać i sprzedać? Oto moje problemy: * Ponieważ został utworzony z kopii A, baza kodu produktu B jest zaśmiecona artefaktami i „długiem technicznym” z produktu A. Część tego kodu jest już nieosiągalna. Część tego kodu jest osiągalna, ale być może logika biznesowa nie ma sensu w przypadku produktu B. Na przykład mogą istnieć wyszukiwania w pustych tabelach w bazie danych lub sprawdzanie elementów, które nie istnieją. Ten rodzaj logiki nie tylko szkodzi wydajności, ale także koszmarem konserwacji. Szacuję, że faktycznie wykorzystujemy 35% bazy kodu produktu A, a reszta to bagaż. * Kierownictwo uważa, że mądrze było utworzyć B z kopii A: „Zaoszczędzi to pieniądze, ponieważ kod można ponownie wykorzystać między produktami”. Jeśli błąd został naprawiony w A, dlaczego nie można go połączyć z B? Lub jeśli opracuję nową funkcję w B, dlaczego nie można jej połączyć z A? Ten argument jest błędny. Chociaż B zostało stworzone z A, zostało to zrobione ponad rok temu, a A ma dedykowany zespół z 4 programistami. Jestem sam na produkcie B. Gałąź kodu dla A nadal odbiega od B. Teraz bardzo trudno jest cokolwiek scalić. * Na koniec czuję, że nałożyliśmy na siebie niepotrzebne ograniczenia, zaczynając od produktu, który ma już 5 lat. Niektóre aspekty zostały zaprojektowane bardzo słabo i bez wątpienia spowodują te same problemy z nową bazą użytkowników. Wyciągnijmy nasze wnioski i wykorzystajmy tę okazję, aby ulepszyć projekt zamiast kopiować bzdury. Korzystajmy też z nowych technologii tam, gdzie ma to sens – w ciągu 5 lat wiele się zmieniło! Jak przekonać kierownictwo, że musimy udoskonalić nasz produkt – najprawdopodobniej od podstaw? Mój szef myśli w kategoriach czasu i pieniędzy, i czuję, że przegram tę debatę, jeśli nie będę ostrożny. Czy tego rodzaju wysiłek można określić ilościowo i przełożyć na warunki zarządzania? Czytałem na temat „wschodzącego projektu” i staram się podejść do mojego argumentu pod kątem tego, że nie musimy dostarczać wszystkiego na raz. Skupmy się na małych fragmentach działającego kodu o największej wartości biznesowej.


title: Jak pisać dobre oprogramowanie podczas nauki języka?

text: Krótkie informacje: Jestem na zaawansowanym kursie C++ w ramach programu studiów za granicą. Problem polega na tym, że nie mam żadnego doświadczenia w C++. Mam skromne wykształcenie C, ale zaczynam myśleć, że mam więcej luk w swojej wiedzy, niż sądziłem. Mój problem polega na tym, że piszę teraz naprawdę gówniany kod, ale uniwersytet ma automatyczny system testowania, który zawsze w jakiś sposób mnie zaskakuje: czy twój kod spełnia wszystkie testy automatyczne (bez punktów, jeśli nie), czy używałeś naiwne rozwiązanie pod względem czasu lub miejsca (dostajesz za to mniej punktów), czy masz JAKIEKOLWIEK błędy pamięci (zazwyczaj brak punktów, jeśli tak). Więc moje pytanie brzmi, co robisz podczas tworzenia, co prowadzi do weryfikowalnych, zintegrowanych wyników? Czy jest lepszy sposób na naukę i rozwój, żebym nie zawsze skręcał w zakręty z funkcjami C/C++? Zamierzam opracować dla siebie metodę inżynierii oprogramowania, w której mogę uzyskać pełne punkty za te prace domowe w mniej niż 10 godzin tygodniowo (obecnie spędzam 15 godzin i nie otrzymuję pełnych punktów).


title: Co mogę zrobić, aby zachować szacunek dla źle napisanej bazy kodu?

text: W mojej pracy muszę utrzymywać kiepsko napisany kod, który jest trudny do zrozumienia, ma mnóstwo komentarzy, które są po prostu błędne, ma mnóstwo dziwnych decyzji i wiele więcej. Zajmuję się przede wszystkim naprawianiem błędów, które rozciąga się od znalezienia tego małego komentarza gdzieś w kodzie, który sprawia, że jakaś losowa część nie działa, do zrozumienia złożonych zależności kołowych z jakimś rodzajem singleton'a'palooza, a czasami faktycznie piszę prawdziwy kod , czyli wtedy, kiedy jestem najszczęśliwszy. Ale obawiam się, że wiedźma naprawiająca błędy, którą muszę przyznać, wiele razy kończy się byciem niechlujnym patchworkiem, ponieważ nie mam już czasu ani siły psychicznej, aby patrzeć na ten przerażający kod. Teraz największym problemem tego projektu nie jest to, że jestem tylko marudnym facetem, z całą pewnością nie jestem osamotniony w wyżej wspomnianych sentymentach do bazy kodu. Największym problemem są chyba koszty jego utrzymania... Ale dygresję. Zastanawiam się, czy istnieją pewne praktyki, które ja i moi koledzy możemy wypróbować, aby odzyskać szacunek dla odziedziczonej przez nas bazy kodu i pracujemy tak, abyśmy nie podążali ścieżką tworzenia większej gnicia kodu?


title: Dziedziczenie projektów – zasady ogólne?

text: > **Możliwy duplikat:** > Kiedy BIG Rewrite odpowiedź? > Alternatywy dotyczące przepisywania oprogramowania > Czy istnieją rzeczywiste studia przypadków dotyczące przepisywania sukcesów/porażek oprogramowania > wskaźników? > Kiedy powinieneś przepisać? > Nie jesteśmy firmą programistyczną. Czy całkowite przepisanie to nadal zły pomysł? > Czy kiedykolwiek brałeś udział w BIG Rewrite? Jest to obszar dyskusji, który od dawna mnie ciekawi, ale ogólnie brakuje mi doświadczenia, aby udzielić sobie odpowiedzi, której w pełni zaufam. Wszyscy tam byliśmy, pojawia się nowy klient z na wpół ukończonym projektem, który chcą ukończyć i uruchomić. Z jakiegoś powodu zwolnili swojego poprzedniego programistę i teraz od Ciebie zależy, czy uratujesz sytuację. Właśnie kończę przegląd kodu dla nowego klienta i według mnie lepiej byłoby wyrzucić to, co poprzedni programiści zbudowali od tego czasu i zacząć od zera. Jest mnóstwo powodów, dla których skłaniam się w ten sposób, ale nadal mnie to denerwuje, ponieważ klient nie będzie chciał słyszeć „ci ostatni faceci zbudowali ci wielką kupę i mogę ją albo wypolerować, albo rzucić w śmieciach". Jakie są twoje ogólne zasady przyjmowania tych projektów? Jak ustalisz, czy lepiej zacząć od zera, czy kontynuować z istniejącą bazą kodu? Jakie inne dodatkowe kroki możesz podjąć, aby pomóc kontrolować oczekiwania klientów, ponieważ poprzedni deweloper mógł zawyżyć te oczekiwania ponad rozsądny poziom? Jakieś inne ogólne porady?