{"id":1238,"date":"2020-11-17T14:03:46","date_gmt":"2020-11-17T14:03:46","guid":{"rendered":"https:\/\/www.juniorjavadeveloper.pl\/?p=1238"},"modified":"2023-06-07T11:41:40","modified_gmt":"2023-06-07T11:41:40","slug":"stop-zanim-zaczniesz-pisac-kod-zastanow-sie-co-chcesz-kodowac-analiza-projekt-i-implementacja","status":"publish","type":"post","link":"https:\/\/www.juniorjavadeveloper.pl\/en\/2020\/11\/17\/stop-zanim-zaczniesz-pisac-kod-zastanow-sie-co-chcesz-kodowac-analiza-projekt-i-implementacja\/","title":{"rendered":"Stop! Zanim zaczniesz pisa\u0107 kod zastan\u00f3w si\u0119, co chcesz kodowa\u0107? Analiza, projekt i implementacja"},"content":{"rendered":"

W tym artykule postaram si\u0119 pokaza\u0107 jak unika\u0107 b\u0142\u0119du, kt\u00f3ry pope\u0142niaj\u0105 programi\u015bci podczas pisania kodu aplikacji, nawet tego najmniejszego i najprostszego kodu. B\u0142\u0119dem tym jest brak zastanowienia si\u0119, co tak na prawd\u0119 chcemy kodowa\u0107. Samemu nieraz pope\u0142ni\u0142em ten b\u0142\u0105d. Mo\u017cesz mi wierzy\u0107, albo i nie, ale nawet nad jednym, prostym fragmentem kodu mo\u017cna zmarnowa\u0107 wiele godzin, je\u017celi wcze\u015bniej nie zastanowimy si\u0119, co on ma robi\u0107.<\/p>\n\n\n\n

Wszystko zaczyna si\u0119 od zadania, pomys\u0142u, kt\u00f3ry mamy do wykonania zimplementowania. Poka\u017c\u0119 spos\u00f3b, kt\u00f3ry stosuj\u0119 na co dzie\u0144 podczas tworzenia oprogramowania. Praktyczne zastosowanie poni\u017cszego sposobu mo\u017cna znale\u017a\u0107 w moim artykule Od czego zacz\u0105\u0107 tworzenie aplikacji? \u2013 Przesta\u0144 pisa\u0107 kod \u017ar\u00f3d\u0142owy \u2013 praktyczny przyk\u0142ad<\/a>.<\/p>\n\n\n\n

Spos\u00f3b, kt\u00f3ry stosuj\u0119 sk\u0142ada si\u0119 z trzech prostych krok\u00f3w:<\/strong><\/p>\n\n\n\n

    \n
  1. Analiza<\/strong> – pozwala g\u0142\u0119biej zastanowi\u0107 si\u0119 nad tym, co zamierzamy kodowa\u0107 oraz spisa\u0107 nasz\u0105 wizj\u0119 tworzonego oprogramowania, aplikacji.<\/li>\n\n\n\n
  2. Projekt<\/strong> – systematyzuje i dokumentuje informacje uzyskane podczas procesu analizy, kt\u00f3re p\u00f3\u017aniej mo\u017cna wykorzysta\u0107 do implementacji.<\/li>\n\n\n\n
  3. Implementacja<\/strong> – poprzedzona analiz\u0105 i projektem nie jest ju\u017c chaotycznym zbiorem kodu oprogramowania, kt\u00f3ry trzeba cz\u0119sto modyfikowa\u0107.<\/li>\n<\/ol>\n\n\n\n

    Nie nale\u017cy zra\u017ca\u0107 si\u0119 widz\u0105c takie poj\u0119cia jak analiza i projekt, bo pod tymi poj\u0119ciami w moim przypadku kryj\u0105 si\u0119 proste metody i rozwi\u0105zania.<\/em><\/p>\n\n\n\n

    Ad. 1. Analiza – Dlaczego analiza jest taka wa\u017cna?<\/strong> Dzi\u0119ki niej mo\u017cemy spojrze\u0107 na tworzone oprogramowanie z szerszej perspektywy, co pozwoli nam dok\u0142adniej zrozumie\u0107 tworzony kod. Analiza pozwala nam dowiedzie\u0107 si\u0119, co tak naprawd\u0119 ma realizowa\u0107 tworzone oprogramowanie. Przeprowadzam analiz\u0119 tak, aby nie uton\u0105\u0107 w morzu “dokumentacji”. Kt\u00f3ra, to z za\u0142o\u017cenia jest nieaktualna w momencie jej tworzenia, bo jedyn\u0105 sta\u0142\u0105 w programowaniu jest zmiana kodu. <\/p>\n\n\n\n

    Dla analizy r\u00f3wnie\u017c mam kilka krok\u00f3w do wykonania:<\/p>\n\n\n\n

      \n
    1. Opis w formie tekstu, spisanego np. w notatniku.<\/li>\n\n\n\n
    2. Wybranie rzeczownik\u00f3w i czasownik\u00f3w z opisu.<\/li>\n\n\n\n
    3. Karty CRC – Class Responsibility Collaborators.<\/li>\n<\/ol>\n\n\n\n

      Ad. 2. Projekt – Nawet najprostszy projekt <\/strong>pozwala unikn\u0105\u0107 du\u017cej ilo\u015bci refaktoryzacji<\/a> kodu. Oczywi\u015bcie wsp\u00f3\u0142czesne IDE<\/a> (Integrated Development Environment) wspiera i automatyzuje proces refaktoryzacji, ale po, co dodawa\u0107 sobie wi\u0119cej pracy? Dodatkowo projekt poka\u017ce zale\u017cno\u015bci mi\u0119dzy elementami tworzonego oprogramowania, co pozwoli z wyprzedzeniem np. podzieli\u0107 aplikacj\u0119 na warstwy i\/lub modu\u0142y.<\/p>\n\n\n\n

      Dla projektu r\u00f3wnie\u017c mam kilka krok\u00f3w do wykonania:<\/p>\n\n\n\n

        \n
      1. Diagram klas w UML.<\/li>\n\n\n\n
      2. Makiety GUI.<\/li>\n\n\n\n
      3. Lista end-point’\u00f3w REST i\/lub API.<\/li>\n<\/ol>\n\n\n\n

        Ad. 3. Implementacja – W trakcie implementacji u\u017cywam<\/strong> TDD<\/a> (Test Driven Development) prawie dla ca\u0142ego kodu. Dlaczego TDD? Na pocz\u0105tku, jak zaczynamy implementowa\u0107 metody z naszego diagramu klas UML, to nie wiemy jak dok\u0142adnie b\u0119dzie dzia\u0142a\u0107 dana metoda. Wtedy nale\u017cy zadeklarowa\u0107 metod\u0119, a implementacj\u0119 dodawa\u0107 podczas tworzenia i rozwijania test\u00f3w jednostkowych.<\/p>\n\n\n\n

        To tyle teorii, teraz czas na praktyczne wykorzystanie przedstawionej wiedzy. M\u00f3g\u0142bym napisa\u0107 du\u017co wi\u0119cej teorii, ale chc\u0119 pokaza\u0107, \u017ce proces jest na prawd\u0119 bardzo prosty, a jego praktyczne zastosowanie daje bardzo dobre rezultaty.<\/em><\/p>\n\n\n\n

        \n\n\n\n

        Praktyczne wykorzystanie trzech krok\u00f3w:<\/strong>
        Analiza, Projekt i Implementacja.<\/strong><\/p>\n\n\n\n

        Zacznijmy od pocz\u0105tku, dostajemy “proste” zadanie, zaimplementowanie systemu do przechowywania notatek<\/strong>. Nale\u017cy pami\u0119ta\u0107, je\u017celi zadanie by\u0142oby “proste”, to mo\u017cna by by\u0142o rozwi\u0105za\u0107 je za pomoc\u0105 kreatora. Ka\u017cde nawet proste zadnie mo\u017cemy sobie skomplikowa\u0107 nie rozk\u0142adaj\u0105c go na czynniki.<\/p>\n\n\n\n

        Analiza – Opis w formie tekstu:<\/strong><\/p>\n\n\n\n

        System umo\u017cliwia przechowywanie notatek, kt\u00f3re u\u017cytkownik tworzy, notatka zawiera informacje o autorze oraz dacie utworzenia i ostatniej modyfikacji. Ka\u017cda notatka posiada tytu\u0142 oraz tre\u015b\u0107, kt\u00f3r\u0105 mo\u017cna modyfikowa\u0107. Je\u017celi u\u017cytkownik ma wi\u0119cej notatek, to mo\u017cna wy\u015bwietli\u0107 je w postaci listy notatek. Notatki mo\u017cna usun\u0105\u0107 oraz wy\u015bwietli\u0107 ich zawarto\u015b\u0107. Autor mo\u017ce poda\u0107 swoje imi\u0119 i nazwisko jak r\u00f3wnie\u017c pseudonim artystyczny.<\/p>\n\n\n\n

        Analiza – Wybranie rzeczownik\u00f3w i czasownik\u00f3w z opisu:<\/strong><\/p>\n\n\n\n

        Dlaczego z tekstu wybieramy tylko rzeczowniki i czasowniki? Poniewa\u017c, to pozwoli nam zidentyfikowa\u0107 i okre\u015bli\u0107 przysz\u0142e klasy j\u0119zyka Java (rzeczowniki) oraz metody w klasach Java (czasowniki). Docelowo wszystkie nazwy klas i metod b\u0119d\u0105 w kodzie zapisane po angielsku dla u\u0142atwienia na czas analizy pozostawiam polskie wyrazy.<\/p>\n\n\n\n

        Rzeczowniki (przysz\u0142e klasy Java)<\/th><\/tr><\/thead>
        System, Notatka, Data utworzenia notatki, Data modyfikacji notatki, Tytu\u0142 notatki, Tre\u015b\u0107 notatki, Autor, Imi\u0119 autora, Nazwisko autora, Pseudonim autora<\/td><\/tr><\/tbody><\/table>
        Lista rzeczownik\u00f3w zidentyfikowanych w opisie<\/figcaption><\/figure>\n\n\n\n

        <\/p>\n\n\n\n

        Czasowniki (przysz\u0142e metody w klasach Java)<\/th><\/tr><\/thead>
        Przechowywanie, Tworzenie, Modyfikacja, Wy\u015bwietlenie listy, Wy\u015bwietlenie zawarto\u015bci<\/td><\/tr><\/tbody><\/table>
        Lista czasownik\u00f3w zidentyfikowanych w opisie<\/figcaption><\/figure>\n\n\n\n

        <\/p>\n\n\n\n

        Powy\u017csza lista mo\u017ce wydawa\u0107 si\u0119 banalnie prosta, ale chodzi o przedstawienie idei, za pomoc\u0105, kt\u00f3rej mo\u017cemy przeanalizowa\u0107 dowolnie du\u017cy, z\u0142o\u017cony system informatyczny.<\/p>\n\n\n\n

        Analiza – Karty CRC – Class Responsibility Collaborators:<\/strong><\/p>\n\n\n\n

        Zanim przyst\u0105pimy do tworzenia kart CRC musz\u0119 powiedzie\u0107 o dw\u00f3ch wa\u017cnych relacjach pomi\u0119dzy klasami. W telegraficznym skr\u00f3cie:
        – Pierwsza relacja, to IS-A (jest)<\/strong> – dziedziczenie (inheritance) oznacza, to \u017ce Car IS-A Vehicle – Samoch\u00f3d jest Pojazdem.
        – Druga relacja, to HAS-A (ma)<\/strong> – kompozycja (composition) oznacza, to \u017ce Car HAS-A Engine – Samoch\u00f3d ma Silnik.<\/p>\n\n\n\n

        Wi\u0119cej informacji Inheritance (IS-A) vs. Composition (HAS-A) Relationship<\/a><\/p>\n\n\n\n

        Dlaczego pisz\u0119 o tych relacjach w\u0142a\u015bnie teraz? Poniewa\u017c pewne rzeczowniki nie b\u0119d\u0105 oddzielnymi klasami, ale ich sk\u0142adowymi, a niekt\u00f3re kasy b\u0119d\u0105 bardziej og\u00f3lnym przypadkiem innych, np.:
        – Autor IS-A (jest) U\u017cytkownik(iem)<\/strong>,
        – Notatka HAS-A (ma) Autor(a), Tre\u015b\u0107, itp<\/strong>.<\/p>\n\n\n\n

        Karty CRC (Class, Responsibility, Collaborators) s\u0142u\u017c\u0105 do przedstawienia dla klasy (Class) jej odpowiedzialno\u015bci\/zale\u017cno\u015bci (Responsibilities) oraz powi\u0105za\u0144 z innymi klasami w ramach tworzonego systemu.<\/p>\n\n\n\n

        Class:<\/strong><\/td>Notatka<\/em><\/td><\/tr>
        Responsibility<\/strong><\/td>Collaborators<\/strong><\/td><\/tr>
        Przechowuje (HAS-A) dane notatki:
        – Tytu\u0142, Tre\u015b\u0107, Autor<\/td>        		Autor (klasa)<\/td><\/tr><\/tbody><\/table>
        Tabela z kart\u0105 CRC dla klasy Notatka<\/figcaption><\/figure>\n\n\n\n

        <\/p>\n\n\n\n

        Class:<\/strong><\/td>Autor (U\u017cytkownik)<\/em><\/td><\/tr>
        Responsibility<\/strong><\/td>Collaborators<\/strong><\/td><\/tr>
        Przechowuje (HAS-A) dane autora:
        – Imi\u0119, Nazwisko, Pseudonim<\/td>        		Notatka (klasa)<\/td><\/tr><\/tbody><\/table>
        Tabela z kart\u0105 CRC dla klasy Autor<\/figcaption><\/figure>\n\n\n\n

        <\/p>\n\n\n\n

        Projekt – Diagram klas w UML<\/strong><\/p>\n\n\n\n

        Na podstawie analizy, a konkretnie kart CRC stworzymy diagram klas<\/a> w j\u0119zyku UML<\/a>. Oczywi\u015bcie w tym przypadku b\u0119dzie, to bardzo prosty diagram, ale tak samo jak na etapie analizy chodzi o przedstawienie idei, za pomoc\u0105, kt\u00f3rej mo\u017cemy stworzy\u0107 diagram klas (projekt) tworzonego systemu.<\/p>\n\n\n\n

        Do tworzenia diagram\u00f3w w j\u0119zyku UML u\u017cywam darmowego narz\u0119dzia – https:\/\/www.diagrams.net<\/a>, dost\u0119pnego online, bez konieczno\u015bci instalacji – jest r\u00f3wnie\u017c dost\u0119pna aplikacja typu desktop.<\/p>\n\n\n

        \n
        \"Note<\/a>
        Note – Author, Class Diagram UML<\/figcaption><\/figure>\n<\/body><\/html>\n<\/div>\n\n\n

        <\/p>\n\n\n\n

        Elementy z diagramu UML w telegraficznym skr\u00f3cie:
        1. Note<\/strong> – nazwa klasy,
        2. + title: String<\/strong> – znak +<\/strong> (plus), zmienna publiczna; title<\/strong> – nazwa zmiennej; String<\/strong> – typ zmiennej,
        3. Po\u0142\u0105czenie, relacja mi\u0119dzy klasami <>—<\/strong> agregacja.<\/p>\n\n\n\n

        Projekt – Makiety GUI<\/strong><\/p>\n\n\n\n

        Je\u017celi tworzymy interfejs u\u017cytkownika dla naszej aplikacji, to nale\u017cy stworzy\u0107 makiety GUI nawet, je\u017celi s\u0105, to bardzo proste makiety GUI. Interfejs u\u017cytkownika mo\u017ce by\u0107 dla aplikacji web’owej i\/lub aplikacji desktop. Przez makiety GUI rozumiem, zobrazowanie w formie graficznej element\u00f3w interfejsu u\u017cytkownika takich jak np.: przyciski, etykiety, pola do wprowadzania danych itp.. Dlaczego warto tworzy\u0107 nawet najprostsze makiety GUI takie, jak poni\u017csze? Takie makiety pozwol\u0105 zrozumie\u0107, przybli\u017cy\u0107 biznesowy aspekt tworzonego systemu oraz b\u0119d\u0105 dobr\u0105 baz\u0105 do tworzenia kolejnych makiet.<\/p>\n\n\n

        \n
        \"Lista
        Lista Notatek – Makiety GUI w UML<\/figcaption><\/figure>\n<\/body><\/html>\n<\/div>\n\n
        \n
        \"Dodawanie\/Edycja
        Dodawanie\/Edycja Notatki – Makiety GUI w UML<\/figcaption><\/figure>\n<\/body><\/html>\n<\/div>\n\n\n

        Projekt – Lista end-point\u2019\u00f3w REST i\/lub API<\/strong><\/p>\n\n\n\n

        Dlaczego przed przyst\u0105pieniem do implementacji\/programowania systemu nale\u017cy ustali\u0107 end-point’y i\/lub API? Wypisanie takich element\u00f3w pozwoli nam zobaczy\u0107 szerszy kontekst, obraz tworzonego systemu. Co, to jest w og\u00f3le end-point? End-point jest, to punkt styku, komunikacji mi\u0119dzy r\u00f3\u017cnymi elementami oprogramowania i\/lub system\u00f3w.<\/p>\n\n\n\n

        Uwaga!<\/strong> Poni\u017cszy opis jest niewystarczaj\u0105cy, dodatkowy opis wybiega poza ten artyku\u0142. Nale\u017cy uzupe\u0142ni\u0107 wiedz\u0119 o takie elementy jak: 1. Nale\u017cy odr\u00f3\u017cni\u0107 end-point od API<\/a>, 2. Co to jest REST<\/a>? 3. Co to jest API<\/a>? 3. Protok\u00f3\u0142 HTTP<\/a>. 4. Us\u0142ugi sieciowe – WebService<\/a>. 5. Aplikacja Web<\/a>.<\/p>\n\n\n\n

        End-point powinien by\u0107 udokumentowany i dobrze znany osobom, kt\u00f3re z niego korzystaj\u0105. Jest, to komunikacja typu \u017c\u0105danie\/odpowied\u017a (request\/response), kt\u00f3ra odbywa si\u0119 za po\u015brednictwem adresu URL, pod kt\u00f3rym dost\u0119pna jest funkcjonalno\u015b\u0107 systemu. W wi\u0119kszo\u015bci przypadk\u00f3w jest, to komunikacja typu klient-serwer.<\/p>\n\n\n\n

        Dla aplikacji web z interfejsem u\u017cytkownika w postaci stron html b\u0119dzie, to zbi\u00f3r adres\u00f3w URL ze stronami do wy\u015bwietlenia u\u017cytkownikowi. Natomiast dla aplikacji REST b\u0119dzie, to zbi\u00f3r adres\u00f3w URL (konkretnie URI), kt\u00f3re zwracaj\u0105 dane mniej czytelne dla zwyk\u0142ego u\u017cytkownika, np. w formacie JSON. <\/p>\n\n\n\n

        Aplikacja web z GUI s\u0142u\u017cy do komunikacji cz\u0142owiek-komputer, a aplikacja REST s\u0142u\u017cy do komunikacji komputer-komputer.<\/p>\n\n\n\n

        Poni\u017csza tabela prezentuje adresy URL, pod kt\u00f3rymi b\u0119d\u0105 dost\u0119pne strony w ramach aplikacji.<\/p>\n\n\n\n

        Dzia\u0142anie<\/th>Web URL<\/th>HTTP Method<\/th>HTML Page<\/th><\/tr><\/thead>
        Lista notatek<\/td>\/notes<\/td>GET<\/td>notes.html<\/td><\/tr>
        Dodaj notatk\u0119<\/td>\/notes\/add<\/td>POST<\/td>manage-note.html<\/td><\/tr>
        Szczeg\u00f3\u0142y notatki<\/td>\/notes\/details<\/td>GET<\/td>manage-note.html<\/td><\/tr>
        Edycja notatki<\/td>\/notes\/edit<\/td>POST<\/td>manage-note.html<\/td><\/tr>
        Usuni\u0119cie notatki<\/td>\/notes\/delete<\/td>POST<\/td>notes.html<\/td><\/tr><\/tbody><\/table>
        Lista adres\u00f3w URL dla stron HTML.<\/figcaption><\/figure>\n\n\n\n

        <\/p>\n\n\n\n

        Dlaczego u\u017cywam tylko metod GET i POST protoko\u0142u HTTP? Poniewa\u017c formularz HTML<\/a> obs\u0142uguje w\u0142a\u015bnie tylko te dwie metody GET i POST. Co mam na my\u015bli pisz\u0105c formularz HTML? Wizualnie jest, to zbi\u00f3r element\u00f3w HTML umo\u017cliwiaj\u0105cych wprowadzanie danych takich jak pole tekstowe, przycisk wysy\u0142aj\u0105cy dane, przyk\u0142adem mo\u017ce by\u0107 formularz logowania, zak\u0142adania konta lub umo\u017cliwiaj\u0105cy dodanie postu na Facebook. Technicznie umo\u017cliwia komunikacj\u0119, wysy\u0142anie wprowadzonych danych na serwer celem ich przetworzenia.<\/p>\n\n\n\n

        Poni\u017csza tabela prezentuje end-point’y zgodne z architektur\u0105 REST<\/a>, kt\u00f3ra dzia\u0142a w oparciu o metody protoko\u0142u HTTP<\/a>, np.: GET, POST.<\/p>\n\n\n\n

        Dzia\u0142anie<\/th>REST<\/th>HTTP Method<\/th><\/tr><\/thead>
        Lista notatek<\/td>\/api\/notes<\/td>GET<\/td><\/tr>
        Dodaj notatk\u0119<\/td>\/api\/notes + (body\/payload)<\/td>POST<\/td><\/tr>
        Szczeg\u00f3\u0142y notatki<\/td>\/api\/notes\/{id}<\/td>GET<\/td><\/tr>
        Edycja notatki<\/td>\/api\/notes + (body\/payload)<\/td>PUT<\/td><\/tr>
        Usuni\u0119cie notatki<\/td>\/api\/notes\/{id}<\/td>DELETE<\/td><\/tr><\/tbody><\/table>
        Lista end-point’\u00f3w REST API.<\/figcaption><\/figure>\n\n\n\n

        <\/p>\n\n\n\n

        Implementacja<\/strong><\/p>\n\n\n\n

        Przyszed\u0142 czas na upragnion\u0105 implementacj\u0119, zanim do tego przejdziemy, kilka s\u0142\u00f3w wyja\u015bnienia. Tak, tak zn\u00f3w odwlekamy implementacj\u0119, ale im wi\u0119cej czasu po\u015bwi\u0119cimy na analiz\u0119 i projekt tym wi\u0119cej b\u0142\u0119d\u00f3w, nieporozumie\u0144 unikniemy podczas implementacji.<\/em> Jak wida\u0107 sam proces implementacji jest poprzedzony s\u0142ownym opisem, kt\u00f3ry w tym przypadku sk\u0142ada si\u0119 z “tysi\u0105ca s\u0142\u00f3w”. Moim zdaniem pokazuje, to jak wiele element\u00f3w poprzedza sam proces pisania kodu \u017ar\u00f3d\u0142owego aplikacji.<\/p>\n\n\n\n

        Zawsze powtarzam, \u017ce zanim przyst\u0105pimy do kodowania musimy zrozumie\u0107, co tak na prawd\u0119 mamy do zakodowania. \u017beby zrozumie\u0107 tworzony system musimy zapyta\u0107, uzgodni\u0107 szczeg\u00f3\u0142y z osob\u0105 i\/lub firm\u0105, kt\u00f3ra zleca nam stworzenie systemu.<\/strong> Pozwoli, to nam unikn\u0105\u0107 wielu nieporozumie\u0144, nieprzyjemnych sytuacji oraz wielu godzin refaktorowania i\/lub przepisywania tworzonego systemu.<\/p>\n\n\n\n

        Implementacj\u0119 wykonujemy w naszym ulubionym \u015brodowisku programistycznym np. IntelliJ IDEA<\/a>. Maj\u0105c przygotowany diagram klas, po prostu tworzymy klasy oraz ich zawarto\u015b\u0107 zgodnie z elementami na diagramie. Dodajemy pola w klasie oraz metody. W tym miejscu gor\u0105co zach\u0119cam do skorzystania z techniki TDD<\/a>, czyli najpierw piszemy klas\u0119 testow\u0105, a potem implementacj\u0119 tworzonej metody.<\/em><\/p>\n\n\n\n

        Podsumowuj\u0105c, implementacja nawet najprostszego systemu polecam rozpocz\u0105\u0107 od analizy, nast\u0119pnie stworzy\u0107 projekt, a dopiero na samym ko\u0144cu zabra\u0107 si\u0119 za kodowanie, najlepiej zgodnie z TDD<\/a>. Powy\u017cszy przyk\u0142ad pozwala wyrobi\u0107 nam dobry nawyk, kt\u00f3ry zaowocuje w przysz\u0142o\u015bci.<\/p>\n\n\n\n

        Zapraszam do regularnego odwiedzania mojej strony, b\u0119d\u0105 pojawia\u0107 si\u0119 kolejne artyku\u0142y oraz do kontaktu przez email kontakt(at)juniorjavadeveloper.pl.<\/p>\n\n\n\n

        Aktualna oferta dost\u0119pna na https:\/\/www.juniorjavadeveloper.pl\/oferta\/<\/a><\/p>","protected":false},"excerpt":{"rendered":"

        W tym artykule postaram si\u0119 pokaza\u0107 jak unika\u0107 b\u0142\u0119du, kt\u00f3ry pope\u0142niaj\u0105 programi\u015bci podczas pisania kodu aplikacji, nawet tego najmniejszego i najprostszego kodu. B\u0142\u0119dem tym jest brak zastanowienia si\u0119, co tak na prawd\u0119 chcemy kodowa\u0107. Samemu nieraz pope\u0142ni\u0142em ten b\u0142\u0105d. Mo\u017cesz mi wierzy\u0107, albo i nie, ale nawet nad jednym, prostym fragmentem kodu mo\u017cna zmarnowa\u0107 wiele […]<\/p>","protected":false},"author":1,"featured_media":1332,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_ppp_document_settings_meta":"","footnotes":"","jetpack_publicize_message":"","jetpack_is_tweetstorm":false,"jetpack_publicize_feature_enabled":true,"jetpack_social_post_already_shared":false,"jetpack_social_options":{"image_generator_settings":{"template":"highway","enabled":false}}},"categories":[4,7],"tags":[],"class_list":["post-1238","post","type-post","status-publish","format-standard","has-post-thumbnail","category-bez-kategorii","category-poradnik"],"jetpack_publicize_connections":[],"jetpack_featured_media_url":"https:\/\/www.juniorjavadeveloper.pl\/wp-content\/uploads\/2020\/11\/stop_zanim-zaczniesz-pisac-kod_naglowek.jpg","jetpack_sharing_enabled":true,"jetpack_likes_enabled":true,"_links":{"self":[{"href":"https:\/\/www.juniorjavadeveloper.pl\/en\/wp-json\/wp\/v2\/posts\/1238","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.juniorjavadeveloper.pl\/en\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.juniorjavadeveloper.pl\/en\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.juniorjavadeveloper.pl\/en\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.juniorjavadeveloper.pl\/en\/wp-json\/wp\/v2\/comments?post=1238"}],"version-history":[{"count":62,"href":"https:\/\/www.juniorjavadeveloper.pl\/en\/wp-json\/wp\/v2\/posts\/1238\/revisions"}],"predecessor-version":[{"id":3103,"href":"https:\/\/www.juniorjavadeveloper.pl\/en\/wp-json\/wp\/v2\/posts\/1238\/revisions\/3103"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.juniorjavadeveloper.pl\/en\/wp-json\/wp\/v2\/media\/1332"}],"wp:attachment":[{"href":"https:\/\/www.juniorjavadeveloper.pl\/en\/wp-json\/wp\/v2\/media?parent=1238"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.juniorjavadeveloper.pl\/en\/wp-json\/wp\/v2\/categories?post=1238"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.juniorjavadeveloper.pl\/en\/wp-json\/wp\/v2\/tags?post=1238"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}