Jeśli dopiero co zapoznałeś się z nowym projektem, czego szukasz, aby dowiedzieć się, jak on działa?
Czy szukasz najpierw projektu? Jeśli jest projekt, czego w nim szukasz? Diagramy klasowe, diagramy wdrażania, diagramy sekwencji czy coś jeszcze?
A może idziesz od razu po kod? Jeśli tak, to jak rozumiesz, w jaki sposób poszczególne warstwy oddziałują?
Odpowiedzi:
Zaczynam od kodu. Oddzielne dokumenty projektowe, jeśli takie istnieją, mogą być tak samo błędne lub błędne, jak nie. Zacznę więc od prześledzenia prostego przepływu kodu; jeśli jest to aplikacja internetowa, może to być na przykład żądanie lub sekwencja żądań. Kiedy to zrobię, mam rodzaj szkieletu, na którym można lepiej zrozumieć. Następnie mógłbym wrócić i przeczytać projekty lub inną dokumentację, ale w tym momencie mam coś konkretnego, z czym mogę je powiązać i zweryfikować, dzięki czemu mogę wykryć informacje duff. Albo mogę po prostu czytać kod, testować przypadki itp.
Zaczynałbym na wyższym poziomie. Jeśli jest jakaś dokumentacja skierowana do użytkownika - instrukcja obsługi lub przewodnik. Jeśli to nie wystarczy, przejrzyj specyfikację wymagań, abyś miał pojęcie, co oprogramowanie ma zrobić. Chciałbym wtedy spojrzeć na projekt i spróbować zmapować go na pliki kodu. Mam nadzieję, że są one uporządkowane w foldery w rozsądny sposób. Następnie wybrałem część projektu i przejrzałem pliki, aby śledzić przepływ kodu bez zbytniego zagłębiania się w najdrobniejsze szczegóły.
Zaczynam od skonfigurowania systemu programistów. Korzystam z udokumentowanej procedury. To pozwala kotowi wyjść z torby na temat synchronizacji dokumentacji z rzeczywistością.
Mówi mi także o zależnościach. To ma znaczenie
Teraz, gdy mam konfigurację dla programistów, (i zaznaczam dokument instalacyjny z poprawkami, gdy idę), buduję wersję. Na tym etapie zadaję pytania.
Teraz został zbudowany, wykonuję ćwiczenie wprowadzające z instrukcji obsługi. To z grubsza mówi mi, co naprawdę robi system.
Teraz mam częściową wskazówkę dotyczącą systemu, czytam dokumenty projektowe, które teraz uważam proporcjonalnie do tego, jak błędne były dotychczas dokumenty.
Po przejściu do faktycznej dokumentacji behawioralnej mogę zacząć przeglądać kod i sprawdzać, co naprawdę tam jest. Nigdy nie ustawiają się w szeregu, ale teraz wiem, w co wierzyć.
Następnie patrzę na dane wyjściowe IDE dla komentarzy „todo” i „fixme”. Takie rzeczy jak „poprawka w wersji 2.0” również są wskazówkami.
Chodzi o to, aby nauczyć się prawdziwości, a jak zauważają ludzie, oddzielne dokumenty projektowe rzadko są aktualne lub poprawne, ale informują o tym, co ludzie myśleli w danym momencie. I oczywiście tych ludzi prawdopodobnie nie ma w pobliżu, aby przesłuchać.
Wolę zacząć od projektu, aby uzyskać przegląd projektu i spróbować zrozumieć niektóre z jego kluczowych funkcji i / lub struktury, zanim przejdziemy do szczegółów.
Zawsze projekt. Z kodem warto przejść przez etapy konfiguracji programisty (sprawdzenie źródła, zbudowanie projektu, wprowadzenie wymaganych zmian w konfiguracji), ale nie ma sensu uczyć się struktury aplikacji na podstawie kodu. To tylko mówi ci, jaka jest struktura, a nie dlaczego jest to, co inni deweloperzy uważają za najważniejsze i złe strony architektury. Te, których uczysz się ze schematów i czatów na tablicy z programistami.
W przypadku złożonego oprogramowania podchodziłbym do niego mniej więcej tak, jakby był to nowy projekt programistyczny. Zacznij od wielkich pomysłów - wizji, kontekstu, zakresu i interesariuszy. Przeczytaj dokumentację użytkownika i dowiedz się, jak z niej korzystać. Przeprowadź szkolenie użytkowników w zakresie oprogramowania, jeśli to możliwe (lub dotyczy). Następnie zacznij przeglądać wymagania i dokumentację projektową, aby dowiedzieć się, jak to działa na wysokim poziomie. Porozmawiaj z projektantami, jeśli nadal są w pobliżu. Spójrz na architekturę systemu z różnych perspektyw. Stamtąd zacznij zagłębiać się w podstawową funkcjonalność i przeglądać trochę kodu, wracając do wymagań i projektu w razie potrzeby. Patrząc na kod, uruchom oprogramowanie, aby zobaczyć, jak działa. Przez cały czas kompiluj dokumentację podsumowującą do wykorzystania w przyszłości - jesteś właścicielem Cliffs Notes. Rozgałęziaj się, aż będziesz miał całkiem dobry pomysł, jak to wszystko działa i pasuje do siebie, ale skoncentruj się na częściach, z którymi będziesz pracować. Do tej pory masz kompleksowe zrozumienie całego systemu lub przynajmniej części, które mają zastosowanie do Ciebie.
Oczywiście w prawdziwym świecie możesz nie mieć czasu, aby przejść przez to wszystko, zanim zaczniesz brudzić sobie ręce, szczególnie przy większych projektach. Ale tak bym to zrobił, gdyby to zależało ode mnie.
Powinieneś pracować w tę iz powrotem między samym kodem a wszelkimi dokumentami projektowymi.
Możesz zacząć od kodu lub projektu, a to naprawdę nie ma znaczenia. Czytaj kod, aż poczujesz się dobrze i naprawdę zdezorientowany, a następnie sprawdź dokumentację projektową. Lub przeczytaj dokumentację projektową, aby uzyskać obraz wysokiego poziomu, a następnie spójrz na kod, aby zobaczyć, jak to wygląda. Powtarzaj prawie w nieskończoność, dopóki pracujesz z kodem.
Pamiętaj, że dokumenty projektowe są prawie zawsze nieaktualne i na wiele sposobów niepoprawne. Jednak o ile pamiętasz o tych kwestiach, nieaktualne dokumenty nadal pomagają zrozumieć umysł autora w pewnym momencie w przeszłości. Wiele problemów i problemów na wysokim poziomie będzie nadal aktualnych, a najprawdopodobniej będziesz w stanie szybciej zrozumieć, w jaki sposób kod dotarł tam, gdzie jest, jeśli nawet datujesz zdjęcie, w którym autor początkowo myślał, że zamierza udać się.
Podczas pracy nad kodem i projektem utwórz własne dokumenty opisujące twoje rozumienie kodu dzisiaj. Może te dokumenty są prostym szkicem lub dwoma, może są napisane na wiki, może są czymś innym. Nie komplikuj ich zbytnio: brak 30-stronicowych dokumentów tekstowych. Po prostu spuść swoje pomysły, co znacznie wyjaśni twoje myślenie.
To zależy od rodzaju aplikacji. Jeśli jest to aplikacja skoncentrowana na danych, zwykle zaczynam od projektu bazy danych. Jeśli ma interfejs użytkownika, który można uruchomić (lub dobre projekty ekranów), mogą one również dać ci dobry pomysł na to, co robi aplikacja bardzo szybko (mówię tutaj najwyżej kilka godzin). Potem zacznę kopać w kodzie i będzie to miało większy sens, ponieważ wiem, co robi aplikacja.
Zaczynam od dokumentacji projektowej. W szczególności specyfikacja - która określa cel rzeczy, na którą patrzymy.
Jeśli to możliwe, przeglądam notatki projektowe i dokumentację, aby uzyskać ogólny obraz tego, jak zostało to zrobione, procesu myślowego, stylu i charakteru zainteresowanych osób.
Jeśli to możliwe, rozmawiam z ludźmi, którzy nad tym pracowali - co robi? W jaki sposób? Dlaczego? Gdzie są pochowane ciała?
Deweloperzy mają tendencję do przeskakiwania do kodu: „Pozwól, że pokażę ci ten kod”. Jest to dla nich w porządku, ale ma tendencję do przejmowania moich potrzeb - czyli rozumienia wysokiego poziomu, który nadaje kontekst elementom niskiego poziomu.
Wykorzystuje ogromną ilość mocy mózgu, aby spojrzeć na małe fragmenty kodu, poza pełnym kontekstem i zrozumieć wszystko, co ma znaczenie. Jeśli to możliwe, zachęcanie programistów do mówienia o ZASADIE, strukturze, jednostkach, modułach i wszystkim innym, co prowadzi do uznania tego zadania.
Tylko wtedy warto spróbować dostać się do kodu.
W dużym schemacie rzeczy patrzenie na kod przypomina patrzenie na stronę pełną zer i jedynek. Ma znaczenie, ale jego zrozumienie zajmuje dużo czasu. Uzyskanie smaku tego, gdzie szukać i które części są znaczące, pomaga zawęzić przestrzeń wyszukiwania.
Wszystko to powiedziawszy - kiedy nie ma doco, nie ma ludzi, a jedynie kod - nie ma nic innego, jak tylko spojrzeć na kod.
W takim przypadku zwykle nie próbuję zrozumieć tego przez powolne, głębokie czytanie, robię szybkie podanie, przeglądam wszystko. Czasami są to tylko otwarte pliki i siedzą po naciśnięciu klawisza przewijania w dół. Dzięki temu możesz uzyskać niesamowite uznanie dla dużego obrazu. (W niektórych przypadkach nawet zrzucam pliki wykonywalne i przeszukuję je, szukając podpisów i wzorów. To było niesamowicie owocne w ciągu ostatnich 20 lat.)
Zaczynam od testów. Jeśli testy jednostkowe i testy integracyjne są dobrze napisane, opisują przypadki użycia. Jeśli nie są dobrze napisane lub wcale nie są napisane (niestety, w dużej mierze tak jest), zaczynam od punktów wejścia w kodzie i dopasowuję je do projektu.
Następnie napiszę testy dla każdego przypadku użycia odkrytego przez drzewo, które znajdziesz po zbadaniu punktów wejścia, aby zbadać kod i użyć narzędzi do pokrycia kodu, aby zobaczyć to, czego mi brakuje. Testy te mówią mi dokładnie, jak działa kod.
Zawsze staram się dodawać wartość do czegoś, na co patrzę; pisanie testów, czyszczenie kodu, refaktoryzacja dużych (ponad 20 linii) funkcji.
Uważam, że samo tworzenie dokumentacji nie dodaje żadnej prawdziwej wartości do kodu, ponieważ nigdy nie wchodzi w interakcje z kodem.
co to jest „projekt”? CZYTNIK? schemat uml? możesz zrobić dokument projektowy w połowie (a większość robi), nie możesz kodować w połowie
każdy projekt będzie po prostu opinią , podczas gdy kod jest faktem
będę odnosić się do dokumentów wtórnych tylko wtedy, gdy nie będę w stanie zrozumieć uzasadnienia kodu
czytanie kodu jest niezbędną umiejętnością dla programisty. równie dobrze możesz się tego teraz nauczyć, i tak nie zobaczysz żadnej przydatnej dokumentacji podczas swojej kariery
Następnie patrzę na programista README, TODO i Changelog. Jeśli nie rozumiem, dlaczego oprogramowanie zostało napisane, jak zostało napisane i dokąd zmierza ... nie używam go.
Jeśli chcesz, najpierw projektuj, a potem koduj, z góry na dół, więc rozumiem kontekst na każdym poziomie, na którym muszę pracować.
Ale jeśli muszę dokonać bardzo konkretnej zmiany, takiej jak naprawienie raportu lub obliczenia, po prostu idę do kodu.
Mówiąc dokładniej, moje podejście „najpierw projekt” jest takie:
Zaczynam od modelu de domain, jeśli taki istnieje, jeśli go nie ma, buduję przynajmniej podstawowy (dobrym punktem wyjścia jest model danych). Definiuje „glosariusz” aplikacji i relację między obiektami (klasami).
Obrazuje „które obiekty są obsługiwane” przez aplikację.
Następnie szukam modelu przypadku użycia, aby dowiedzieć się „jakie procesy są wykonywane” przez aplikację, chociaż wolę mapę procesu, jeśli jest taka, która pokazuje sekwencje procesów.
Potem powinienem mieć ładny obraz aplikacji, a potem mogę zająć się projektowaniem zmiany.
Nawiasem mówiąc, powyższa odpowiedź dotyczy kontekstu aplikacji biznesowych.
Kod nie kłamie. Z pewnością dobrym pomysłem jest zapoznanie się z projektem, aby najpierw zrozumieć, co on robi. Jeśli jednak Twoim zadaniem jest szczegółowe zrozumienie działania projektu, patrzenie na kod, przynajmniej dla mnie, jest jak przeglądanie puzzli kawałek po kawałku, z tym wyjątkiem, że z każdą klasą, na którą patrzysz, dodajesz kolejną kawałek układanki. Jeśli kod jest dobrze skonstruowany, możesz zobaczyć wzorzec tworzący się z nazw klas, nawet nie badając, co robi klasa. W wielu przypadkach możesz uzyskać wskazówki i wskazówki z kodu, które pomogą ci dalej.
Wreszcie masz niezaprzeczalne wyobrażenie o tym, co robi program - ukończoną układankę. Dokumentacja może być niekompletna lub niedokładna, ale kod nigdy nie kłamie. Wszystko to możesz zrobić bez zastanawiania się, co robi każda metoda. Nie każdy może dowiedzieć się o projekcie w ten sposób, ale jeśli robisz to często, przychodzi ci łatwiej, nie wspominając o tym, że można uzyskać sedno średniej wielkości aplikacji w ciągu kilku godzin nauki. Chociaż przypuszczam, że wszystko sprowadza się do preferencji.
Po tym, jak zobaczę kod najbardziej krytycznego modułu / punktu aplikacji: widząc kod, mogę zweryfikować poprawność projektu.
Przykład:
Musisz pracować w zarządzaniu aplikacjami aplikacji internetowej na temat sprawozdawczości finansowej.
Po przeczytaniu kodu o wiadomości, aplikacji początkowej i końcowej (dla prawdopodobnej blokady w db), głównym procesie tworzenia danych, które należy zgłosić itp. Itp. (Na przykład w przypadku przechowywania gazu proces główny dotyczy obliczanie zapasów gazu w obszarze magazynowym odbiorców wraz z dostawą i zatłaczaniem; procesem wtórnym jest fakturowanie tych danych wcześniej obliczonych)
Ani kod, ani projekt. Lubię rozmawiać z interesariuszami i użytkownikami końcowymi oraz dowiedzieć się, jak to działa z ich perspektywy. Kiedy już mogę stworzyć z nich zdjęcie, rzuciłem okiem na projekt techniczny, a następnie na kod.
Najpierw zajmę się projektowaniem, a następnie kodem jednocześnie. Jest to bardzo ważne, ponieważ każdy projekt jest inny. Musisz wyjść z planem i wysokim poziomem przepływu pracy procesów od A do Z, zanim będziesz mógł rozpocząć pracę nad kodami jednocześnie. Każda podjęta decyzja musi być udokumentowana, aby inne zespoły (lub ty), które opracowują / opracowują kody, znały najnowszą aktualizację i to, co zostało potwierdzone.
Jeśli istnieje dobry dokument projektowy na wysokim poziomie, skorzystam z niego. Musi być zwięzły i aktualny. Jeśli jest zbyt szczegółowe lub nieaktualne, udam się do kodu.
Oczywiście zależy to od projektu, prawda? Do bardzo złożonego lub różnorodnego projektu można być może lepiej podejść poprzez dokumentację (jeśli dokumentacja jest wystarczająco solidna).
Pojedynczy prosty moduł lub prosta aplikacja jest moim zdaniem prawie zawsze najlepiej dostępna na poziomie kodu.
Nie ma właściwej odpowiedzi na każdą sytuację!