Metoda Kanban – Zadania

przez Karol Bocian | 24 marca, 2020

Zadania w metodzie Kanban

Zadania w metodzie Kanban reprezentowane są na tablicy za pomocą karteczek. W systemach wirtualnych również przyjmują taką formę. Te fizyczne, z racji ograniczonego miejsca, mają również ograniczoną liczbę atrybutów. Te wirtualne, z racji mniejszych ograniczeń, mają zazwyczaj znacznie więcej elementów.

Zadanie to coś, co należy wykonać. Wielkość zadania powinna wynikać z naszych standardów pracy. Dla niektórych odpowiednie będzie dodawanie zadań zajmujących tylko kilka minut, dla innych będzie to jednak za małe zadanie. Tak samo w drugą stronę. Zadania z zasady nie powinny trwać zbyt długo. Kilkudniowe zadania są trudne do zarządzania. Ciężko jest być zwinnym i z dnia na dzień reagować na zmiany priorytetów, jeżeli zadania w naszym procesie trwają kilkanaście dni i przez taki czas blokujemy nasze zasoby. Zalecam, aby robić w miarę krótkie zadania oraz grupować je w tematy. Zaletami tego podejścia są:

  • Realizowanie dużego zadania jako wielu zadań w ramach jednego tematu sprawia, że możemy zespołowo skupić się na wybranym temacie i skończyć go jak najszybciej, a potem przejść do kolejnego.
  • Podzielenie zadania na mniejsze pozwala:
    • Podzielić się pracą z innymi członkami zespołu.
    • Ułatwia zabranie się do dużego tematu (jedzenie słonia odbywa się po kawałku).
    • Zwiększa zadowolenie z pracy, bo co chwila kończymy zadanie i widzimy postęp w pracy.
    • Skrócona jest pętla informacji zwrotnej.
    • Jesteśmy zwinniejsi, bo jak trafia się coś pilniejszego, to możemy jeszcze trochę popracować nad obecnym zadaniem i je skończyć, bo wiemy, że będziemy robili je chwilę, a nie przez kilka następnych dni.
    • Wprowadza lepsze zrozumienie tematu, wymusza jego przemyślenie, ponieważ przed zabraniem się za pracę, musimy zastanowić się, jak rozbić go na mniejsze kroki.

Zadania mogą mieć przeróżne cechy. Które z nich wybrać? Najważniejsze w tym wszystkim, jest zachować umiar, przejrzystość i rozsądek. Dodawanie elementów z powodu: bo może kiedyś się przyda albo dlatego, że ktoś inny tak ma, nie jest dobrym pomysłem. Zbiór cech zadania budujmy przyrostowo i eksperymentalnie, jak wszystko, co robimy w obszarze metody Kanban. Jeżeli chcemy dodać nowy element, zastanówmy się, jaki jest tego cel, do czego nam się przyda, czy nie jest on zbyteczny. Jeżeli uznamy, że warto spróbować, wprowadźmy go i przetestujmy, czy wnosi więcej dobrego do naszego procesu, czy jednak jest kulą u nogi i nikt go nie używa. Sprawdźmy też, jak wpłynął on na nasze metryki. W przypadku negatywnym tzn. wnosi więcej złego niż dobrego, usuńmy go, albo wdróżmy jego usprawnienie (w postaci kolejnego eksperymentu).

Zadania mogą mieć następujące atrybuty:

  • Nazwa zadania.
  • Opis zadania.
  • Typ / rodzaj zadania.
  • Osoba wykonująca zadanie.
  • Etap procesu (kolumna).
  • Priorytet.
  • Typ przepływu (swimline).
  • Historia zadania.
  • Czas bycia w danej kolumnie.
  • Data powstania.
  • Data zakończenia.
  • Termin wykonania.
  • Tagi.
  • Komentarze.
  • Załączniki.
  • Efekty pracy poszczególnych etapów.
  • Relacja do innych zadań.
  • Informacja o powtarzalności zadania.
  • ID.
  • Wiek zadania.
  • Kolor.
  • Pineski / flagi / emotikony.
  • Planowane rezultaty pracy.
  • Przemyślenia / podsumowanie pracy.
  • Powód zatrzymania / zablokowania.
  • Osoby śledzące.
  • Osoby pracujące wcześniej nad tym zadaniem.
  • Osoby zlecające.
  • Osoby oddelegowane.
  • Osoby odpowiedzialne za wykonanie zadania.
  • Checklista rzeczy do zrobienia.
  • Wzór zadania.
  • Wielkość / trudność zadania.
  • Informacja zwrotna od klienta.
  • Atrybut wersji / wydania produktu.
  • Źródło dodania zadania.
  • Informacja jak przetestować i sprawdzić poprawność wykonania zadania.
  • Informacja, na co zwrócić szczególną uwagę podczas testowania.
  • Informacje co zostało zmienione / zrobione / odkryte / ustalone.
  • Autor zadania.

Zadania mogą mieć jeszcze wiele innych atrybutów, związanych np. z integrowanymi narzędziami.

Wszystkie posty związane z mini projektem: Poznaj metodę Kanban:

    Źródła

    Obraz główny

    Materiały

    10 pomysłów na: poprawę marketingu:

    przez Karol Bocian | 19 marca, 2021

    W ramach rozwijania moich zdolności kreatywnego myślenia przygotowałem listę 10 pomysłów.

    10 pomysłów na: poprawę marketingu:

    1. Regularna aktywność na Instagramie.
    2. Regularna aktywność na Facebook (fanpage i grupa tematyczna, relacje, posty, zdjęciami, filmiki).
    3. Regularne pisanie postów na własnym blogu.
    4. Regularna aktywność na TikToku.
    5. Wizytówka firmowa w Google i Google Maps.
    6. Regularna aktywność na kanale na YouTube.
    7. Newsletter.
    8. Artykuły sponsorowane i kampanie u influencerów.
    9. Regularna aktywność na LinkedIn.
    10. Regularna aktywność na Twitterze.

    Wszystkie posty związane z kreatywnością:

      Źródła

      Obraz główny

      10 pomysłów na: biznes (w internecie):

      przez Karol Bocian | 19 marca, 2021

      W ramach rozwijania moich zdolności kreatywnego myślenia przygotowałem listę 10 pomysłów.

      10 pomysłów na: biznes (w internecie):

      1. Dropshipping.
      2. Sprzedaż szkoleń i konsultacji.
      3. Sprzedaż wiedzy (e-booki, kursy, wzory, szablony, książki).
      4. Sprzedaż usług, np. planowania wycieczek.
      5. Sprzedaż dostępu do konkretnej grupy klientów (np. prowadząc fanpage i grupę pasjonatów majsterkowania).
      6. Świadczenie usług, np. aplikacja licząca pensję brutto i netto, ocenianie awersji do ryzyka inwestycyjnego.
      7. Wirtualny kierownik projektu, coach, scrum master, koordynator, kanban flow manager.
      8. Robienie zdjęć, grafik i filmów.
      9. Wspieranie budowania i kreowania marki, prowadzenie marketingu.
      10. Wirtualna asystentka.

       

      Wszystkie posty związane z kreatywnością:

        Źródła

        Obraz główny

        10 pomysłów na: biznes (i łatwy zysk)

        przez Karol Bocian | 19 marca, 2021

        W ramach rozwijania moich zdolności kreatywnego myślenia przygotowałem listę 10 pomysłów.

        10 pomysłów na: biznes (i łatwy zysk):

        1. Korepetycje.
        2. E-book.
        3. Reklamy ad-sense na blogu.
        4. Szkolenie.
        5. Konsultacje.
        6. Sprzedaż garażowa.
        7. Obrazy.
        8. Kartki okolicznościowe.
        9. Coppywriting i artykuły sponsorowane.
        10. Sprzątanie.

        Wszystkie posty związane z kreatywnością:

          Źródła

          Obraz główny

          Metoda Kanban – Udoskonalaj i rozwijaj eksperymentalnie

          przez Karol Bocian | 21 marca, 2020

          Udoskonalaj i rozwijaj eksperymentalnie

          Kanban, jako jedną ze swoich zasad, podaje ciągłe udoskonalanie. Pod tym hasłem można wyróżnić:

          • Ciągłe i ewolucyjne doskonalenie, wykorzystanie filozofii kaizen, czyli ciągłego rozwoju małymi krokami.
          • Nieprzerwane optymalizowanie procesów.
          • Stawianie hipotez i przeprowadzanie eksperymenty w celu potwierdzenia jej słuszności. Hipotezy dotyczą ulepszeń i zmian. Eksperymenty służą wprowadzania zmian na podstawie twardych danych.
          • Narzędziami umożliwiającymi otrzymywanie często i w sposób zarządzany są pętle inspekcji i adaptacji.
          • Rozwiązywanie prawdziwych problemów, ponieważ tablica kanbanowa powinna reprezentować faktyczną pracę. Należy unikać pracy ukrytej, czyli robienia zadań bez umieszczania jej na tablicy. Sprawia to, że na tablicy można zaobserwować faktyczne problemy.

          Rozwój procesu wytwórczego oraz sposobu zarządzania tym procesem powinien odbywać się również małymi krokami. Należy zacząć od stanu obecnego: przedstawić na tablicy obecny proces wytwórczy oraz spisać obecnie panujące zasady, standardy i wydarzenia. Następnie w pierwszej kolejności należy wprowadzić regularne (np. co dwa tygodnie) spotkanie zespołu skupione na rozwoju i udoskonalaniu procesów (retrospektywa). To narzędzie jest wystarczające, aby optymalizować procesy. Na retrospektywach omawia się problemy procesu, wprowadza za pomocą eksperymentów zmiany i udoskonalenia, podejmuje się decyzje, czy dane udoskonalenie należy przyjąć jako standard. Warto również w miarę szybko wprowadzić codzienne spotkania przy tablicy. Podczas takich spotkań następuje przegląd tablicy, znajdowane są zatory, blokady, wąskie gardła, problemy, ustalane są priorytety, przekazywane są porady oraz rozwiązywane są małe problemy.

          Narzędzia umożliwiające udoskonalanie i rozwój procesów:

          1. Pętle inspekcji i adaptacji.
          2. Regularne spotkania przy tablicy.
          3. Regularne retrospektywy.
          4. Teoria ograniczeń — poszukiwanie wąskich gardeł i próbowanie w pierwszej kolejności udoskonalenie największego ograniczenia przepływu pracy.
          5. Limity pracy w toku — zmienianie limitów pozwala sterować procesem wytwórczym, zmieniać rozłożenie zadań, uwypuklać problemy, likwidować wąskie gardła oraz minimalizować nadprodukcję.
          6. Etapy procesu (dodawanie, uszczegóławianie, usuwanie).
          7. Zasady i standardy pracy (aktualizowanie, poprawianie, uszczegóławianie, dodawanie zadań do wykonania, usuwanie).
          8. Swimline’y — traktowanie w inny sposób wybranych zadań — wprowadzanie lub usuwanie innych przepływów dla danych typów zadań.
          9. Wizualizacja — przeglądanie tablicy w poszukiwaniu problemów, wąskich gardeł, spowolnień przepływu, niedoskonałości procesu.
          10. Eskperymenty — wprowadzanie trudnych lub nieoczywistych zmian jako eksperymenty.
          11. Metryki i wykresy — podejmowanie decyzji na podstawie twardych danych.
          12. Samozarządzanie — zespół powinien decydować o wprowadzanych zmianach. Powinien to robić na podstawie danych, a nie widzimisię kierownika lub konsultanta.

          Wszystkie posty związane z mini projektem: Poznaj metodę Kanban:

            Źródła

            Obraz główny

            Materiały

            10 pomysłów na: biznes (oparty o bloga)

            przez Karol Bocian | 19 marca, 2021

            W ramach rozwijania moich zdolności kreatywnego myślenia przygotowałem listę 10 pomysłów.

            10 pomysłów na: biznes (oparty o bloga):

            1. Sprzedaż gier planszowych.
            2. Sprzedaż gier opartych o opowieść prezentowaną na blogu.
            3. Sprzedaż gier uczących metody zarządzania (blog ekspercki).
            4. Sprzedaż gier uczących przeżycia w trudnych warunkach (blog ekspercki).
            5. Sprzedaż gier rozwijających umiejętności interpersonalne (blog ekspercki).
            6. Sprzedaż gier uczących konkretnej wiedzy lub rozwijających jakieś umiejętności (blog ekspercki).
            7. Sprzedaż gier na telefon lub komputer.
            8. Sprzedaż sposobu na życie jako gry (narzędzia, schematy, procesy, zasady).
            9. Sprzedaż sposobu na biznes jako gry (narzędzia, schematy, procesy, zasady).
            10. Blog jako gra (użytkownik zdobywając wiedzę lub czytając opowiadanie wybiera kolejne kroki, gdzie spotyka się z kolejnymi problemami).

            Wszystkie posty związane z kreatywnością:

              Źródła

              Obraz główny

              Metoda Kanban – Pętle informacji zwrotnej, czyli feedback loops

              przez Karol Bocian | 20 marca, 2020

              Pętle informacji zwrotnej

              Pętle informacji zwrotnej to mechanizmy mające na celu weryfikację wyników prac, słuszności założeń oraz sposobu pracy. Otrzymywane informacje pomagają wprowadzić usprawnienia, podjąć decyzje o kierunku dalszych prac, zmianie sposobu pracy i dostarczania wartości. Im pętla jest krótsza, tym lepiej. Pozwala to wcześniej reagować, dostarczać wartościowszy produkt i minimalizować straty. Pętle powinny być częste oraz regularne.

              Pętla informacji zwrotnej to:

              1. Postawienie hipotezy i wdrożenie jej, czyli danie okazji do sprawdzenia w prawdziwych warunkach słuszności założeń.
              2. Zebranie informacji — gromadzenie informacji pozyskanych od systemów, klienta, zespołu, interesariuszy.
              3. Przeprowadzenie analizy informacji i przejście do kroku 1, w którym na podstawie nowych informacji stawiamy kolejną hipotezę.

              Przykład:

              Problem: Podczas zdalnych spotkań codziennych członkowie zespołu zajmują się swoimi zadaniami i nie są w pełni skupieni na rozmowie.

              1. Hipoteza — niech wszyscy stoją. Stojąc, nie można pisać na klawiaturze.
              2. Weryfikacja — przez 3 tygodnie zespół stara się wstawać podczas spotkań.
              3. Analiza informacji — dziwnie jest stać pośród osób, które aktualnie nie mają z nami spotkania. Jest to niekomfortowe, więc część zespołu nie wstawała. Hipoteza poprzednia okazała się niewłaściwym rozwiązaniem. Spróbujmy innego.
              4. Hipoteza 2 – niech wszyscy podczas spotkań używają kamerek.
              5. Analiza informacji — przez 3 tygodnie zespół używa kamerek podczas spotkań.
              6. Analiza informacji – …

              Powyższy przykład jest elementem pętli zwrotnej zorientowanej na poprawę pracy zespołu. Pętla trwa 3 tygodnie. Zespół będzie zajmował się tym tematem do momentu, aż znajdzie rozwiązanie odpowiednio satysfakcjonujące. Takich 3 tygodniowych pętli może być na ten temat wiele, a może być tylko jedna. Warto jednak czasem wrócić do już zakończonego tematu i spróbować kolejnego eksperymentu.

              Elementy, które należy weryfikować:

              • Cel projektu i zasadność.
              • Plan projektu.
              • Elementy produktu.
              • Zmiany produktu.
              • Zmiany procesu wytwórczego.
              • Zmiany w komunikowaniu się z interesariuszami.

              Momenty zbierania:

              • Spotkania przy tablicy i zaobserwowanie np.:
              • zablokowanych zadań,
              • kolejki,
              • braku zadania,
              • priorytetowe zadania nie są realizowane.
              • Retrospektywa zespołu.
              • Codzienne spotkanie zespołu.
              • Otrzymanie informacji od interesariuszy.
              • Przeróżne spotkania.
              • Refleksje członków zespołu i innych interesariuszy.

              Kanban nazywa pętle informacji zwrotnej kadencjami. Są to pętle inspekcji i adaptacji, będące elementami empiryzmu i doświadczalnego oraz ewolucyjnego podejścia do wprowadzania zmian. Kanban wyróżnia 7 kadencji:

              1. Rewizja strategii — długoterminowe spojrzenie (np. kwartalne) na organizacje. Następuje przegląd strategii i poziomu spełniania potrzeb klientów.
              2. Inspekcja wyników operacyjnych — dotyczy przeglądu produktów i zespołów na poziomie organizacji lub działów (np. co miesiąc).
              3. Przegląd ryzyk — przegląd przez organizację lub zespół ryzyk i zarządzanie nimi (np. co miesiąc).
              4. Uzupełnianie i zobowiązanie — planowanie co zespół ma zrobić w najbliższym czasie (uzupełnianie backlogu, np.co miesiąc).
              5. Planowanie dostaw — zespół i organizacja planują i synchronizują dostawy produktów oraz usprawniają ich przebieg (np. co miesiąc).
              6. Przegląd dostaw — przegląd poziomu satysfakcji klienta oraz analiza metryk związanych z dostarczaniem produktów (np. co tydzień).
              7. Codzienne spotkanie przy tablicy — zespół omawia przebieg pracy na najbliższy dzień, analizuję i poprawia przepływ pracy korzystając z tablicy, uszczegóławia zasady pracy (np. definition of ready i definition od done) (codziennie).

              Wszystkie posty związane z mini projektem: Poznaj metodę Kanban:

                Źródła

                Obraz główny

                Materiały

                10 pomysłów na: biznes (blogowy)

                przez Karol Bocian | 19 marca, 2021

                W ramach rozwijania moich zdolności kreatywnego myślenia przygotowałem listę 10 pomysłów.

                10 pomysłów na: biznes (blogowy):

                1. Prezentowanie rękodzieła (własnego i innych)
                2. Przeprowadzanie testów zabawek dla dzieci i omawianie ich
                3. Omawianie, jak uprawiać zioła (w domu), jakie sa korzyści z ich uprawy i sprzedawanie ich
                4. Omawianie, jak uprawiać zioła (w domu), jakie sa korzyści z ich uprawy i sprzedawanie ich
                5. Prezentowanie, jak prowadzi się gospodarstwo rolne i swoją wiedzę
                6. Prezentowanie rzeczy do zrobienia własnoręcznie (DIY) i sprzedaż ich
                7. Prezentowanie i sprzedawanie przepisów kulinarnych oraz potraw
                8. Opisywanie swoich przygód
                9. Szkolenie z wychowywania dzieci, opowiadanie o własnych doświadczeniach
                10. Prezentowanie szkolnych romansów (w postaci postów, filmików, TikToka

                Wszystkie posty związane z kreatywnością:

                  Źródła

                  Obraz główny

                  10 pomysłów na: biznes (blogując)

                  przez Karol Bocian | 19 marca, 2021

                  W ramach rozwijania moich zdolności kreatywnego myślenia przygotowałem listę 10 pomysłów.

                  10 pomysłów na: biznes (blogując):

                  1. Prowadzenie korepetycji.
                  2. Rozwiązywanie zamówionych problemów.
                  3. Przeprowadzanie panelu lub dyskusji publicznej.
                  4. Wpływanie na firmy i podmioty z pomocą możliwości dotarcia do wielu osób negocjowanie z nimi.
                  5. Zbieranie funduszy na społeczne cele.
                  6. Opowiadanie o swoich problemach i sposobach ich rozwiązania.
                  7. Przedstawianie gier planszowych. Materiały są płatne.
                  8. Przedstawianie zadań maturalnych. Dokładne wyjaśnienie lub ich część jest płatna.
                  9. Gromadzenie ludzi w celu wspólnego zrobienia czegoś, np. odmalowania płotu.
                  10. Gromadzenie ludzi w celu robienia grupowych zakupów: minimalizowanie kosztów transportu, wynajem busa.

                  Wszystkie posty związane z kreatywnością:

                    Źródła

                    Obraz główny

                    10 pomysłów na: biznes (za pomocą bloga):

                    przez Karol Bocian | 19 marca, 2021

                    W ramach rozwijania moich zdolności kreatywnego myślenia przygotowałem listę 10 pomysłów.

                    10 pomysłów na: biznes (za pomocą bloga):

                    1. Treści ukryte za paywallem.
                    2. Pisanie opowiadania i z płatnym zakończeniem.
                    3. Pisanie opowiadań na zamówienie (np. zamawiający wybiera postać główną).
                    4. Rozwijanie zamówionej umiejętności i opisywanie postępów z jej rozwijania.
                    5. Wyjaśnianie i przekazywanie zamówionej wiedzy.
                    6. Sprzedaż narzędzi online.
                    7. Łączenie ludzi o wspólnych zainteresowaniach.
                    8. Tworzenie platformy zawierającej rozwiązania najczęstszych błędów (ala wzorce projektowe).
                    9. Prowadzenie szkoleń z prowadzenia bloga.
                    10. Publikacja ofert pracy.

                    Wszystkie posty związane z kreatywnością:

                      Źródła

                      Obraz główny

                      Metoda Kanban – niech wszyscy wiedzą, co mają robić – Miej jasne zasady

                      przez Karol Bocian | 17 marca, 2020

                      Uczyń zasady jasnymi

                      Jak można dobrze pracować, nie wiedząc, czego się od nas oczekuje? Jest bardzo ciężko. Kanban, jako jedną ze swoich reguł, podaje: posiadaj jasne zasady. Co to znaczy?

                      Wszyscy członkowie zespołu powinni znać, akceptować i przestrzegać zasad pracy. Powinny być one jasne, przejrzyste oraz odpowiednio szczegółowe. Jednym ze źródeł informacji o procesie wytwórczym jest tablica kanban. Składa się ona z etapów produkcji, zadań różnego rodzaju, reguł przesuwania zadań do innej kolumny. Nie wszystko jest jednak jasne na pierwszy rzut oka. Należy wszystkie wątpliwości i dwuznaczności rzetelnie wyjaśniać oraz uszczegóławiać. Pamiętajmy, że tablica musi być spójna z aktualnym procesem produkcji — odzwierciedlać go, a nie prezentować idealny -taki do którego dążymy.

                      Tworzenie przejrzystych zasad obejmuje wiele tematów, np.:

                      • Normalny przebieg pracy.
                      • Awaryjny / wyjątkowy przebieg pracy.
                      • Definicja ograniczeń WIP, jakie są, po co są, czy można je przekroczyć, jak i kiedy je zmieniać.
                      • Co należy umieszczać na tablicy, a czego nie trzeba.
                      • W jaki sposób umieszczać zadania na tablicy.
                      • Kto może umieszczać zadania na tablicy.
                      • Jak powinny wyglądać dobre zadania.
                      • W jaki sposób zgłaszać błędy procesu lub produktu.
                      • W jaki sposób zgłaszać awarie.
                      • Co oznacza, że zadanie jest zakończone (definition of done).
                      • Kiedy można przenieść zadanie do kolejnej kolumny (definition of ready).
                      • Kiedy, kto i jak może cofnąć zadanie.
                      • Kto może brać zadania z danej kolumny.
                      • Jakie są wytyczne co do jakości pracy.
                      • Jakie są wytyczne co do komunikacji w zespole.
                      • Kiedy brać kolejne zadanie.
                      • Czy i kiedy można porzucić obecne zadanie.
                      • Co w przypadku, gdy nie skończyłem zadania, a idę na urlop.
                      • Co zrobić z zadaniem, które jest długo zablokowane.
                      • Jak odblokowywać zadania i jak często?
                      • Jak wybierać kolejne zadanie do zrobienia.
                      • Co oznaczają symbole na tablicy.
                      • Kto ustala ważność, pilność, priorytety zadań.
                      • Kiedy i jak często aktualizować tablicę.
                      • Jak współpracować z klientem.
                      • Jak współpracować z resztą firmy.
                      • Jak współpracować ze sobą wewnątrz zespołu.
                      • Jakie i kiedy robimy spotkania.
                      • Jak rozwiązujemy problemy.
                      • Jakie są zasady kanban i co to jest kanban.
                      • W jakiej metodzie pracy pracujemy.
                      • Dlaczego pracujemy w taki, a nie inny sposób.
                      • Jaką mam decyzyjność i o czym mogę decydować.
                      • Po co rozwijamy się i udoskonalamy.
                      • Po co coś robimy i do czego zmierzamy.

                      Sytuacje, kiedy można wyjaśnić lub ustalić zasady:

                      • Podczas regularnego przeglądu sposobu pracy — w celu optymalizacji.
                      • Przyjście nowej osoby, która zadaje pytania, jak ma coś robić — możemy tym sposobem rozbudowywać instrukcję pracy. Jeżeli nadal coś jest niejasne, to uzupełniać ją.
                      • Zauważymy, że różne osoby różnie robią tę samą czynność.
                      • Wpadliśmy na pomysł usprawnienia.
                      • Zauważyliśmy, że coś nie działa najlepiej — możemy rozpocząć dyskusję na ten temat.
                      • Ktoś nie wie jak powinien postąpić.

                      Zasady i nasz proces produkcji cały czas ewoluują i się zmieniają. Zwracajmy baczną uwagę na nasz proces i zadajmy sobie regularnie pytanie: czy mogę poprawić proces produkcji? Czy mogę go jakoś odchudzić? Czy jest sens dalej to robić? Czy jest sens robić to w taki sposób?

                      Wszystkie posty związane z mini projektem: Poznaj metodę Kanban:

                        Źródła

                        Obraz główny

                        Materiały

                         

                        Ludzie. Krótka historia o tym, jak spieprzyliśmy wszystko – Tom Phillips

                        przez Karol Bocian | 3 lipca, 2020

                        Przeczytałem ostatnio kolejną książkę. W tym wpisie dzielę się informacjami, które w niej znalazłem oraz które wdrożyłem w swoim życiu. Staram się z każdej książki wdrażać minimum jedną rzecz.

                        Wdrożyłem:

                        1. Staram się kwestionować tezy innych i ich prawdziwość. Nie zakładam, że osoba w mundurze, garniturze, sutannie, z tytułem profesora ma racje tylko z powodu jej atrybutów.

                        Książkę możesz kupić tutaj:

                        Notatki:

                        Książka opowiada w ciekawy sposób, że ludzie popełniają dużo błędów, nie wyciągają z nich wniosków i ponownie je popełniają, np. Kolumb oraz NASA pomyliło jednostki miar, przez co mieli problemy. Pokazuje, że wiele błędów została popełniona nieświadomie albo wręcz intencja działań była dobra, ale zakończyły się katastrofą, np. Nobel wynalazł dynamit, aby nie było więcej wojen.

                        Nie myślimy o tym, jak nasza drobna zmiana może wpłynąć na resztę świata. Zapominamy, że świat jest skomplikowany i wszystko jest ze sobą połączone. Później dziwimy się, że mała zmiana pociągnęła łańcuch zmian i wywołała serię coraz większych katastrof (np. wybicie w Chinach wróbli (które jedzą zboże, jeżeli więc zabijemy wróble, to będzie więcej zboża dla ludzi), spowodowało to zwiększenie liczby szarańczy, które zniszczyły zboże, co spowodowało śmierć z głodu ogromnej liczby ludzi).

                        Powody błędnego myślenia:

                        • Szukanie wzorców (np. słyszeliśmy o kilku kradzieżach przez cyganów, więc wnioskujemy, że wszyscy cyganie kradną).
                        • Skróty myślowe — zbytnie upraszczanie świata.
                        • Efekt potwierdzenia — zwracamy uwagę tylko na potwierdzenia naszych słów. Elementy przeczące naszej tezie uważamy za: wyjątki, błędne odczyty, niewarte zachodu (do zignorowania).
                        • Heurystyka kotwiczenia — nasze myślenie zmienia się, gdy mamy kontekst. Na pytanie: „Ile miesięcznie powinien zarabiać programista, jeżeli sprzątaczka w Berlinie zarabia 3000 euro (prawie 13 000 PLN)?” odpowiemy inaczej, niż na pytanie: „Ile miesięcznie powinien zarabiać programista, jeżeli prezes firmy informatycznej zarabia 10 000 PLN?”.
                        • Heurystyka dostępności — oceniamy na podstawie najświeższych danych lub pierwszej myśli, która przyjdzie nam do głowy, a nie na podstawie wszystkich informacji, które mamy (zbieranych przez całe życie).
                        • Efekt wspierania decyzji — trwamy przy raz podjętej decyzji, mimo iż już od dłuższego czasu wiemy, że nie ma ona sensu. Wiąże się to czasem z niechęcią stracenia już wykorzystanych zasobów w związku z realizacją podjętej decyzji (np. kończymy studia, mimo iż na drugim roku stwierdziliśmy, że nie przydadzą nam się, bo nie chcemy pracować w tej branży).
                        • Gromadomyślenie — napędzamy się wzajemnie w błędnym myśleniu: jesteśmy nakierowanie przez kogoś na błędne myślenie (niekoniecznie świadomie), boimy się podważyć słowa (odstawać od stada), jesteśmy oczarowani innym aspektem i nie zwracamy uwagi na błędne myślenie.
                        • Myślenie życzeniowe — wmawiamy sobie i innym, że świat działa w jakiś sposób.
                        • Uprzedzenia — dzieli świat, na „My” i „Oni”. Jeżeli „Oni” mylą się w jednym aspekcie, to muszą mylić się w innym. Jeżeli nie lubimy „Ich”, to również nie lubimy ich pomysłów.

                        Książkę możesz kupić tutaj:

                        Notatki:

                        Książka opowiada w ciekawy sposób, że ludzie popełniają dużo błędów, nie wyciągają z nich wniosków i ponownie je popełniają, np. Kolumb oraz NASA pomyliło jednostki miar, przez co mieli problemy. Pokazuje, że wiele błędów została popełniona nieświadomie albo wręcz intencja działań była dobra, ale zakończyły się katastrofą, np. Nobel wynalazł dynamit, aby nie było więcej wojen.

                        Nie myślimy o tym, jak nasza drobna zmiana może wpłynąć na resztę świata. Zapominamy, że świat jest skomplikowany i wszystko jest ze sobą połączone. Później dziwimy się, że mała zmiana pociągnęła łańcuch zmian i wywołała serię coraz większych katastrof (np. wybicie w Chinach wróbli (które jedzą zboże, jeżeli więc zabijemy wróble, to będzie więcej zboża dla ludzi), spowodowało to zwiększenie liczby szarańczy, które zniszczyły zboże, co spowodowało śmierć z głodu ogromnej liczby ludzi).

                        Powody błędnego myślenia:

                        <

                        ul>

                        Wszystkie posty związane z książkowymi wdrożeniami:

                          Źródła

                          Obraz główny

                          Materiały

                          • Ludzie. Krótka historia o tym, jak spieprzyliśmy wszystko — Tom Phillips.

                          Linki oznaczone (*) są linkami afiliacyjnymi. Jeżeli uważasz, że czerpiesz korzyści z mojej pracy, to kup coś korzystając z powyższego linku. Sprawi to, że dostanę prowizję z afiliacji.

                          10 pomysłów na: biznes (poprzez bloga)

                          przez Karol Bocian | 19 marca, 2021

                          W ramach rozwijania moich zdolności kreatywnego myślenia przygotowałem listę 10 pomysłów.

                          10 pomysłów na: biznes (poprzez bloga):

                          1. Reklamy np. AdSense.
                          2. Afiliacje, np Convertiser, TradeTracker.
                          3. Sprzedaż czyichś produktów.
                          4. Sprzedać swojego produktu fizycznego.
                          5. Sprzedaż swojego e-booka lub kursu.
                          6. Sprzedać swojego szkolenia.
                          7. Sprzedaż swojej usługi.
                          8. Sprzedaż swoich konsultacji.
                          9. Pisanie artykułów sponsorowanych.
                          10. Publikowanie czyichś artykułów.

                          Wszystkie posty związane z kreatywnością:

                            Źródła

                            Obraz główny

                            Metoda Kanban – Zarządzaj przepływem

                            przez Karol Bocian | 16 marca, 2020

                            Zarządzaj przepływem

                            Metoda Kanban służy optymalizowaniu przepływu przez proces, tzn. zarządzaniu pracę w taki sposób, aby klient był maksymalnie zadowolony z naszej pracy, wykonane zadania spełniały jego oczekiwania i były dostarczane mu w odpowiednim momencie.

                            W celu maksymalizacji zadowolenia klienta należy zarządzać przepływem pracy, czyli obserwować i monitorować wskaźniki, mierniki, wykresy oraz statusy, które daje nam Kanban, a następnie na ich podstawie zmieniań proces oraz wychwytywać jego (w tym również chwilowe) problemy, np. zatory, wąskie gardła, starzejące się lub niechciane zadania. Wszystko to, aby zwiększać efektywność naszego procesu wytwórczego.

                            Głównym narzędziem do zarządzania procesem wytwórczym w metodzie Kanban jest zmienianie limitów pracy w toku. Limit pracy w toku (WIP — Work In Progress) to maksymalna liczba zadań, które mogą być jednocześnie realizowane (w ramach jednego kroku procesu, określonego typu zadania lub przez jedną osobę). Zazwyczaj limit pracy w toku przypisuje się konkretnej kolumnie (czyli etapowi procesu), np. w etapie programowania może być maksymalnie 5 zadań.

                            Limity pracy w toku zmuszają pracowników do podejmowania innych prac.

                            Przykład 1

                            Kolumna Programowanie ma WIP równy 2 oraz są niej 2 zadania. Programista, chcąc pracować, może wziąć zadanie: Zadanie 106 z kolumny Do przetestowania i przetestować je.

                            TODO Programowanie (2) Do przetestowania Testowanie (2) Done
                            Zadanie 105

                            Zadanie 108

                            Zadanie 100

                            Zadanie 102

                            Zadanie 106 Zadanie 98

                            Przykład 2

                            Kolumna Programowanie ma WIP równy 2 oraz są niej 2 zadania. Kolumna Testowanie ma WIP równy 2 oraz w niej również są 2 zadania. Programista, chcąc pracować, może spróbować pomóc komuś wykonać zadanie (pomóc osobom robiącym zadania w kolumnie Programowanie) lub pomóc przetestować komuś jakieś zadanie (pomóc osobom robiącym zadania w kolumnie Testowanie).

                             

                            TODO Programowanie (2) Do przetestowania Testowanie (2) Done
                            Zadanie 105

                            Zadanie 108

                            Zadanie 100

                            Zadanie 102

                            Zadanie 98

                            Zadanie 106

                            Tablica pozwala nam łatwo wychwycić problemu i spróbować je naprawić. Bardzo ważne jest, aby przedstawiała ona faktyczną sytuację. Nie chcemy przecież tracić czasu na próbę naprawienia problemu, którego nie ma. Aby uniknąć takiej sytuacji, wszyscy członkowie z zespołu muszą regularnie aktualizować statusy zadań — pracować na tablicy zadań.

                            Chcemy również móc zauważyć, że jakiś problem pojawia się, aby później zdecydować, czy chcemy go naprawić. Ważne jest, aby nie było pracy ukrytej, tzn. wszystko, co robi zespół, było przedstawione na tablicy. Każda praca wykonywana w ramach naszego procesu wytwórczego powinna być na tablicy. Jeżeli czegoś na tej tablicy nie ma, to nie jesteśmy w stanie tego zmierzyć, a jeżeli czegoś nie mierzymy, to nie możemy tym zarządzać oraz tego optymalizować.

                            Zarządzanie przepływem obejmuje zajmowanie się takimi elementami:

                            • zatory,
                            • blokady,
                            • wąskie gardła,
                            • starzejące się zadania,
                            • brakujące etapy procesu,
                            • uszczegóławianie zadań i standardów związanych z danym etapem procesu,
                            • nadmiarowe etapy procesu,
                            • skomplikowane etapy procesu,
                            • płynność,
                            • wykresy,
                            • miary,
                            • jakość,
                            • ludzie,
                            • wielozadaniowość i zmiana kontekstu,
                            • wrzutki,
                            • awarie,
                            • metody pracy,
                            • odchylenia od normy lub średniej,
                            • limity WIP.

                            Narzędzia służące do zarządzania przepływem, to:

                            • tablica kanban i jej obserwacja,
                            • limity WIP,
                            • wykresy,
                            • miary,
                            • dyskusje,
                            • eksperymenty.

                            Zarządzanie przepływem ciągłe poprawianie systemu w kierunku coraz płynniejszego wykonywania pracy.

                            Wszystkie posty związane z mini projektem: Poznaj metodę Kanban:

                              Źródła

                              Obraz główny

                              Materiały

                              10 pomysłów na: biznes (w czasie kryzysu finansowego):

                              przez Karol Bocian | 19 marca, 2021

                              W ramach rozwijania moich zdolności kreatywnego myślenia przygotowałem listę 10 pomysłów.

                              10 pomysłów na: biznes (w czasie kryzysu finansowego):

                              1. Wyprzedaże garażowe.
                              2. Przygotowywanie grupowe posiłków w niższych cenach (np. jednego dnia tylko jedna zupa).
                              3. Uczenie o sposobach oszczędzania pieniędzy (oszczędzanie wody, prądu, benzyny).
                              4. Umożliwienie wspólnego inwestowania w produkty odporne na kryzys.
                              5. Aplikacja do wystawiania voucherów z odroczoną płatnością, ale wykorzystania teraz.
                              6. Umożliwienie rozwijania kompetencji najpotrzebniejszych obecnie na rynku (szkoła).
                              7. Umożliwienie znajdowania zatrudnienia w obecnej sytuacji (pośrednictwo pracy).
                              8. Umożliwienie pracy dla podmiotów / na rynku nieobjętym kryzysem.
                              9. Umożliwienie przeżycia przez dłuższy czas (np. magazyn z artykułami spożywczymi i środkami czystości, który wysyła co tydzień paczkę z rzeczami danej osoby, magazyn został uzupełniony na początku kryzysy, gdy inflacja była niska, a potem np. przez dwa lata umożliwia życie po kosztach z początku kryzysu pomimo rosnącej inflacji).
                              10. Odchudzanie procesów i optymalizacja kosztowa.

                              Wszystkie posty związane z kreatywnością:

                                Źródła

                                Obraz główny

                                10 pomysłów na: biznes (ze sztuczną inteligencją)

                                przez Karol Bocian | 19 marca, 2021

                                W ramach rozwijania moich zdolności kreatywnego myślenia przygotowałem listę 10 pomysłów.

                                10 pomysłów na: biznes (ze sztuczną inteligencją):

                                1. Aplikacja optymalizująca jakość snu.
                                2. Aplikacja optymalizująca dietę.
                                3. Aplikacja optymalizująca ćwiczenia sportowe.
                                4. Aplikacja optymalizująca naukę języka obcego.
                                5. Aplikacja optymalizująca relacje międzyludzkie.
                                6. Aplikacja optymalizująca korzystanie z social media.
                                7. Aplikacja optymalizująca regenerację i odpoczynek.
                                8. Aplikacja optymalizująca zadowolenie z życia.
                                9. Aplikacja optymalizująca osiąganie celów osobistych.
                                10. Robot sprzątający mieszkanie.

                                Wszystkie posty związane z kretywnością:

                                  Źródła

                                  Obraz główny

                                  Podsumowanie połowy projektu: Poznaj metodę Kanban

                                  przez Karol Bocian | 14 marca, 2020

                                  Podsumowanie połowy projektu: Poznaj metodę Kanban

                                  Za mną już połowa projektu: Poznaj metody Kanban.

                                  Za dużo blogowania

                                  W czasie jego trwania zauważyłem, że bardzo dużo czasu poświęcam na edytowanie treści i blogowanie. Postanowiłem więc, że radykalnie zmienię formę prowadzenia przeze mnie projektu. Przebudowałem listę zadań do wykonania: usunąłem zadania związane z pisaniem postów, dodawaniem lekcji do kursu mailowego, dodawanie treści do testu oraz do Anki.

                                  Obecna nauka

                                  Codziennie robię kolejne zadanie z listy zadań. Zadanie to zazwyczaj jeden temat dotyczący kanbana, np. reguła kanbana: Zarządzanie przepływem. W ramach tego zadania. Otwieram mój duży plik z notatkami o kanbanie i wpisuję tam notatki i hasła dotyczące danego tematu. Notatki tworzę na podstawie mojego doświadczenia oraz poznawanych treści (postów, książek oglądam filmy, słucham podcastów) skupiając się na danym zagadnieniu. Na taką naukę poświęcam około 30 minut.

                                  Tworzenie treści

                                  Innego dnia redaguję moje notatki z przerobionego tematu. Jest to forma powtórki zdobytej wiedzy. Następnie kopiuje duży plik, wycinam z niego wszystko oprócz jednego tematu i publikuję go oraz dodaję lekcje do kursu e-mailowego. Poświęcam na to około 30 minut.

                                  Podsumowanie

                                  1. Z 29 Mustów, zrobiłem 18. Zostało mi jeszcze 11 zadań.
                                  2. Czuję, że się uczę. Widzę, jak w praktyce mogę wykorzystać właśnie zdobywaną wiedzę.
                                  3. Zrobiłem jedną tablicę kanban dotyczącą mojego prywatnego życia (obszar: gra w 5 zadań) i korzystam z niej codziennie.
                                  4. Bywało stosunkowo wiele dni, kiedy nie chciało mi się usiąść do tego projektu. Muszę popracować nad moją dyscypliną oraz atrakcyjnością tego projektu. Udało mi się na szczęście nadgonić tematy!
                                  5. Przede mną szkolenie z kanbana, które będę prowadził. Planuję przedstawić tutaj prezentację z niego 🙂
                                  6. Muszę bardziej ustrukturyzować bardziej proces tej nauki: wybrać mniej rzeczy do robienia, ustalić limity czasowe na dane działania, np. 25 minut — zdobywanie nowej wiedzy, 20 minut — redagowanie treści z poprzedniego tematu, 5 minut — publikacja postu, 5 minut — dodanie lekcji, 5 minut — dodanie treści do Anki.

                                  Wszystkie posty związane z mini projektem: Poznaj metodę Kanban:

                                    Źródła

                                    Obraz główny

                                    10 pomysłów na: biznes (w czasie pandemii)

                                    przez Karol Bocian | 19 marca, 2021

                                    W ramach rozwijania moich zdolności kreatywnego myślenia przygotowałem listę 10 pomysłów.

                                    10 pomysłów na: biznes (w czasie pandemii):

                                    1. Robienie zakupów i przywożenie do domu.
                                    2. Wyprowadzanie psa, kota i innych zwierząt.
                                    3. Szkolenie i konsultacje on-line.
                                    4. Zajęcia z dziećmi on-line – śpiewanie, granie w gry, tańczenie, korepetycje.
                                    5. Dezynfekowanie i odkażanie miejsc i przedmiotów.
                                    6. Informowanie o stanie pandemii, sprawdzonych zaleceniach, jak należy postępować, sytuacji w okolicy (np. w sklepie X nie ma już chleba).
                                    7. Konsultacje i wdrożenia umożliwiające pracę zdalną.
                                    8. Odbieranie śmieci z domu i wyrzucanie do śmietnika.
                                    9. Organizowanie imprez, konferencji i dyskotek on-line.
                                    10.  Organizowanie hackatonów on-line.

                                    Wszystkie posty związane z kretywnością:

                                      Źródła

                                      Obraz główny

                                      Metoda Kanban – Ograniczanie pracy w toku

                                      przez Karol Bocian | 4 października, 2023
                                      Metoda Kanban – Ograniczanie pracy w toku

                                      Ograniczaj pracę cząstkową

                                      Ważnym pojęciem występującym w kanbanie jest praca cząstkowa, czyli praca, która jest obecnie wykonywana. Nazywa się ją pracą w toku i określa skrótem: WIP (ang. Work in Progress).

                                      Kanban wykorzystuje do optymalizowania procesu ograniczanie pracy w toku. Zazwyczaj realizowane jest to przez określenie liczbowej wartości będąca limitem liczby zadań dla wybranego etapu procesu. Np. możemy ustalić, że w kolumnie: aktualnie robione, możemy mieć maksymalnie 5 zadań.

                                      Cel ograniczania pracy w toku

                                      Ograniczanie pracy w toku ma na celu:

                                      • Minimalizowanie wielozadaniowości.
                                      • Minimalizowanie liczby przezbrojeń maszyn.
                                      • Minimalizowanie konieczności zmieniania kontekstu (przeskakiwania z jednego zadania na drugie wymaga ponowne wdrożenie się w to zadanie).
                                      • Zmniejszać opóźnień innych zadań (ponieważ aktualne robimy szybciej, pozostałe czekają na produkty tego zadania lub wykorzystywane obecnie zasoby).
                                      • Skracanie pętli zwrotnej (szybciej dostarczone zadanie pozwala wcześniej dostać informacje, czy należy coś poprawić).
                                      • Minimalizowanie niepotrzebnej produkcji (robienie zadania długo, może sprawić, że gdy już je zrobimy, to okaże się, że jest nieaktualne).
                                      • Zwiększanie jakości produktu (przeskakiwanie między zadaniami sprawia, że stresujemy się bardziej, śpieszymy się, musimy zmieniać kontekst i przypominać sobie, czego dotyczy inne zadanie i na czym skończyliśmy).
                                      • Minimalizowanie kosztów i kar opóźnień.
                                      • Minimalizowanie niewykorzystanych szans (zrobienie zadania później niż moglibyśmy je zrobić, może sprawić, że w czasie jego robienia nie zarabialiśmy pieniędzy, które byśmy mogli już zacząć zarabiać).
                                      • Ograniczanie marnotrawstwa.
                                      • Ograniczanie magazynowania.

                                      Możliwości ograniczania

                                      W kanbanie możemy ograniczać m.in.:

                                      • Liczbę zadań w danym etapie procesu (kolumnie).
                                      • Liczbę zadań danego typu (np. jedno zadanie z refaktoryzacji na tydzień).
                                      • Liczbę zadań z danego przepływu (np. maksymalnie jedno pilne zadanie na tydzień).
                                      • Wprowadzanie nowych tematów / produktów (np. robimy maksymalnie jeden projekt i zaczynamy następny, dopiero gdy skończymy obecny).
                                      • Liczbę zadań przydzielonych do danej osoby.
                                      • Liczbę zadań przydzielonych do danej maszyny lub stanowiska.

                                      Sterowanie limitami to balansowanie pomiędzy szybkim dostarczaniem zadania i nieobciążonymi zasobami (np. limit WIP w danym etapie procesu jest niższy niż liczba osób pracujących w tym etapie, więc nowe zadania od razu są przez kogoś podejmowane) a wolniejszym przepływem, ale w pełni obciążonymi zasobami (zadań jest więcej niż pracowników, więc każdy ma co robić).

                                      Zalecenia Kanbana

                                      Kanban radzi, aby:

                                      • Zacząć kończyć, a przestać zaczynać. Oznacza to, że należy skupić się na tym, aby jak najszybciej kończyć rozpoczęte zadania, a nie zaczynać ich jak najwięcej.
                                      • Patrzeć na tablicę od prawej, to lewej. Jest to związane z powyższą zasadą. Chcemy przede wszystkim kończyć zadania, a nie zaczynać nowe. Zadania, które niedługo mogą opuścić nasz proces, znajdują się z prawej strony tablicy. Jeżeli szukamy zadania do wykonania, a nasze kompetencje pozwalają na to, to powinniśmy brać zadania jak najbardziej z prawej strony, aby jak najszybciej je zakończyć.
                                      • Robić więcej, robiąc mniej. Oznacza to, że skupiamy się na kilku zadaniach (robimy mniej jednocześnie), ale ostatecznie robimy więcej (ponieważ nie tracimy czasu na magazynowanie, transportowanie do magazynu, przełączanie kontekstu, przezbrajanie).

                                      Kanban będzie pomagał nam optymalizować naszą pracę pod jednym warunkiem: musimy być zdyscyplinowani. Musimy na bieżąco aktualizować statusy zadań, umieszczać wszystko na tablicy (wszystkie zadania, etapy procesu, zmiany stanu zadań). Musimy wyeliminować pracę ukrytą, tzn. pracę, którą wykonujemy, ale nigdzie jej nie przedstawiamy. Taka praca zaburza nasze postrzeganie procesu za pomocą tablicy. Tablica, która nie przedstawia rzetelnie naszego procesu wytwórczego, okłamuje nas i może prowadzić do błędnych wniosków.

                                      Limity na początku można ustalić poprzez wybranie dużej liczby, np. liczba osób w zespole + 1, a następnie regularnie próbować je zmniejszać. Zmiana limitu może odbywać się na zasadzie eksperymentów: spróbujmy zmniejszyć to o połowę i sprawdźmy, jak będzie nam się pracowało i jakie będziemy otrzymywali wyniki przez dwa tygodnie. Po takim eksperymencie możemy zostawić wypróbowywany limit, wrócić do pierwotnego albo ustalić jeszcze inny. Ważne jest, aby regularnie nimi sterować. Limity służą znalezieniu optymalnego sposobu przepływu pracy: zadowolenie klienta, przyjemność z pracy, wysoka jakość produktu, dobrze wykorzystane zasoby. Zarządzanie w kanbanie oraz sterowanie limitami ma na celu zarządzanie pracą (i procesem produkcji), a nie ludźmi.

                                      Decyzję o zmianie limitów powinien podjąć cały zespół i powinien on go zaakceptować (nawet jeżeli ktoś się z tym nie zgadza, to i tak powinien go przestrzegać). Idealnie byłoby, gdyby zespoły pracujące w kanbanie były samozarządzalne i wszyscy członkowie brali odpowiedzialność za cały projekt (a nie tylko kierownik, szef, przełożony, etc.).

                                      Wszystkie posty związane z mini projektem: Poznaj metodę Kanban:

                                        Źródła

                                        Obraz główny

                                        Materiały

                                        Metoda Kanban – Wizualizacja

                                        przez Karol Bocian | 9 marca, 2020

                                        Metoda Kanban – Wizualizacja

                                        Zasady Systemu Kanban

                                        1. Wizualizuj przepływ.
                                        2. Ograniczaj pracę cząstkową.
                                        3. Zarządzaj przepływem.
                                        4. Uczyń zasady jasnymi.
                                        5. Stwórz pętle informacji zwotnej.
                                        6. Udoskonalaj i rozwijaj ekspermentalnie.

                                        Wizualizuj przepływ

                                        Kanban umożliwia zwizualizowanie wielu istotnych rzeczy związanych z pracą. Pozwala pokazać przede wszystkim: jaka praca (zadania) są robione, jak wygląda proces produkcji, kto się tym zajmuje oraz czy nie ma problemów z przepływem pracy.

                                        Do narzędzi wizualizacji należą:

                                        • Tablica kanbanowa.
                                        • Wykresy.
                                        • Plakaty.
                                        • Tablice ogłoszeniowe.
                                        • Kalendarze.
                                        Tablica kanbanowa

                                         

                                        Do zrobienia Oczekujące  W trakcie Zrobione
                                        Wynieść śmieci

                                        Pomalować ścianę

                                        Wymienić opony

                                        Złożyć regał Zrobić zakupy Zrobić obiad
                                        Zatamować cieknącą rurę

                                        Głównym narzędziem jest tablica kanbanowa. Zawiera ona kolumny oraz wiersze.

                                        Kolumny reprezentują konkretne etapy procesu wytwórczego. Najpopularniejsze etapy to: Do zrobienia, W trakcie pracy i Zrobione. Niektóre kolumny odpowiadają etapom, w których wykonywana jest praca (np. programowanie, W trakcie pracy), a inne są magazynami (np. Do zrobienia – magazynuje zadania, które chcemy podjąć w przyszłości).

                                        Pierwszy wiersz określa nazwy kolumn, czyli etapów procesu. Kolejne wiersze określają przepływy zadań. Większość tablic ma tylko jeden przepływ: podstawowy. Polega on na przejściu zadań przez wszystkie kolumny (etapy procesu). Niektóre tablice mają więcej wierszy, np. wiersz na zadania pilne, wiersz na poprawę małych błędów w oprogramowaniu. Takie przepływy mają inne zasady, niż przepływ podstawowy: np. pomijają niektóre kolumny. Są one wykorzystywane w sytuacjach wyjątkowych i ich użycie powinno być bardzo limitowane (w końcu jest to wyjątkowy przepływ).

                                        Patrząc na taką tablicę, możemy zobaczyć:

                                        • Ile zadań zostało zrobionych.
                                        • Ile jest w trakcie robienia.
                                        • Ile zadań jeszcze nie zostało podjętych.
                                        • Jak wygląda proces pracy.
                                        • Czy jakiś etap pracy jest pomijany.
                                        • Czy jakiś etap pracy wykonywany jest długo lub szybko.
                                        • Jaki jest status konkretnego zadania
                                        • Kto zajmuje się danym zadaniem (jeżeli mamy przypisane osoby do zadań).
                                        • Czym zajmuje się dana osoba.
                                        • Czy gdzieś mamy za dużo lub za mało zadań (np. czy tester ma co testować).
                                        • Czy nie mamy opóźnień.
                                        • Czy prace idą równomiernie.
                                        • Czy jakieś zadania realizowane są równolegle.
                                        • Czy ktoś wykonuje jednocześnie wiele zadań (multitasking).

                                        Tablica kanbanowa jest narzędziem informacyjnym oraz optymalizacyjnym.

                                        Ważne jest, aby ta tablica odzwierciedlała rzeczywistość. Potrzebna jest duża dyscyplina zespołu, aby regularnie aktualizował status zadań.

                                        Taka tablica może być postrzegana jako:

                                        1. Grzejnik informacyjny – tablica jest grzejnikiem, ponieważ cały czas przekazuje informacje zespołowi oraz istotnym interesariuszom. Jest ona łatwo dostępna i wszyscy zainteresowanie często i chętnie z niej korzystają.
                                        2. Lodówka informacyjna – tablica jest lodówką, ponieważ nie przekazuje zbyt często informacji, które posiada. Taka sytuacja ma miejsce, gdy dostęp do tablicy jest trudny, praca z tablicą jest nieprzyjemna lub zespół nie aktualizuje danych, o czym wszyscy wiedzą, więc nie korzystają z tablicy. Przykładem takiej tablicy jest tablica fizyczna umieszczona w biurze, gdy większość zespołu pracuje zdalnie. Innym przykładem jest tablica cyfrowa, do której dostęp jest trudny (wymagane jest logowanie, dostęp jest tylko z danego serwera, jest ustalony czas sesji, po którym następuje automatyczne wylogowanie).
                                        Wykresy

                                        Wykresy występujące w kanbanie mają na celu przekazać informacje, jak wygląda przebieg pracy, pomóc przewidzieć kiedy skończymy pracę, gdzie mamy problemy w procesie, jak możemy zoptymalizować nasz proces.

                                        Najpopularniejsze wykresy w kanbanie:

                                        • Burndown – wykres spalania. Pokazuje on, jak zmienia się liczba zadań do wykonania wraz z upływem czasu (zakładając, że w czasie trwania prac zadania nie dochodzą, krzywa z zadaniami do zrobienia zbliża się do 0.
                                        • Burnup – wykres pokazuje, jak zmienia się liczba zadań zrobionych wraz z upływem czasu.
                                        • Cumulative Flow – wykres pokazuje, jak zmienia się liczba zadań z poszczególnych etapów procesu wraz z upływem czasu.
                                        Plakaty i tablice ogłoszeniowe

                                        Plakaty i tablice ogłoszeniowe przekazują istotne informacje dla zespołu, np. wartości zespołu, spis dobrych praktyk, definicja ukończenia zadania, zasady jakości, zasady pracy z tablicą kanban, hasła motywacyjne, znane problemy i sposoby ich uniknięcia.

                                        Kalendarze

                                        Kalendarze mogą pomóc zespołowi samoorganizować się i dostarczać wyniki swojej pracy na czas. Mogą przedstawiać terminarze: planowanych urlopów, dostępności zespołu, planów wdrożeń, ważnych wydarzeń, szkoleń, imprez.

                                        Wszystkie posty związane z mini projektem: Poznaj metodę Kanban:

                                          0%
                                          10
                                          Utworzono

                                          Sprawdź swoją wiedzę i lepiej poznaj metodę Kanban!

                                          Cześć!
                                          Podaj proszę swoje imię i e-mail.
                                          Jeżeli nie chcesz tego robić, możesz zrobić test jako nieznajomy. Kliknij po prostu strzałkę dalej 🙂

                                          1 / 13

                                          Stwórz pętle informacji zwotnej

                                          2 / 13

                                          Udoskonalaj i rozwijaj eksperymentalnie

                                          3 / 13

                                          Uczyń zasady jasnymi

                                          4 / 13

                                          Ograniczaj pracę cząstkową

                                          5 / 13

                                          Kanbana możemy wykorzystać w:

                                          6 / 13

                                          Podstawowe zasady Kanban to:

                                          7 / 13

                                          Wizualizuj przepływ

                                          8 / 13

                                          Czym jest Kanban?

                                          9 / 13

                                          Zarządzaj przepływem

                                          10 / 13

                                          Celami metody Kanban jest "7 x żadnych", czyli

                                          11 / 13

                                          Na czym skupia się Kanban?

                                          12 / 13

                                          Kanban pasuje do środowisk, w których występuje któryś z tych elementów:

                                          13 / 13

                                          Jakie są zalety Kanbana?

                                          Twój wynik to

                                          Średni wynik to 25%

                                          0%

                                          Źródła

                                          Obraz główny

                                          Materiały

                                          Zasady Kanban

                                          przez Karol Bocian | 16 kwietnia, 2020

                                          Podstawowe zasady Kanban

                                          Podstawowe zasady Kanban to:

                                          1. Wizualizuj przepływ.
                                          2. Ograniczaj pracę cząstkową.
                                          3. Zarządzaj przepływem.
                                          4. Uczyń zasady jasnymi.
                                          5. Stwórz pętle informacji zwotnej.
                                          6. Udoskonalaj i rozwijaj ekspermentalnie.

                                          Wizualizuj przepływ

                                          Kanban umożliwia zwizualizowanie procesu wytwórczego, zadań, ich przepływu przez proces, problemów i stanu pracy. Wykorzystywana jest do tego tablica Kanban.

                                          Ograniczaj pracę cząstkową

                                          Limit pracy cząstkowej (WIP – Work In Progress) to wartość określająca, ile maksymalnie zadań może być w danym etapie procesu. Sterowanie tymi parametrami (limitów może być wiele, bo wiele może być etapów w procesie) jest głównym narzędziem do optymalizowania przepływu.

                                          Zarządzaj przepływem

                                          Zarządzaj pracą (a nie ludźmi) – należy obserwować przepływ zadań przez proces i reagować, gdy w którymś momencie on się blokuje.

                                          Uczyń zasady jasnymi

                                          Ustal jasne zasady pracy, określ definicje, co znaczy zadanie, jak zadania powinny przechodzić przez proces, co znaczy, że zadanie jest zakończone, co należy zrobić w poszczególnych etapach procesu.

                                          Stwórz pętle informacji zwotnej

                                          Stwórz mechanizm umożliwiający zbieranie informacji zwrotnej, wyciągania wniosków oraz wykorzystywania ich w dalszej pracy (m.in. aktualizowanie planów, rzeczy do zrobienia).

                                          Udoskonalaj i rozwijaj eksperymentalnie

                                          Stwórz mechanizm usprawniania swojego procesu oraz przeprowadzania eksperymentów mających na celu wprowadzenie usprawnień. Analizuj zmiany, wyciągaj wnioski, zostawiaj i wzmacniaj pozytywne zmiany i cofaj negatywne.

                                          Wszystkie posty związane z mini projektem: Poznaj metodę Kanban:

                                            0%
                                            10
                                            Utworzono

                                            Sprawdź swoją wiedzę i lepiej poznaj metodę Kanban!

                                            Cześć!
                                            Podaj proszę swoje imię i e-mail.
                                            Jeżeli nie chcesz tego robić, możesz zrobić test jako nieznajomy. Kliknij po prostu strzałkę dalej 🙂

                                            1 / 13

                                            Uczyń zasady jasnymi

                                            2 / 13

                                            Wizualizuj przepływ

                                            3 / 13

                                            Na czym skupia się Kanban?

                                            4 / 13

                                            Podstawowe zasady Kanban to:

                                            5 / 13

                                            Celami metody Kanban jest "7 x żadnych", czyli

                                            6 / 13

                                            Zarządzaj przepływem

                                            7 / 13

                                            Stwórz pętle informacji zwotnej

                                            8 / 13

                                            Jakie są zalety Kanbana?

                                            9 / 13

                                            Ograniczaj pracę cząstkową

                                            10 / 13

                                            Kanban pasuje do środowisk, w których występuje któryś z tych elementów:

                                            11 / 13

                                            Kanbana możemy wykorzystać w:

                                            12 / 13

                                            Czym jest Kanban?

                                            13 / 13

                                            Udoskonalaj i rozwijaj eksperymentalnie

                                            Twój wynik to

                                            Średni wynik to 25%

                                            0%

                                            Źródła

                                            Obraz główny

                                            Materiały

                                            Do czego i gdzie wykorzystywać metodę Kanban?

                                            przez Karol Bocian | 6 marca, 2020

                                            Kanbana możemy wykorzystać w:

                                            • Produkcji oprogramowania (IT).
                                            • Prowadzeniu bloga, kanału na You Tube, podcastu.
                                            • Codziennym życiu (wizyta u lekarza, zakupy, sprzątanie, wymiana opon).
                                            • HR.
                                            • Marketingu.
                                            • Call center.
                                            • Dziale prawnym.
                                            • Uczeniu się.

                                            Kanban pasuje do środowisk, w których występuje któryś z tych elementów:

                                            • Ciągła produkcja.
                                            • Trudno zaplanować jest pracę, bo spływa ona regularnie — obsługiwana jest kolejka pracy (utrzymanie produktu, zapytania kontrahentów).
                                            • Priorytety zadań dynamicznie się zmieniają.
                                            • Nie ma zespołu, lecz są osoby, które realizują dany proces (warto w takim przypadku wyznaczyć osobę odpowiedzialną za usprawnianie przepływu).
                                            • Nie są stosowane żadne metody zarządzania projektami lub zadaniami.
                                            • Nie jest znany przebieg procesu wytwórczego, a chcemy go usprawnić, ponieważ jest niezadowalający.

                                            0%
                                            10
                                            Utworzono

                                            Sprawdź swoją wiedzę i lepiej poznaj metodę Kanban!

                                            Cześć!
                                            Podaj proszę swoje imię i e-mail.
                                            Jeżeli nie chcesz tego robić, możesz zrobić test jako nieznajomy. Kliknij po prostu strzałkę dalej 🙂

                                            1 / 13

                                            Kanban pasuje do środowisk, w których występuje któryś z tych elementów:

                                            2 / 13

                                            Ograniczaj pracę cząstkową

                                            3 / 13

                                            Podstawowe zasady Kanban to:

                                            4 / 13

                                            Uczyń zasady jasnymi

                                            5 / 13

                                            Kanbana możemy wykorzystać w:

                                            6 / 13

                                            Stwórz pętle informacji zwotnej

                                            7 / 13

                                            Jakie są zalety Kanbana?

                                            8 / 13

                                            Na czym skupia się Kanban?

                                            9 / 13

                                            Zarządzaj przepływem

                                            10 / 13

                                            Udoskonalaj i rozwijaj eksperymentalnie

                                            11 / 13

                                            Czym jest Kanban?

                                            12 / 13

                                            Wizualizuj przepływ

                                            13 / 13

                                            Celami metody Kanban jest "7 x żadnych", czyli

                                            Twój wynik to

                                            Średni wynik to 25%

                                            0%

                                            Wszystkie posty związane z mini projektem: Poznaj metodę Kanban:

                                              Źródła

                                              Obraz główny

                                              Materiały

                                              Od dobrego do wielkiego – J. Collins

                                              przez Karol Bocian | 3 lipca, 2020

                                              Przeczytałem ostatnio kolejną książkę. W tym wpisie dzielę się informacjami, które w niej znalazłem oraz które wdrożyłem w swoim życiu. Staram się z każdej książki wdrażać minimum jedną rzecz.

                                              Wdrożyłem:

                                              1. Zacząłem proces określania:
                                                1. Co w stosunku do czego definiuje sukces w moim biznesie.
                                                2. Jaka jest moja Zasada Jeża.
                                                3. Jaki jest mój BHAG.
                                              2. Rozpocząłem pracę nad sobą — rozwijania siebie jako przywódcę poziomu 5.

                                              Książkę możesz kupić tutaj:

                                              Notatki:

                                              Uniwersalne zasady konieczne do transformacji organizacji z dobrej w wielką (doskonałą i osiągającą trwały sukces)

                                              1 Zdyscyplinowani ludzie

                                              1.1 Miej przywódcę poziomu 5

                                              Przywódca poziomu 5 jest przywódcą pozostałych poziomów (zdolny wykonawca, cenny członek zespołu, kompetentny menadżer, skuteczny przywódca) oraz jest:

                                              • Spokojny, zdeterminowany, ambitny, zdystansowany, pełen pokory, mocy, nieustraszony, nieugięty.
                                              • Nie ma dużego ego, charyzmy, postawy showmana.
                                              • Stawia sukces firmy ponad swoim sukcesem.
                                              • Zazwyczaj wcześniej był pracownikiem firmy.
                                              • Skromny — myśli: to zrobił mój zespół, a nie my; mieliśmy szczęście; rynek nam sprzyjał.
                                              • Używa techniki: okno i lustro. Patrzy przez okno (wskazując na innych ludzi) opowiadając o sukcesie. Patrzy w lustro (wskazując na siebie) opowiadając o porażce.
                                              1.2 Znajdź najpierw odpowiednich ludzi, a potem zdecydujcie, co robicie

                                              Należy wybrać odpowiednich ludzi, umieścić na odpowiednich stanowiskach, usunąć zbędnych, a potem szukać co chce się razem robić. Cechy charakteru (etyka pracy, zaangażowanie, charakter, inteligencja, wyznawane zasady) są najważniejsze (ciężko je zmienić), a nie wiedza i umiejętności (łatwo je nabyć).

                                              • Wybitni liderzy zatrudniali tylu utalentowanych ludzi, ilu mogli, a później znajdywali im stanowiska.
                                              • Właściwych ludzi nie trzeba motywować.
                                              • Nie trzeba płacić ludziom więcej, niż inne firmy, tylko tyle, co średnio płaci rynek.
                                              • Należy tworzyć system sprawiający, że właściwi ludzie będą chcieli przyjść i zostać, a niewłaściwi uciec.
                                              • Zatrudniasz najlepszych, inwestujesz w nich i akceptujesz, że niektórzy odejdą.
                                              • Zatrudniaj tylko najlepszych. Nie gódź się na zatrudnianie miernot. Rezygnuj z takich jak najszybciej.
                                              • Stwarzaj najlepszym ludziom optymalne warunki do ich rozwoju.

                                              2. Zdyscyplinowane myślenie

                                              2.1 Skonfrontuj się z wrogą rzeczywistością

                                              Pamiętaj o paradoksie Stockdale’a: Posiadaj niezachwianą wiarę w sukces bez względu na trudności i pokonuj wszelkie przeszkody.

                                              Przystosuj proces do wrogiej rzeczywistości. Nie rób rewolucji w swojej firmie, tylko cały czas dostosuj się do otoczenia, rozwijaj się nieprzerwanie krok po kroku. Twórz atmosferę prawdy: ludzie są wysłuchani, ich głos ma znaczenie i ważna jest prawda, a nie to, kto powiedział dane zdanie.

                                              Tworzenie atmosfery prawdy:

                                              1. Przewódź zadając pytania, a nie dają c odpowiedzi (pytania służą zrozumieniu rzeczywistości).
                                              2. Wprowadzaj dyskusję i dialog, a nie przymus (bądź moderatorem dyskusji).
                                              3. Szukaj przyczyn, a nie winnych.
                                              4. Wprowadź mechanizm czerwonej flagi — każdy może powiedzieć nawet najgorszą prawdę.
                                              2.2 Zasada Jeża

                                              Odpowiedź na pytania, które pozwolą Ci zrozumieć, co powinieneś robić:

                                              1. Co jest naszą pasją?
                                              2. W czym możemy być najlepsi na świecie?
                                              3. Co przynosi korzyści materialne?
                                              4. Co jest elementem wspólnym odpowiedzi na powyższe pytania? Będzie to BHAG, czyli wielki, niebezpieczny, zuchwały cel.

                                              Znając swój BHAG, należy w pełni skoncentrować się na jego osiągnięciu i odrzucić inne cele.

                                              Określ jeden jedyny wskaźnik ekonomiczny o formule: zysk przypadający na x, który systematycznie chcesz zwiększać, gdzie x jest czynnikiem mającym największy wpływ na Twój ekonomiczny motor.

                                              3 Zdyscyplinowane działanie

                                              3.1 Stwórz kulturę dyscypliny z etyką przedsiębiorczości

                                              Stwórz kulturę, podejmowania zdyscyplinowanego działania związanego wyłącznie z Zasadą Jeża:

                                              1. Daj swobodę i odpowiedzialność w ramach ściśle określonych granic.
                                              2. Znajdź zdyscyplinowanych ludzi gotowych do robienia wszystkiego, co konieczne.
                                              3. Twórz kulturę dyscypliny, a nie tyranię. Świeć przykładem (twarda kontrola, ścisła analiza).
                                              4. Konsekwentnie trzymaj się Zasady Jeża i rób tylko to, co jest przez nią określone. Usuwaj cele i działania spoza Zasady Jeża.
                                              5. Stwórz listę rzeczy, z których trzeba zrezygnować.
                                              3.2 Wykorzystaj technologiczne turbodoładowanie

                                              Technologia jest narzędziem, a nie celem. Nie skupiaj się na niej, lecz na biznesie. Technologia ma Ci pomóc osiągnąć cele.

                                              4 Koło zamachowe i spirala klęski

                                              Stwórz proces ciągłego rozwoju (ewolucji) przedsiębiorstwa w wielkie. Miej wewnętrzne dążenie do doskonałości i bycia w zwycięskim zespole. Nie rób rewolucji, lecz poprawiaj się z dnia na dzień małymi krokami. Nie podążaj za modą. Wielkie firmy miały dwa etapy: konstruowania (zbierania wiedzy) i przełomu (przekraczania granic).

                                              Książkę możesz kupić tutaj:

                                              Wszystkie posty związane z książkowymi wdrożeniami:

                                                Źródła

                                                Obraz główny

                                                Zdjęcia

                                                Materiały

                                                • Od dobrego do wielkiego — J. Collins

                                                Linki oznaczone (*) są linkami afiliacyjnymi. Jeżeli uważasz, że czerpiesz korzyści z mojej pracy, to kup coś korzystając z powyższego linku. Sprawi to, że dostanę prowizję z afiliacji.

                                                Kanban

                                                przez Karol Bocian | 4 marca, 2020

                                                Kanban

                                                W tym poście skupiłem się głównie na Kanbanie znanym z produkcji. W kolejnych postach będę skupiał się już tylko na Kanbanie wykorzystywanym w usługach.

                                                Charakterystyka

                                                Kanban jest metodą sterowania produkcji, oznaczającym również system informacyjny, system planowania, rozdziału i kontroli zadań.

                                                Głównym celem Kanbana jest organizowanie produkcji w taki sposób, aby każdy zasób produkował dokładnie tyle, ile jest obecnie potrzebne. Likwiduje on magazyny, ponieważ wszystko dostarczane i produkowane jest na czas.

                                                Podstawowym elementem Kanbana są karty kanban (formularze). Podróżują one wraz z zadaniami / półproduktami po kolejnych stanowiskach / etapach procesu w celu stworzenia produktu końcowego.

                                                Kanban w usługach

                                                Metodę Kanban znamy głównie jako tablicę z pionowymi kolumnami określającymi kolejne etapy procesu wytwórczego i karteczkami oznaczającymi zadania. Jest to system typu Pull (Ciągnij). Zamówienie klienta sprawia, że ostatni etap procesu dostaje sygnał, aby wysłać produkt. Przekazuje on sygnał do zrobienia produktu poprzedniemu etapowi. Ten przekazuje sygnał poprzedniemu etapowi, aby zrobił półprodukty. Sygnały przekazywane są tak aż do pierwszego etapu, który zaczyna gromadzić surowce i przekazywać drugiemu etapowi, a ten robi półprodukt i przekazuje dalej.

                                                Kanban w skupia się na:

                                                • Wizualizacji przepływu zadań.
                                                • Ograniczeniu pracy cząstkowej (WIP — Work in Progress)
                                                • Zarządzaniu przepływem.

                                                Tablica może wyglądać tak:

                                                TODO

                                                DOING

                                                DONE

                                                Cele Kanbana

                                                Główne cele:

                                                • Zapobieganie nadprodukcji.
                                                • Dostarczanie procesom konkretnych zleceń produkcyjnych.
                                                • Wizualizowanie pracy.
                                                • Umożliwienie ciągłego doskonalenie.

                                                Celami metody Kanban jest sytuacja:

                                                • Żadnych braków,
                                                • Żadnych opóźnień,
                                                • Żadnych zapasów,
                                                • Żadnych kolejek,
                                                • Żadnych bezczynności,
                                                • Żadnych zbędnych operacji technologicznych i kontrolnych,
                                                • Żadnych przemieszczeń.

                                                Zalety

                                                • Ograniczenie kosztów produkcji.
                                                • Duża elastyczność produkcji.
                                                • Brak produkcji na zapas.
                                                • Brak magazynów i eliminacja marnotrawstwa.
                                                • Zapewnienie ciągłości pracy.
                                                • Wzrost jakości prac.
                                                • Wzrost wydajności.
                                                • Spadek czasu wytworzenia produktu.

                                                Wady

                                                • Większe koszty transportowe.
                                                • Dostawcy muszą być bardziej dostępni.
                                                • Produkcja odbywa się w partiach o stałej wielkości.
                                                • Słaba odporność na wahania popytu.
                                                • Wymaga produkcji bezbrakowej i dużego zaangażowania pracowników.
                                                • Brak zapasów.

                                                Wymagania

                                                • Ciągła produkcja.
                                                • Zmniejszanie wielkości zapasów.
                                                • Produkcja wygładzona.
                                                • Redukcja i standaryzacja cykli transportowych.
                                                • Określenie adresów.
                                                • Konsekwentne zarządzanie pojemnikami partii.

                                                Zastosowanie

                                                • Produkcja elementów o wysokiej wartości i dokładnej znajomości popytu.
                                                • Usługi.
                                                • Procesy ciągłe.
                                                • Tworzenie i utrzymywanie oprogramowania.

                                                Sposób działania

                                                • Pracownik wykorzystuje opakowanie z partią półproduktów (robi zadania znajdujące się w jego kolumnie z zadaniami), a gdy skończy ją, przekazuje kartę z opakowania stanowisku, które je wytworzyło partie półproduktów. Jest to dla niego sygnał, aby zacząć robić kolejną partię.

                                                0%
                                                10
                                                Utworzono

                                                Sprawdź swoją wiedzę i lepiej poznaj metodę Kanban!

                                                Cześć!
                                                Podaj proszę swoje imię i e-mail.
                                                Jeżeli nie chcesz tego robić, możesz zrobić test jako nieznajomy. Kliknij po prostu strzałkę dalej 🙂

                                                1 / 13

                                                Na czym skupia się Kanban?

                                                2 / 13

                                                Zarządzaj przepływem

                                                3 / 13

                                                Podstawowe zasady Kanban to:

                                                4 / 13

                                                Kanban pasuje do środowisk, w których występuje któryś z tych elementów:

                                                5 / 13

                                                Wizualizuj przepływ

                                                6 / 13

                                                Czym jest Kanban?

                                                7 / 13

                                                Jakie są zalety Kanbana?

                                                8 / 13

                                                Ograniczaj pracę cząstkową

                                                9 / 13

                                                Uczyń zasady jasnymi

                                                10 / 13

                                                Celami metody Kanban jest "7 x żadnych", czyli

                                                11 / 13

                                                Stwórz pętle informacji zwotnej

                                                12 / 13

                                                Kanbana możemy wykorzystać w:

                                                13 / 13

                                                Udoskonalaj i rozwijaj eksperymentalnie

                                                Twój wynik to

                                                Średni wynik to 25%

                                                0%

                                                Wszystkie posty związane z mini projektem: Poznaj metodę Kanban:

                                                  Źródła

                                                  Obraz główny

                                                  Obrazy

                                                  Materiały

                                                  Mini kurs: Poznaj metodę Kanban – Zapisz się!

                                                  przez Karol Bocian | 13 stycznia, 2024

                                                  Cześć, zapraszam Cię do zapisania się na mini kurs: Poznaj metodę Kanban. W marcu 2020 roku zdecydowałem się, że chcę poprawić swoje umiejętności zarządzania pracą i zadaniami. Wziąłem więc książki do ręki i komputer, a potem codziennie przez 30 dni pracowałem z nimi.

                                                  W ramach mojej nauki napisałem posty na blogu oraz przygotowałem kilka testów, które pomagają zapamiętać zdobywaną wiedzę. Wszystkie te teksty i posty zebrałem w jednym miejscu. W prezentowanym Tobie mini kursie: Poznaj metodę Kanban.

                                                  Wszystkie posty związane z mini projektem: Poznaj metodę Kanban:

                                                    Obrazek nagłówka

                                                    Mini kurs: Poznaj zasady SOLID i OOP – Zapisz się!

                                                    przez Karol Bocian | 13 stycznia, 2024

                                                    Cześć, zapraszam Cię do zapisania się na mini kurs: Poznaj zasady SOLID i OOP. W lutym 2020 roku zdecydowałem się, że chcę poprawić swoje umiejętności programowania. Wziąłem więc książki do ręki i komputer, a potem codziennie przez 30 dni pracowałem z nimi.

                                                    W ramach mojej nauki napisałem posty na blogu oraz przygotowałem kilka testów, które pomagają zapamiętać zdobywaną wiedzę. Wszystkie te testy i posty zebrałem w jednym miejscu. W prezentowanym Tobie mini kursie: Poznaj zasady SOLID i OOP.

                                                    Obrazek nagłówka

                                                    Początek mini projektu: Poznaj metodę Kanban

                                                    przez Karol Bocian | 13 stycznia, 2024

                                                    Cele i ramy czasowe

                                                    Rozpoczynam dziś kolejny mini projekt. Codziennie (oprócz niedziel) przez najbliższy miesiąc będę poświęcał na ten projekt 1 godzinę. Jego celem jest poprawienie swojej znajomości metody Kanban, czyli metody zarządzania pracą, którą bardzo lubię ze względu na jej dużą uniwersalność.

                                                    Dlaczego 1 miesiąc? Dlaczego 1 godzina dziennie?

                                                    Słyszałem, że wystarczy przez 3 miesiące poświęcać danej tematyce 20 minut dziennie, czyli poświęcić 90 * 20 min. = 1800 minut, czyli 30 godzin, aby zostać zaawansowanym amatorem. Ja wolałem przeznaczyć po jednej godzinie w jednym miesiącu, aby rozwinąć swoje umiejętności. W marcu poświęcę na ten projekt 24 godziny.

                                                    Zadania — priorytety

                                                    Wypisałem zadania, które mam wykonać w ramach tego projektu oraz przydzieliłem im priorytety. Skorzystałem z metody MoSCoW (opisanej m.in. tutaj: https://kierownikprojektu.com/2016/09/05/jak-okreslic-co-jest-wazne-moscow/). Won’ty (Would have) potraktowałem jako coś, co byłoby fajnie zrobić, jeżeli wszystko inne zostanie zrobione, a zostanie mi jeszcze na to czas.

                                                    Musty

                                                    Moimi najważniejszymi zadaniami jest poznać metodę Kanban, przećwiczyć ją w praktyce, zrobić z niej testy oraz wpisać najważniejsze rzeczy do mojego systemu wiedzy na całe życie (Anki).

                                                    Shouldy

                                                    Jeżeli będę miał odpowiednio dużo czasu, to będę pisał posty o metodzie Kanban.

                                                    Couldy

                                                    W ramach tego priorytetu zaplanowałem zrobienie kursu e-mail.

                                                    Won’ty (Would have)

                                                    Jeżeli niespodziewanie zostanie mi jeszcze trochę czasu, to… nie planowałem żadnych zadań o tym priorytecie.

                                                    W skrócie

                                                    Mój projekt rozpisałem w niezawodnym Excelu i wygląda następująco:

                                                    Do usłyszenia!

                                                    .

                                                    Wszystkie posty związane z mini projektem: Poznaj metodę Kanban:

                                                      Źródła

                                                      Obraz główny

                                                      Obrazy

                                                      • praca własna

                                                      Podsumowanie zasad SOLID i OOP

                                                      przez Karol Bocian | 1 marca, 2020

                                                      Zakończyłem mój mini projekt: Poznaj zasady SOLID i OOP. W tym wpisie zbieram je wszystkie:

                                                      Single responsibility principle – Zasada jednej odpowiedzialności

                                                      Każda klasa powinna mieć tylko jedną odpowiedzialność (czyli tylko jeden powód do modyfikacji klasy) – jeden cel istnienia.

                                                      Open/closed principle – Zasada otwarte-zamknięte

                                                      Wszystkie klasy powinny być otwarte na rozszerzenia, ale zamknięte na modyfikacje.

                                                      Liskov substitution principle – Zasada podstawienia Liskov

                                                      Oprogramowanie powinno dobrze działać, gdy w miejsce klasy bazowej podstawimy jej którąkolwiek klasę potomną.

                                                      Interface segregation principle – Zasada segregacji interfejsów

                                                      Wiele dedykowanych i małych interfejsów jest lepsze niż jeden ogólny.

                                                      Dependency inversion principle – Zasada odwróconej zależności

                                                      Wysokopoziomowe moduły nie powinny zależeć od modułów niskopoziomowych, lecz zależność powinna wynikać z abstrakcji.

                                                      Podstawowe założenia programowania obiektowego

                                                      Hermetyzacja

                                                      Hermetyzacja polega na ukryciu szczegółów implementacji. Obiekty przedstawiają publiczny interfejs, który mogą wywoływać inne obiekty. Obiekt może zmieniać tylko swój stan. Nikt inny nie może tego robić.

                                                      Dziedziczenie

                                                      Mechanizm dający możliwość tworzenia wyspecjalizowanych obiektów na podstawie obiektów ogólniejszych. Pozwala to współdzielić funkcjonalności. Obiekt wyspecjalizowany może wykorzystywać część definicji obiektu ogólniejszego i rozszerzać go lub zmieniać.

                                                      Polimorfizm

                                                      Mechanizm umożliwiający traktowanie różnych obiektów w jeden sposób dziedziczących tę samą klasę.

                                                      Abstrakcja

                                                      Obiekty są modelami abstrakcyjnych bytów, które wykonują powierzone im zadania bez zdradzania, jak te działania są realizowane. Przedstawiają one uproszczenie danego zagadnienia.

                                                      KISS — Keep it simple, stupid — Bez udziwnień zapisu, idioto (BUZI)

                                                      Twórz rozwiązanie w sposób jak najprostszy.

                                                      Lod — Law of Demeter, czyli Prawo Demeter (Zasada minimalnej wiedzy / Reguła ograniczenia interakcji)

                                                      Rozmawiaj tylko z bliskimi przyjaciółmi.

                                                      DRY — Don’t repeat yourself — Nie powtarzaj się

                                                      Nie powtarzaj tego samego rozwiązania.

                                                      SLAP — Single Level of Abstraction Principle — Pojedynczy poziom abstrakcji

                                                      Wszystkie linie kodu w metodzie powinny mieć ten sam poziom abstrakcji. Nie można mieszać niskopoziomowych i wysokopoziomowych detali w jednej metodzie.

                                                      Composition Over Inheritance — Kompozycja ponad dziedziczeniem

                                                      Lepiej korzystać jest z kompozycji (klasa A używa klasy B) zamiast dziedziczenia po klasie.

                                                      Encapsulate what may change — Ukrywaj zmieniające się rzeczy

                                                      Ukrywaj zmieniające się rzeczy pod stabilnym interfejsem.

                                                      Wszystkie posty związane z mini projektem: Poznaj zasady SOLID i OOP:

                                                        Źródła

                                                        Obrazek nagłówka

                                                        Obrazki

                                                        Podsumowanie projektu: Poznaj zasady SOLID i OOP

                                                        przez Karol Bocian | 13 stycznia, 2024

                                                        Dzisiaj zakończyłem mini projekt: Poznaj Zasady SOLID i OOP. Pora zatem na podsumowanie i trochę przemyśleń.

                                                        Cel projektu

                                                        Poznanie zasad SOLID i OOP — cel został osiągnięty. Świadczą o tym napisane posty:

                                                        Poznałem kilka zasad, przypomniałem sobie już mi znane, zacząłem zwracać większą uwagę na jakość kodu i wykorzystanie w praktyce tych zasad.

                                                        Trójkąt projektu

                                                        Projekt składa się z trzech elementów (wg teorii trójką projektu): czas, pieniądze i zakres. Omawiam je poniżej.

                                                        Budżet

                                                        Budżet projektu był 0 zł (oprócz kosztu prądu) i taki udało się zachować. Materiały, z których skorzystałem, były darmowe lub kupione przeze mnie już kiedyś.

                                                        Planowałem wykorzystać 28 godzin mojego czasu wolnego. Nie policzyłem, ile dokładnie czasu poświęciłem na ten projekt, szacuję, że jest to około 28 godzin.

                                                        Czas

                                                        Projekt realizowałem przez 28 dni (cały luty minus jeden dzień wolnego od projektu). Nie robiłem go jednak codziennie. Zdarzyły mi się w tym miesiącu kilkudniowe wyjazdy oraz czasami po prostu miałem dość tego projektu.

                                                        Zakres

                                                        Stan zadań wygląda następująco:

                                                        MOSCOW

                                                        L. zadań

                                                        L. zrobionych zadań

                                                        L. zadań do zrobienia

                                                        Must

                                                        38

                                                        38

                                                        0

                                                        Should

                                                        21

                                                        21

                                                        0

                                                        Could

                                                        24

                                                        24

                                                        0

                                                        Won’t

                                                        0

                                                        0

                                                        0

                                                        Razem

                                                        83

                                                        83

                                                        0

                                                        Zrobiłem wszystkie zadania! W czasie projektu zmieniłem jednak lekko plan i usunąłem 3 zadania typu should (były to zadania z napisaniem posta i zrobienia lekcji przy temacie ćwiczenia w praktyce danego zagadnienia — uznałem to za zbędne).

                                                        Muszę przyznać, że nie zawsze robiłem dany temat w 1 godzinę. Czasem robiłem go szybciej, a czasem dłużej.

                                                        Ocena

                                                        Jestem zadowolony z tego projektu. Przypomniałem sobie kilka rzeczy, zrobiłem Kata (i chyba będę je robił regularnie). Rozpocząłem tworzenie bloga w języku angielskim. Zacząłem gromadzić swoją wiedzę w systemie umożliwiającym zapamiętywanie jej na całe życie (Anki). A jaka jest Wasza ocena tego projektu?

                                                        Najważniejsze osiągnięcia

                                                        Za najważniejsze osiągnięcia związane z tym projektem uważam:

                                                        • Odświeżenie zasad SOLID, wykorzystywanie ich w pracy oraz zwiększenie dbałości o kod.
                                                        • Usprawnienie tworzenia postów oraz kursu e-mailowego.
                                                        • Rozpoczęcie tłumaczenia bloga na angielski i tworzenia treści w tym języku.

                                                        Przemyślenia

                                                        • Wolne niedziele: Robienie tego projektu codziennie przez miesiąc godzinę dziennie (w dodatku zazwyczaj o 5 rano) jest dla mnie ogromnym obciążeniem psychicznym. Potrzebuje trochę wolnych dni. Wprowadzam do przyszłych projektów wolne niedziele! Więcej praktyki, mniej blogowania
                                                        • Większe zagadnienia: Niektóre tematy wymagają sporo czasu na zapoznanie się z nimi. Ciężko jest to przewidzieć, gdy temat jest nowy. W kolejnym miesiącu zaplanuję dwa dni, które nie będą miały konkretnego tematu, lecz będą dniem, w którym kończę jakiś rozpoczęty większy temat.
                                                        • Praktyka ponad blogowaniem: Za dużo uwagi skupiłem na pisaniu postów. Wykorzystuje to kilka technik skutecznego uczenia się (metoda nauczyciela, majstersztyku, walenia). Czuję jednak, że jakość wielu tych postów jest niska oraz nie jest to najlepszy sposób na zdobywanie wiedzy. Postaram się w kolejnych miesiącach skupiać się więcej na zastosowaniu wiedzy w praktyce i zbudowaniu systemu umożliwiającego mi korzystanie ze zdobytej wiedzy przez lata.
                                                        • System zapamiętywania: Zacząłem umieszczać zdobywaną wiedzę w Anki. Wrzucam tam wszystko, czego się nauczyłem (i uważam to za istotne). Mechanizm zaszyty w Anki wymusi na mnie regularne powtarzanie zdobytej wiedzy i pamiętanie jej przez całe życie.
                                                        • Testy: w tym projekcie nie robiłem na blogu testów. Korzystałem z Anki. Postaram się jednak je dodawać (niekoniecznie jako oddzielny post). Są dobrym sposobem na sprawdzenie, czy dobrze przyswoiliśmy wiedzę.

                                                        Plany na przyszłość

                                                        Kanban

                                                        W kolejnym mini projekcie będę uczył się metody zarządzania pracą — Kanban.

                                                        Rozwój

                                                        W kolejnych miesiącach będę na przemian rozwijał się w następujących tematach:

                                                        • stawanie się ekspertem w obszarze IT i programowania (w ramach projektu: 4 Tygodniowy Ekspert IT),
                                                        • stawanie się ekspertem w obszarze zarządzania (w ramach projektu: 4 Tygodniowy Ekspert Zarządzania),
                                                        • stawanie się zaawansowanym amatorem w różnych obszarach (nie zawsze amatorem :)) np. szybkie czytanie, sprzedawanie, efektywne komunikowanie (w ramach projektu: 4 Tygodniowy Zaawansowany Amator).

                                                        Koniec

                                                        Projekt zakończony. Pora na głęboki oddech, chwilę wytchnienia. Jutro robię sobie dzień wolny, a w poniedziałek ruszam z nowym projektem. Zapraszam do śledzenia moich poczynań!

                                                        Wszystkie posty związane z mini projektem: Poznaj zasady SOLID i OOP:

                                                          Źródła

                                                          Obrazek nagłówka

                                                          Obrazki

                                                          Encapsulate what changes, czyli Ukrywaj zmieniające się rzeczy

                                                          przez Karol Bocian | 1 marca, 2020

                                                          Encapsulate what may change, czyli Ukrywaj zmieniające się rzeczy

                                                          Zasada mówi, aby ukrywać zmieniające się rzeczy pod stabilnym interfejsem.

                                                          Przykłady:

                                                          Bilety: Ukrycie warunku np. czy bilet jest ważny w oddzielnej metodzie.

                                                          Zwierzęta: Zwierzęta (Pies, Kot) dają głos. Tworzymy klasę, która sprawia, że wszystkie zwierzęta (ZwierzecyKoncert) dają głos. Ma ona metodę, w której sprawdza, jakiego typu jest dane zwierze i wtedy daje odpowiedni głos.

                                                          Możemy implementację dawania głosu przenieść do klas Pies i Kot oraz stworzyć interfejs IZwierzęDajęceGłos. Nasze zwierzęta implementują ten interfejs, a klasa odpowiedzialna za dawanie głosu przez wszystkie zwierzęta tylko iteruje po liście zwierząt i woła na nich metodę DajGłos. Jeżeli dodamy nowe zwierzę, to jedynie dodamy nową klasę, a nie będziemy musieli zmieniać takich klas, jak ZwierzecyKoncert.

                                                          Zalety

                                                          • Mniej miejsc w kodzie trzeba zmodyfikować podczas wprowadzania zmiany.
                                                          • Klienci uzależnieni są od abstrakcji, a nie od szczegółów implementacyjnych (zasada Odwrócenia zależności).
                                                          • Łatwiejsze testowanie.
                                                          • Łatwiejsze utrzymanie.

                                                          Wady

                                                          • Należy tworzyć abstrakcje.

                                                          Wszystkie posty związane z mini projektem: Poznaj zasady SOLID i OOP:

                                                          [catlist name=”projekt-poznaj-zasady-solid-i-oop” pagination=yes orderby=date order=asc author=no numberposts=100]

                                                          Źródła

                                                          Obraz główny

                                                          Materiały

                                                          Composition Over Inheritance, czyli Kompozycja ponad dziedziczeniem

                                                          przez Karol Bocian | 1 marca, 2020

                                                          Composition Over Inheritance, czyli Kompozycja ponad dziedziczeniem

                                                          Zasada mówi, że lepiej korzystać jest z kompozycji (klasa A używa klasy B) zamiast dziedziczenia po klasie. Stosując dziedziczenie, należy pamiętać, aby nie złamać Zasady podstawienia Liskov.

                                                          Zasada nie mówi, że mamy całkowicie zrezygnować z dziedziczenia.

                                                          Przykład:

                                                          Mamy Pracownika i Kierownika.

                                                          Dziedziczenie: Obaj mają imię i nazwisko. Mogą oni dziedziczyć po klasie Pracownik.

                                                          Kompozycja: Obaj mają wyliczaną pensję. Tutaj lepiej jest wstrzyknąć w Pracownika i Kierownika klasę, która odpowiada za wyliczenie ich pensji.

                                                          Zalety

                                                          • Mniejsza zależność między klasami.
                                                          • Rozbicie klas na mniejsze (rozbicie odpowiedzialności na różne klasy).
                                                          • Łatwiej zachować zgodność z zasadami SOLID.
                                                          • Łatwiejsze testowanie kodu.

                                                          Wady

                                                          • Czasem lepiej zastosować dziedziczenie.

                                                          Wszystkie posty związane z mini projektem: Poznaj zasady SOLID i OOP:

                                                          [catlist name=”projekt-poznaj-zasady-solid-i-oop” pagination=yes orderby=date order=asc author=no numberposts=100]

                                                          Źródła

                                                          Obraz główny

                                                          Materiały

                                                          Zostań Drapieżnikiem — R. Mazur, M. Osman

                                                          przez Karol Bocian | 3 lipca, 2020

                                                          Przeczytałem ostatnio kolejną książkę. W tym wpisie dzielę się informacjami, które w niej znalazłem oraz które wdrożyłem w swoim życiu. Staram się z każdej książki wdrażać minimum jedną rzecz.

                                                          Zostań Drapieżnikiem

                                                          Ta książka jest tak przepełniona wiedzą i tezami, z którymi się zgadzam, że nie mogłem zdecydować się, co wybrać, więc wybrałem wiele wątków i tematów.

                                                          Wdrożyłem:

                                                          1. Przed rozpoczęciem projektu lub zadania, zadaję sobie pytanie: PO CO to robię? Dodałem to pytanie m.in. do arkusza wykorzystywanego w zarządzania moimi mini projektami.
                                                          2. Nie być negatywnym, tylko czasem zamknąć się, aby miło spędzić czas. Nie każda rozmowa musi kończyć się kłótnią.
                                                          3. Życie to gra. Codziennie wygrywam dzień, bo uczę się wygrywania. Codziennie osiągam cele, bo uczę się osiągania. 
                                                          4. Stawiam hipotezy i sprawdzam je.
                                                          5. Staram się płacić sobie za efekty, a nie za pracę.

                                                          Książkę możesz kupić tutaj:

                                                          Notatki:

                                                          Nauka

                                                          Podczas uczenia się, znajduj odpowiedzi na pytania:

                                                          • Jaki to ma związek ze mną?
                                                          • Jak mogę wprowadzić to od razu w życie?
                                                          • Czy to uczenie się, to narzędzie, czy cel sam w sobie?

                                                          Słuchanie, czytanie i uczenie się to prokrastynacja. Przygotowanie do działania to prokrastynacja. Prokrastynacja przesuwa na później moment próby, sprawdzenia i wykazania się. Jest wynikiem strachu przed porażką. Obranie dobrego kierunku jest sposobem na walkę z prokrastynacją, ponieważ osiąganie celów, które nie mają sensu, jest bez sensu! Wybierając aktywność, pamiętaj, aby nie tracić pieniędzy, czasu, energii i nie marnować potencjału.

                                                          Trening zwyciężania

                                                          Zmieniaj się z dnia na dzień. Stabilność nie istnieje, bo zmienia się świat cały czas (Ty też się starzejesz, więc też się zmieniasz). Rozwijaj się i pracuj (nad sobą, projektem) krok po kroku. Znajduj elementy, które zmieniły się i które osiągnąłeś – szukaj dowodów swojego postępu. Trenuj się w ciężkiej pracy i regularnym posuwaniu się naprzód. Rób to mądrze i sprytnie, nie działaj tylko dla samego działania. 

                                                          Życie to trening: trenujesz przegrywanie, to przegrywasz, trenujesz odkładanie na później, to odkładasz, trenujesz szukania wymówek, to stajesz się mistrzem w szukaniu wymówek, trenujesz dyscyplinę i wygrywanie, to … Im częściej pokonujesz opór, tym on staje się słabszy, a Ty silniejszy. Należy codziennie wygrywać, być nieustępliwym i zdystansowanym. Odpuszczaj w walkach bez znaczenia, ale bądź nieustępliwych w ważnych bitwach.

                                                          Motywacja

                                                          Motywacja to stan emocjonalny, bardzo chwiejny, niezarządzalny, zmienny. Nie warto na nim polegać. Lepiej nauczyć się czerpania przyjemności z pracy, nauczyć się robić coś na siłę albo sposobem. 

                                                          Motywuje nas strach oraz pragnienie. Często robimy coś, co musimy, a nie coś, co powinniśmy. Możemy to wykorzystać, tworząc motywatory oparte na strachu, przymusie, uznaniu, wyrzutach sumienia oraz ludziach. Na przykład, możemy publicznie założyć się z kimś, że jeżeli czegoś nie zrobimy, to stracimy coś ważnego, w tym również szacunek i uznanie innych (bo okazaliśmy się kimś, kto nie był w stanie tego zrobić). 

                                                          Biznesowa gra

                                                          Życie i biznes można traktować jak eksperyment: stawiać hipotezę i testować ją (np. sposobem X sprzedam w tym miesiącu 5 odkurzaczy). W takim kontekście nie ma porażki, lecz nauka, że dana hipoteza nie jest prawdziwa. 

                                                          Nie powtarzaj tylko drogi innych do osiągniętego sukcesu, ale również unikaj elementów, które doprowadziły pozostałych do sukcesu (usuwanie negatywności).

                                                          Szukaj utalentowanych ludzi i otaczaj się takimi. Nie czuj się od nich gorszy, tylko razem budujcie wartość (Ty też masz jakieś talenty). Buduj zespół i wspólnie osiągajcie cele.

                                                          Nasze życie i przyszłość zależy od naszej interpretacji otaczającego nas świata.

                                                          Największa przegrana to brak walki – udpuszczenie na samym starcie.

                                                          Świetny sprzedawca potrafi słuchać i rozpoznawać potrzeby. Jest jak lekarz: diagnozuje problem, sprawdza jego konsekwencje, uzmysławia je pacjentowi, leczy. Podczas słuchania pamiętaj, że to, co sobie myślisz, jest czymś innym, niż to, co myśli rozmówca.

                                                          Książkę możesz kupić tutaj:

                                                          Wszystkie posty związane z książkowymi wdrożeniami:

                                                            Źródła

                                                            Obraz główny

                                                            Materiały

                                                            • Zostań Drapieżnikiem — R. Mazur, M. Osman

                                                            Linki oznaczone (*) są linkami afiliacyjnymi. Jeżeli uważasz, że czerpiesz korzyści z mojej pracy, to kup coś korzystając z powyższego linku. Sprawi to, że dostanę prowizję z afiliacji.

                                                            SLAP — Single Level of Abstraction Principle, czyli Pojedynczy poziom abstrakcji

                                                            przez Karol Bocian | 1 marca, 2020

                                                            Zasada pojedynczego poziomu abstrakcji

                                                            Wszystkie linie kodu w metodzie powinny mieć ten sam poziom abstrakcji. Nie można mieszać niskopoziomowych i wysokopoziomowych detali w jednej metodzie.

                                                            Zalety

                                                            • Większa czytelność kodu.
                                                            • Łatwiejsze zrozumienie kodu.

                                                            Wady

                                                            • Większa liczba metod i klas.

                                                            Wszystkie posty związane z mini projektem: Poznaj zasady SOLID i OOP:

                                                              Źródła

                                                              Obraz główny

                                                              Materiały

                                                              DRY — Don’t repeat yourself, czyli Nie powtarzaj się

                                                              przez Karol Bocian | 25 lutego, 2020

                                                              DRY zaleca nie powtarzać tego samego rozwiązania.

                                                              Dotyczy to powtarzania tego kodu, sposobu rozwiązania, czynności.

                                                              Powtarzające działania można automatyzować, powtarzający się kod można wydzielać i odwoływać się, powtarzające wzorce można uogólniać.

                                                              Zaletą stosowania zasady DRY jest unikanie błędów i oszczędność czasu:

                                                              • Błąd w skopiowanym w wielu miejscach fragmencie kodu trzeba poprawić wszędzie.
                                                              • Podczas manualnego wykonywania zadania łatwo o pomyłkę. Automatyczny skrypt nie pomyli się przy kolejnych wykonaniach i wykona pracę za nas.

                                                              Wszystkie posty związane z mini projektem: Poznaj zasady SOLID i OOP:

                                                                Źródła

                                                                Obraz główny

                                                                Materiały

                                                                Lod — Law of Demeter, czyli Prawo Demeter

                                                                przez Karol Bocian | 29 lutego, 2020

                                                                Prawo Demeter (Zasada minimalnej wiedzy / Reguła ograniczenia interakcji)

                                                                Rozmawiaj tylko z bliskimi przyjaciółmi.

                                                                Należy unikać wywołań typu: Name = School.GetWorkers().GetPersonData().GetName(). Metoda jakiegokolwiek obiektu może wywoływać metody:

                                                                • Swojego obiektu.
                                                                • Argumentów swoich metod.
                                                                • Obiektów, które sam tworzy.
                                                                • Pól swojego obiektu.

                                                                Zalety

                                                                • Mniejsza zależność między klasami i modułami.
                                                                • Łatwiejsze utrzymanie kodu.
                                                                • Brak konieczności znania szczegółów wywoływanych obiektów.

                                                                Wady

                                                                • Klasy muszą mieć więcej metod.

                                                                Wszystkie posty związane z mini projektem: Poznaj zasady SOLID i OOP:

                                                                  Źródła

                                                                  Obraz główny

                                                                  Materiały

                                                                  Anki – sposób na zapamiętanie na całe życie

                                                                  przez Karol Bocian | 1 maja, 2020

                                                                  Słyszałeś kiedyś o Anki? Jest to aplikacja wykorzystująca:

                                                                  • Fiszki (kartę, na której awersie wpisane jest hasło, słowo, nazwa zasady, a na rewersie wyjaśnienie, definicja, pojęcie, zasada).
                                                                  • Mechanizm przypominania oparty o krzywą zapominania – po nauczeniu się nowych fiszek, program sprawdza co jakiś czas, czy nadal pamiętamy dane zagadnienie. Jeżeli pamiętamy, to program zapyta na znowu o to, ale za dużo dłuższy czas. Jeżeli nie pamiętamy, to program uzna, że nie pamiętamy pojęcia i zapyta nas o to niebawem.

                                                                  Ja używam wersji webowej anki: https://ankiweb.net/. Dodaję do swojej tablicy wiedzę, którą regularnie zdobywam. Codziennie staram się zrobić jedną sesję przypominania (maksymalnie 100 fiszek dziennie).

                                                                  Z całego serca polecam Ci, abyś też skorzystał z tej metody:

                                                                  • Gromadź całą wiedzę, której się uczysz, w jednym miejscu.
                                                                  • Regularnie powtarzaj całą zdobywaną wiedzę (najlepiej wykorzystując mechanizm oparty o krzywą zapominania).

                                                                  Wszystkie posty związane z narzędziami:

                                                                    Źródła

                                                                    Obraz główny

                                                                    KISS — Keep it simple, stupid, czyli Bez udziwnień zapisu, idioto (BUZI)

                                                                    przez Karol Bocian | 24 lutego, 2020

                                                                    Reguła KISS zaleca tworzenie rozwiązania w sposób jak najprostszy.

                                                                    Należy utrzymać elegancką, przejrzystą strukturę niezawierającą udziwnień, niepotrzebnych elementów oraz unikać przerostu formy nad treścią.

                                                                    Jej stosowanie ma na celu: ułatwienie zrozumienia rozwiązania, jego późniejszego utrzymania i rozwoju, np. programu komputerowego.

                                                                    W Polsce stosowany jest akronim BUZI (odzwierciedla angielskie słówko kiss) – Bez Udziwnień Zapisu, Idioto.

                                                                     

                                                                    Wszystkie posty związane z mini projektem: Poznaj zasady SOLID i OOP:

                                                                      Źródła

                                                                      Obraz główny

                                                                      Materiały

                                                                      Filmiki? No nie wiem

                                                                      przez Karol Bocian | 21 lutego, 2020

                                                                      Cześć!

                                                                      Zastanawiałem się ostatnio, czy zacząć nagrywać filmiki.

                                                                      Co o tym myślisz? Czy chciałbyś słuchać, co u mnie słychać i jak podążam moją życiową drogą? Chcesz oglądać, czego ostatnio się nauczyłem oraz jak wpływa to na moje życie? Chcesz poznać moje cele, marzenia i spojrzenie na świat?

                                                                      Chcesz wiedzieć, co mówię na tym filmie? Daj mi znać! Jestem bardzo ciekawy Twojej opinii 🙂

                                                                      Napisz w komentarzu swoje zdanie!

                                                                       

                                                                       

                                                                       

                                                                      OOP — Object Oriented Programming, czyli programowanie obiektowe — Modelowanie dziedziny

                                                                      przez Karol Bocian | 17 marca, 2020

                                                                      Programowanie obiektowe warto jest rozpocząć od przeanalizowania problemu i zaprojektowania rozwiązania. Bardzo pomocnym krokiem (szczególnie w utrzymaniu wysokiej jakości oprogramowania) jest modelowanie dziedziny.

                                                                      Pojęcia:

                                                                      Programowanie obiektowe — technika tworzenia programów komputerowych wykorzystująca klasy i obiekty, które komunikują się ze sobą i nawzajem wywołują swoje metody.

                                                                      Obiekty — elementy oprogramowania łączące stan (dane) i zachowania (metody).

                                                                      Analiza — badanie problemu.

                                                                      Analiza obiektowa — badanie i klasyfikacja obiektów pojęciowych w problemie.

                                                                      Projektowanie — tworzenie koncepcyjnego rozwiązania.

                                                                      Projektowanie obiektowe — tworzenie koncepcyjnego rozwiązania bazującego na obiektach, ich odpowiedzialnościach, komunikacji między nimi, relacjach i zależnościach.

                                                                      Wzorce projektowe — powszechne rozwiązania typowych problemów.

                                                                      Model dziedziny — odzwierciedlenie części świata rzeczywistego oraz ich zależności.

                                                                      Sprzężenie — miara jak bardzo obiekty zależą od siebie nawzajem.

                                                                      Spójność — miara jak bardzo metody danej klasy powiązane są ze sobą funkcjonalnie.

                                                                      Obiektowe modelowanie dziedziny zawiera:

                                                                      • Klasy pojęciowe — obiekt występujący w modelowanej dziedzinie. Mogą odpowiadać rzeczownikom z opisu świata. Podczas modelowania należy myśleć o rzeczywistym świecie, a nie artefaktach programowych (np. bazie danych).
                                                                      • Powiązania — są to zależności między klasami. Mogą odpowiadać czasownikom z opisu świata. Zależności między klasami określają zdania, np. Jan (klasa Osoba) mieszka pod adresem (klasa Adres).
                                                                      • Liczebność — atrybut powiązania. Określa liczbę egzemplarzy klasy A powiązanej z jednym egzemplarzem klasy B.
                                                                      • Atrybuty- opisy egzemplarzy klas pojęciowych. Problemy:
                                                                        • Atrybut (pole klasy) może być inną klasą (np. w Osobie możemy dać pola Ulica, Nr domu, a możemy dać klasę Adres, które będą zwierały te pola) lub atrybutem innej klasy (np. numer jest atrybutem Miejsca, a nie Biletu).
                                                                        • Atrybuty są wartościami typów podstawowych (w innym przypadku są to klasy pojęciowe).

                                                                      Porządek obiektowego modelowania dziedziny:

                                                                      1. Klasyfikacja obiektów.
                                                                      2. Rozważanie związków między klasami.
                                                                      3. Klasyfikacja atrybutów klas.

                                                                      Warto dbać o wysoką spójność klas oraz nie należy bać się tworzenia klas pomocniczych.

                                                                      Wszystkie posty związane z mini projektem: Poznaj zasady SOLID i OOP:

                                                                        Źródła

                                                                        Obraz główny

                                                                        Materiały

                                                                        Zawartosc skladajaca sie z internetowego edytora HTML. Wpisz kod licencji, aby zatrzymac dodawanie podobnych reklam do edytowanych dokumentów.

                                                                        OOP — Myślenie obiektowe

                                                                        przez Karol Bocian | 1 marca, 2020

                                                                        Porady:

                                                                        • Poznaj zasady SOLID i staraj się jak najbardziej przestrzegać.
                                                                        • Myśl o klasie jak o fizycznym obiekcie: co on może zrobić, kto może coś robić z jego danymi, czego robić on nie powinien.
                                                                        • Zastanawiaj się, jak obiekty mogą się ze sobą komunikować.
                                                                        • Opieraj zależności między obiektami na abstrakcji.
                                                                        • Pamiętaj, że klasy powinny być hermetyczne.
                                                                        • Klasy i metody nie powinny robić zbyt wiele — duże klasy i metody trudno jest zrozumieć i testować.
                                                                        • Klasa sama powinna manipulować swoimi danymi. Nie powinniśmy zwracać danych innej klasie, aby ona je podmieniła.
                                                                        • Wyciągaj wspólne części kodu do klas wyspecjalizowanych. Zmniejsza to możliwość wystąpienia błędu w przyszłości oraz pozwala ponownie wykorzystać kod.
                                                                        • Pisz ładny, czytelny i czysty kod. Im mniej zagnieżdżeń w kodzie, tym lepiej.
                                                                        • Nie nadużywaj dziedziczenia. Zazwyczaj lepszym rozwiązaniem jest kompozycja.

                                                                        Sposób na poprawienie wiedzy, jak lepiej programować obiektowo:

                                                                        Książka do przeczytania: Myślenie obiektowe w programowaniu — Matt Weiffeld.

                                                                        Sposób na ćwiczenie:

                                                                        Zamiana programu napisanego w paradygmacie strukturalnym na obiektowy.

                                                                        Wszystkie posty związane z mini projektem: Poznaj zasady SOLID i OOP:

                                                                          Źródła

                                                                          Obraz główny

                                                                          Materiały

                                                                          OOP — Object Oriented Programming, czyli programowanie obiektowe

                                                                          przez Karol Bocian | 18 lutego, 2020

                                                                          Programowanie obiektowe

                                                                          Sposób tworzenia oprogramowania wykorzystujący obiekty — elementy scalające dane i funkcje. Program składa się z obiektów komunikujących się ze sobą i realizujących różne zadania. Jest to naturalny dla człowieka sposób modelowania rzeczywistości. Zaletą programowania obiektowego jest łatwość pisania oprogramowania, modyfikowania, utrzymywania, rozwijania oraz ponownego używania już raz napisanego kodu.

                                                                          Cechy programowana obiektowego

                                                                          Klasy

                                                                          Klasy to szablony obiektów. Zawierają dane (charakterystyki) oraz procedury (metody — działania do wykonywania). Na przykład: klasą jest Koło, który zawiera pole: promień oraz metodę PodajPolePowierzchni (wraz z implementacją obliczania pola).

                                                                          Obiekty

                                                                          Obiekty to konkretne instancje klas. Na przykład: obiektem będzie użycie klasy Koło o promieniu 3 cm.

                                                                          Podstawowe założenia programowania obiektowego

                                                                          Hermetyzacja

                                                                          Hermetyzacja polega na ukryciu szczegółów implementacji. Obiekty przedstawiają publiczny interfejs, który mogą wywoływać inne obiekty. Obiekt może zmieniać tylko swój stan. Nikt inny nie może tego robić.

                                                                          Dziedziczenie

                                                                          Mechanizm dający możliwość tworzenia wyspecjalizowanych obiektów na podstawie obiektów ogólniejszych. Pozwala to współdzielić funkcjonalności. Obiekt wyspecjalizowany może wykorzystywać część definicji obiektu ogólniejszego i rozszerzać go lub zmieniać.

                                                                          Polimorfizm

                                                                          Mechanizm umożliwiający traktowanie różnych obiektów w jeden sposób dziedziczących tę samą klasę.

                                                                          Abstrakcja

                                                                          Obiekty są modelami abstrakcyjnych bytów, które wykonują powierzone im zadania bez zdradzania, jak te działania są realizowane. Przedstawiają one uproszczenie danego zagadnienia.

                                                                          Wszystkie posty związane z mini projektem: Poznaj zasady SOLID i OOP:

                                                                            Źródła

                                                                            Obraz główny

                                                                            Materiały

                                                                            Ćwiczenia z SOLID — Kata

                                                                            przez Karol Bocian | 15 lutego, 2020

                                                                            Dzisiaj będę ćwiczył zasady SOLID poprzez robienie Kata. Wybrałem bardzo popularną formę kata: Kalkulator napisów. Czym jest kata?

                                                                            Kata

                                                                            Kata to podstawowy ruch. Jest to japońskie słowo, które oznacza konkretne sekwencje ruchów (walki). Ich regularne powtarzanie pozwala ćwiczyć się do perfekcji w danej technice. W programowaniu pod hasłem Kata określa się zbiór konkretnych czynności stosowanych do ćwiczenia się w programowaniu. Jedno kata polega na zaprogramowaniu i rozwiązaniu danego problemu, np. ćwicząc przy tym TDD. Sekwencja wygląda następująco:

                                                                            1. Czytamy polecenie (wymaganie biznesowe).
                                                                            2. Piszemy test, który ma sprawdzić nasz kod, czy wykonał dobrze polecenie (Testowanie poprawności rozwiązania).
                                                                            3. Piszemy kod, spełnia nasze testy (rozwiązanie).
                                                                            4. Poprawiamy nasz kod (refaktoryzacja).

                                                                            SOLID — przypomnienie

                                                                            Przypomnijmy sobie jeszcze raz wszystkie zasady SOLID. Następnie przedstawię Ci sposoby, jak ćwiczyć zasady SOLID.

                                                                            Single responsibility principle — Zasada jednej odpowiedzialności

                                                                            Każda klasa powinna mieć tylko jedną odpowiedzialność (czyli tylko jeden powód do modyfikacji klasy) – jeden cel istnienia.

                                                                            Open/closed principle — Zasada otwarte-zamknięte

                                                                            Wszystkie klasy powinny być otwarte na rozszerzenia, ale zamknięte na modyfikacje.

                                                                            Liskov substitution principle — Zasada podstawienia Liskov

                                                                            Oprogramowanie powinno dobrze działać, gdy w miejsce klasy bazowej podstawimy jej którąkolwiek klasę potomną.

                                                                            Interface segregation principle — Zasada segregacji interfejsów

                                                                            Wiele dedykowanych i małych interfejsów jest lepsze niż jeden ogólny.

                                                                            Dependency inversion principle — Zasada odwróconej zależności

                                                                            Wysokopoziomowe moduły nie powinny zależeć od modułów niskopoziomowych, lecz zależność powinna wynikać z abstrakcji.

                                                                            Ćwiczenia

                                                                            W dzisiejszym ćwiczeniach wykorzystam to kata: https://osherove.com/tdd-kata-1/. Ćwiczenia wykonywałem w VisualStudio 2019, a testy jednostkowe pisałem używając biblioteki Microsoft.VisualStudio.TestTools.UnitTesting oraz uruchamiałem je skrótem: Ctrl+ R, A.

                                                                            Wszystkie posty związane z mini projektem: Poznaj zasady SOLID i OOP:

                                                                              Źródła

                                                                              Obraz główny

                                                                              Materiały

                                                                              Podsumowanie połowy projektu: Poznaj zasady SOLID i OOP

                                                                              przez Karol Bocian | 13 stycznia, 2024

                                                                              Za mną pierwsza połowa mojego 30-dniowego mini projektu: Poznaj Zasady SOLID i OOP. Idzie dobrze, wszystkie zadania, które miałem do dzisiaj zrobić, zostały wykonane. Jednego dnia nie udało mi się popracować nad tym projektem, ale na szczęście kolejnego dnia mogłem to nadrobić.

                                                                              W ramach tego projektu:

                                                                              1. Odświeżyłem sobie zasady SOLID.
                                                                              2. Przećwiczyłem zasady SOLID w praktyce (programując).
                                                                              3. Napisałem posty z zadami solid, moimi praktycznymi przykładami (kilka również przetłumaczyłem na angielski).
                                                                              4. Zrobiłem kurs e-mailowy: Poznaj zasady SOLID i OOP i sukcesywnie dodaję do niego kolejne lekcje.

                                                                              Tutaj możesz zapisać się na kurs:

                                                                              Przede mną jeszcze trochę pracy związanej z tym projektem: przede wszystkim odświeżenie zasad OOP. Stan projektu wygląda następująco (poprawiłem Excela, w którym zarządzam takim projektem, jeżeli będziecie chcieli, podzielę się nim z Wami). Zrobiłem 41 zadań i zostało mi jeszcze 45 zadań do zrobienia.

                                                                              Wszystkie posty związane z mini projektem: Poznaj zasady SOLID i OOP:

                                                                                Źródła

                                                                                Obraz główny

                                                                                Ćwiczenia z SOLID

                                                                                przez Karol Bocian | 13 lutego, 2020

                                                                                ćwiczenia SOLID

                                                                                SOLID

                                                                                Zasady SOLID są podstawowymi dobrymi praktykami w programowaniu obiektowym. Warto jest nie tylko znać zasady SOLID, ale również je ćwiczyć. Przypomnijmy sobie jeszcze raz wszystkie zasady SOLID. Następnie przedstawię Ci sposoby, jak ćwiczyć zasady SOLID.

                                                                                Single responsibility principle – Zasada jednej odpowiedzialności

                                                                                Każda klasa powinna mieć tylko jedną odpowiedzialność (czyli tylko jeden powód do modyfikacji klasy) – jeden cel istnienia.

                                                                                Open/closed principle – Zasada otwarte-zamknięte

                                                                                Wszystkie klasy powinny być otwarte na rozszerzenia, ale zamknięte na modyfikacje.

                                                                                Liskov substitution principle – Zasada podstawienia Liskov

                                                                                Oprogramowanie powinno dobrze działać, gdy w miejsce klasy bazowej podstawimy jej którąkolwiek klasę potomną.

                                                                                Interface segregation principle – Zasada segregacji interfejsów

                                                                                Wiele dedykowanych i małych interfejsów jest lepsze niż jeden ogólny.

                                                                                Dependency inversion principle – Zasada odwróconej zależności

                                                                                Wysokopoziomowe moduły nie powinny zależeć od modułów niskopoziomowych, lecz zależność powinna wynikać z abstrakcji.

                                                                                Ćwiczenia zasady SOLID

                                                                                1. Programuj zwracając uwagę na zasady
                                                                                2. Czytaj zasady
                                                                                3. Czytaj kod innych osób w kontekście zasad
                                                                                4. Obserwuj, jak zmienia się Twoje oprogramowanie i czy zasady SOLID ułatwiłyby jego rozwój czy odwrotnie.
                                                                                5. Czytaj kod napisany w celu zaprezentowania zasad.
                                                                                6. Dawaj swój kod do review (sprawdzenia) innej osobie i poproś, aby wzięła pod uwagę zasady.

                                                                                Odwiedź strony z ćwiczeniami zasad SOLID

                                                                                Wszystkie posty związane z mini projektem: Poznaj zasady SOLID i OOP:

                                                                                  Źródła

                                                                                  Obraz główny

                                                                                  Materiały

                                                                                  CI jak Ćwiczenia Dependency Inversion Principle, czyli Zasada odwrócenia zależności

                                                                                  przez Karol Bocian | 12 lutego, 2020

                                                                                  Dependency inversion principle — Zasada odwróconej zależności

                                                                                  Wysokopoziomowe moduły nie powinny zależeć od modułów niskopoziomowych, lecz zależność powinna wynikać z abstrakcji.

                                                                                  Jak wykorzystywać w praktyce DIP?

                                                                                  Twórzmy dużo abstrakcyjnych bytów. Każda klasa niech implementuje interfejs lub dziedziczy po klasie abstrakcyjnej. Tworząc oprogramowanie, możemy najpierw stworzyć tylko interfejsy, a dopiero później je zaimplementować.

                                                                                  Pomocne w spełnieniu tej zasady jest przestrzeganie tych reguł:

                                                                                  • Każda zmienna w klasie jest referencja do abstrakcji.
                                                                                  • Wszystkie klasy dziedziczą po abstrakcji.
                                                                                  • Żadna klasy potomna nie przesłania metod z klasy bazowej.
                                                                                  • Ustawianie zmiennych realizowane jest przez wzorzec fabryki lub wstrzykiwania zależności.

                                                                                  Przykład

                                                                                  Poniżej mamy klasę pokazującą raport. Dane do raportu brane są za bazy danych. Implementacja wygląda następująco:

                                                                                  class Program
                                                                                     {
                                                                                         static void Main(string[] args)
                                                                                         {
                                                                                   
                                                                                             var reportImporter = new ReportDatabaseImporter();
                                                                                             var reportPresenter = new ReportPresenter(reportImporter);
                                                                                             reportPresenter.ShowReport();
                                                                                         }
                                                                                     }
                                                                                   
                                                                                     internal class ReportPresenter
                                                                                     {
                                                                                   
                                                                                         private readonly ReportDatabaseImporter importer;
                                                                                   
                                                                                   
                                                                                         public ReportPresenter(ReportDatabaseImporter importer)
                                                                                         {
                                                                                             this.importer = importer;
                                                                                         }
                                                                                   
                                                                                         public void ShowReport()
                                                                                         {
                                                                                             Console.WriteLine(importer.GetReportData());
                                                                                         }
                                                                                     }
                                                                                   
                                                                                   
                                                                                   
                                                                                     internal class ReportDatabaseImporter
                                                                                   
                                                                                     {
                                                                                         public string GetReportData()
                                                                                   
                                                                                         {
                                                                                             return "Report from Database";
                                                                                         }
                                                                                     }

                                                                                  Po jakimś czasie dostaliśmy prośbę o wyświetlanie danych również z pliku Excel w taki sam sposób. Niestety, nie jesteśmy w stanie zrobić tego łatwo. Musimy zmienić klasę prezentującą raport. Takie rozwiązanie pozwala nam dodawać łatwiej kolejne źródła raportu:

                                                                                  using System;
                                                                                   
                                                                                  namespace SRP.Bad
                                                                                  {
                                                                                      class Program
                                                                                      {
                                                                                          static void Main(string[] args)
                                                                                          {
                                                                                              var reportImporter = new ReportDatabaseImporter();
                                                                                              var reportPresenter = new ReportPresenter(reportImporter);
                                                                                              reportPresenter.ShowReport();
                                                                                   
                                                                                   
                                                                                   
                                                                                              var reportImporter2 = new ReportExcelImporter();
                                                                                              var reportPresenter2 = new ReportPresenter(reportImporter2);
                                                                                              reportPresenter2.ShowReport();
                                                                                          }
                                                                                      }
                                                                                   
                                                                                      internal class ReportPresenter : IReportPresenter
                                                                                      {
                                                                                          private readonly IReportImporter importer;
                                                                                   
                                                                                          public ReportPresenter(IReportImporter importer)
                                                                                          {
                                                                                              this.importer = importer;
                                                                                          }
                                                                                          public void ShowReport()
                                                                                          {
                                                                                              var reportData = importer.GetReportData();
                                                                                              Console.WriteLine(reportData.GetContent());
                                                                                          }
                                                                                      }
                                                                                   
                                                                                      internal class ReportDatabaseImporter : IReportImporter
                                                                                      {
                                                                                          public IReportData GetReportData()
                                                                                          {
                                                                                              return new ReportData("Report from Database");
                                                                                          }
                                                                                      }
                                                                                      internal class ReportExcelImporter : IReportImporter
                                                                                      {
                                                                                          public IReportData GetReportData()
                                                                                          {
                                                                                              return new ReportData("Report from Excel");
                                                                                          }
                                                                                      }
                                                                                      internal class ReportData : IReportData
                                                                                      {
                                                                                          private readonly string content;
                                                                                   
                                                                                          public ReportData(string content)
                                                                                          {
                                                                                              this.content = content;
                                                                                          }
                                                                                          public string GetContent()
                                                                                          {
                                                                                              return content;
                                                                                          }
                                                                                      }
                                                                                      internal interface IReportData
                                                                                      {
                                                                                          string GetContent();
                                                                                      }
                                                                                      internal interface IReportImporter
                                                                                      {
                                                                                          IReportData GetReportData();
                                                                                      }
                                                                                   
                                                                                      internal interface IReportPresenter
                                                                                      {
                                                                                          void ShowReport();
                                                                                      }
                                                                                  }
                                                                                  

                                                                                  Mamy tutaj dużą liczbę interfejsów. Ułatwiają one jednak rozwój aplikacji oraz testowanie. W testach będziemy mogli pod interfejs podstawić mocka.

                                                                                  Wszystkie posty związane z mini projektem: Poznaj zasady SOLID i OOP:

                                                                                    Źródła

                                                                                    Obraz główny

                                                                                    Materiały

                                                                                    CI jak Ćwiczenia Interface segregation principle, czyli Zasady segregacji interfejsów

                                                                                    przez Karol Bocian | 11 lutego, 2020

                                                                                    Interface segregation principle – Zasada segregacji interfejsów

                                                                                    Wiele dedykowanych i małych interfejsów jest lepsze niż jeden ogólny.

                                                                                    Jak wykorzystywać w praktyce ISP?

                                                                                    Należy rozdzielać interfejsy na mniejsze i przyłożyć się do projektowania abstrakcyjnych elementów w aplikacji. Za granicę podziału najlepiej wybierać jest miejsce, które pozwala wydzielić obszary zgodne z zasadą pojedynczej odpowiedzialności. Każdy obszar powinien mieć jeden powód do zmiany. Powinien zmniejszać zależności i zwiększać spójność. Interfejsy powinny zawierać taki zbiór metod, aby klasy je implementujące nie musiały implementować metod, których nie chcą implementować.

                                                                                    Przykład

                                                                                    class Program
                                                                                      {
                                                                                          static void Main(string[] args)
                                                                                          {
                                                                                              IDataImporter reportImporter = new ReportImporter();
                                                                                              Console.WriteLine(reportImporter.GetDataFromPdf());
                                                                                              Console.WriteLine(reportImporter.GetDataFromExcel());
                                                                                     
                                                                                              IDataImporter pictureImporter = new TableImporter();
                                                                                              Console.WriteLine(pictureImporter.GetDataFromPdf());
                                                                                              Console.WriteLine(pictureImporter.GetDataFromExcel());
                                                                                          }
                                                                                      }
                                                                                     
                                                                                      internal class TableImporter : IDataImporter
                                                                                      {
                                                                                          public string GetDataFromExcel()
                                                                                          {
                                                                                              return "Table from Excel";
                                                                                          }
                                                                                     
                                                                                          public string GetDataFromPdf()
                                                                                          {
                                                                                              //We do not return a table from pdf file
                                                                                              return string.Empty;
                                                                                          }
                                                                                      }
                                                                                     
                                                                                      internal class ReportImporter : IDataImporter
                                                                                      {
                                                                                          public string GetDataFromExcel()
                                                                                          {
                                                                                              return "Report from Excel";
                                                                                          }
                                                                                     
                                                                                          public string GetDataFromPdf()
                                                                                          {
                                                                                              return "Report from Pdf";
                                                                                          }
                                                                                      }
                                                                                     
                                                                                      internal interface IDataImporter
                                                                                      {
                                                                                          string GetDataFromExcel();
                                                                                          string GetDataFromPdf();
                                                                                      }

                                                                                    Klasa TableImporter implementuje metodę, z której w ogóle nie korzysta. Lepiej jest oddzielić interfejs DataImporter na mniejsze interfejsy. Wtedy wszystkie klasy będą implementowały tylko to, co chcą.

                                                                                    class Program
                                                                                    {
                                                                                        static void Main(string[] args)
                                                                                        {
                                                                                            var reportImporter = new ReportImporter();
                                                                                            Console.WriteLine(reportImporter.GetDataFromPdf());
                                                                                            Console.WriteLine(reportImporter.GetDataFromExcel());
                                                                                     
                                                                                            IExcelParser pictureImporter = new TableImporter();
                                                                                            Console.WriteLine(pictureImporter.GetDataFromExcel());
                                                                                        }
                                                                                    }
                                                                                     
                                                                                    internal class TableImporter : IExcelParser
                                                                                    {
                                                                                        public string GetDataFromExcel()
                                                                                        {
                                                                                            return "Table from Excel";
                                                                                        }
                                                                                    }
                                                                                     
                                                                                    internal class ReportImporter : IExcelParser, IPdfParser
                                                                                    {
                                                                                        public string GetDataFromExcel()
                                                                                        {
                                                                                            return "Report from Excel";
                                                                                        }
                                                                                     
                                                                                        public string GetDataFromPdf()
                                                                                        {
                                                                                            return "Report from Pdf";
                                                                                        }
                                                                                    }
                                                                                    internal interface IExcelParser
                                                                                    {
                                                                                        string GetDataFromExcel();
                                                                                    }
                                                                                    internal interface IPdfParser
                                                                                    {
                                                                                        string GetDataFromPdf();
                                                                                    }

                                                                                    Wszystkie posty związane z mini projektem: Poznaj zasady SOLID i OOP:

                                                                                      Źródła

                                                                                      Obraz główny

                                                                                      Materiały

                                                                                      CL jak Ćwiczenia Liskov Substitution Principle, czyli zasada podstawień Barbary Liskov

                                                                                      przez Karol Bocian | 10 lutego, 2020

                                                                                      Liskov substitution principle – Zasada podstawienia Liskov

                                                                                      Oprogramowanie powinno dobrze działać, gdy w miejsce klasy bazowej podstawimy jej którąkolwiek klasę potomną.

                                                                                      Jak wykorzystywać w praktyce LSP?

                                                                                      Należy dobrze zastanowić się przed skorzystaniem z dziedziczenia. Zazwyczaj lepszą opcją jest użycie kompozycji. Warto jest również zrobić proste eksperymenty: próbować podstawić w klasach korzystających z naszego drzewa klas, wszystkie klasy potomne oraz klasę bazową i zobaczyć, czy nadal program zachowuje się odpowiednio, czy może jednak oczekuje tylko jednego konkretnego rodzaju klasy.

                                                                                      Przykład

                                                                                      Rozważmy takie zadanie:

                                                                                      Mamy napisać aplikację, który wyświetla obraz z kamery video. Do naszej aplikacji możemy podłączyć wiele kamer. Nie wszystkie z nich potrafimy obsłużyć. Na szczęście wiemy to już na początku. Tworzymy klasę bazową Camera oraz klasy dziedziczące po kamerze, w tym również klasę dla kamery nieobsługiwanej.

                                                                                      class Program
                                                                                         {
                                                                                             static void Main(string[] args)
                                                                                             {
                                                                                                 var cameras = new List<Camera>();
                                                                                                 var cameraNC1 = new CameraNC1("Front camera");
                                                                                                 cameras.Add(cameraNC1);
                                                                                                 var cameraShower = new CameraShower(cameraNC1);
                                                                                                 cameraShower.Show();
                                                                                       
                                                                                       
                                                                                                 var cameraNC2 = new CameraNC2("Back camera");
                                                                                                 cameras.Add(cameraNC2);
                                                                                                 cameraShower = new CameraShower(cameraNC2);
                                                                                                 cameraShower.Show();
                                                                                       
                                                                                                 var unsupportedCamera = new UnsupportedCamera(null);
                                                                                                 cameras.Add(unsupportedCamera);
                                                                                                 cameraShower = new CameraShower(unsupportedCamera);
                                                                                                 cameraShower.Show();
                                                                                             }
                                                                                         }
                                                                                       
                                                                                         internal class CameraShower
                                                                                         {
                                                                                             private Camera camera;
                                                                                       
                                                                                             public CameraShower(Camera camera)
                                                                                             {
                                                                                                 this.camera = camera;
                                                                                             }
                                                                                       
                                                                                             internal void Show()
                                                                                             {
                                                                                                 if (!(camera is UnsupportedCamera))
                                                                                                     Console.WriteLine($"Camera name: {camera.GetName()}");
                                                                                             }
                                                                                         }
                                                                                       
                                                                                         internal class CameraNC2 : Camera
                                                                                         {
                                                                                             public CameraNC2(string name) : base(name)
                                                                                             {
                                                                                             }
                                                                                         }
                                                                                         internal class CameraNC1 : Camera
                                                                                         {
                                                                                             public CameraNC1(string name) : base(name)
                                                                                             {
                                                                                             }
                                                                                       
                                                                                         }
                                                                                         internal class UnsupportedCamera : Camera
                                                                                         {
                                                                                             public UnsupportedCamera(string name) : base(name)
                                                                                             {
                                                                                             }
                                                                                       
                                                                                             internal override string GetName()
                                                                                             {
                                                                                                 throw new Exception("This camera does not have name. It is not supported.");
                                                                                             }
                                                                                         }
                                                                                       
                                                                                         internal abstract class Camera
                                                                                         {
                                                                                             protected readonly string name;
                                                                                       
                                                                                             public Camera(string name)
                                                                                             {
                                                                                                 this.name = name;
                                                                                             }
                                                                                             internal virtual string GetName()
                                                                                             {
                                                                                                 return name;
                                                                                             }
                                                                                         }

                                                                                      Wszystko pięknie działa. Ale musieliśmy kamerę niewspieraną specjalnie obsłużyć. Jeżeli byśmy tego nie zrobili, dostalibyśmy wyjątek. Możemy trochę inaczej zaimplementować metodę GetName w klasie dla kamery niewspieranej:

                                                                                      class Program
                                                                                      {
                                                                                          static void Main(string[] args)
                                                                                          {
                                                                                              var cameras = new List<Camera>();
                                                                                              var cameraNC1 = new CameraNC1("Front camera");
                                                                                              cameras.Add(cameraNC1);
                                                                                              var cameraShower = new CameraShower(cameraNC1);
                                                                                              cameraShower.Show();
                                                                                       
                                                                                       
                                                                                              var cameraNC2 = new CameraNC2("Back camera");
                                                                                              cameras.Add(cameraNC2);
                                                                                              cameraShower = new CameraShower(cameraNC2);
                                                                                              cameraShower.Show();
                                                                                       
                                                                                              var unsupportedCamera = new UnsupportedCamera();
                                                                                              cameras.Add(unsupportedCamera);
                                                                                              cameraShower = new CameraShower(unsupportedCamera);
                                                                                              cameraShower.Show();
                                                                                          }
                                                                                      }
                                                                                       
                                                                                      internal class CameraShower
                                                                                      {
                                                                                          private Camera camera;
                                                                                       
                                                                                          public CameraShower(Camera camera)
                                                                                          {
                                                                                              this.camera = camera;
                                                                                          }
                                                                                       
                                                                                          internal void Show()
                                                                                          {
                                                                                              Console.WriteLine($"Camera name: {camera.GetName()}");
                                                                                          }
                                                                                      }
                                                                                       
                                                                                      internal class CameraNC2 : Camera
                                                                                      {
                                                                                          public CameraNC2(string name) : base(name)
                                                                                          {
                                                                                          }
                                                                                      }
                                                                                      internal class CameraNC1 : Camera
                                                                                      {
                                                                                          public CameraNC1(string name) : base(name)
                                                                                          {
                                                                                          }
                                                                                       
                                                                                      }
                                                                                      internal class UnsupportedCamera : Camera
                                                                                      {
                                                                                          public UnsupportedCamera() : base("Unknown - this camera is not supported")
                                                                                          {
                                                                                          }
                                                                                      }
                                                                                       
                                                                                      internal abstract class Camera
                                                                                      {
                                                                                          protected readonly string name;
                                                                                       
                                                                                          public Camera(string name)
                                                                                          {
                                                                                              this.name = name;
                                                                                          }
                                                                                          internal virtual string GetName()
                                                                                          {
                                                                                              return name;
                                                                                          }
                                                                                      }

                                                                                      Wszystkie posty związane z mini projektem: Poznaj zasady SOLID i OOP:

                                                                                        Źródła

                                                                                        Obraz główny

                                                                                        Materiały

                                                                                        CO jak Ćwiczenia Open/closed principle, czyli Zasada otwarte-zamknięte

                                                                                        przez Karol Bocian | 10 lutego, 2020

                                                                                        Open/closed principle – Zasada otwarte-zamknięte

                                                                                        Wszystkie klasy powinny być otwarte na rozszerzenia, ale zamknięte na modyfikacje.

                                                                                        Jak wykorzystywać w praktyce OCP?

                                                                                        Warto jest stosować interfejsy oraz operować na abstrakcji, a nie uzależniać się od szczegółów implementacyjnych.

                                                                                        Trudności związane z OCP

                                                                                        Ciężko jest czasami zdecydować, co jest szczegółem implementacyjnym oraz w którą stronę będzie rozszerzała się nasza aplikacja.

                                                                                        Przykład

                                                                                        Ćwiczenia tej metody wykonałem na bardzo prostym przykładzie. Mamy kalkulator, który ma za zadanie obliczyć powierzchnię figur. W pierwszej wersji używa on switcha, do rozpoznania, jaka jest to klasa.

                                                                                        class AreaCalculator
                                                                                         {
                                                                                             private readonly List<object> figures;
                                                                                             public AreaCalculator(List<object> figures)
                                                                                             {
                                                                                                 this.figures = figures;
                                                                                             }
                                                                                             public double Calculate()
                                                                                             {
                                                                                                 double area = 0;
                                                                                                 foreach (var figure in figures)
                                                                                                 {
                                                                                                     switch (figure)
                                                                                                     {
                                                                                                         case Square square:
                                                                                                             area += square.GetWidth() * square.GetWidth();
                                                                                                             break;
                                                                                                         case Rectangle rectangle:
                                                                                                             area += rectangle.GetWidth() * rectangle.Getheight();
                                                                                                             break;
                                                                                                         case Circle circle:
                                                                                                             area += Math.PI * Math.Pow(circle.GetRadius(), 2);
                                                                                                             break;
                                                                                                         default:
                                                                                                             area += area;
                                                                                                             break;
                                                                                                     }
                                                                                                 }
                                                                                                 return area;
                                                                                             }
                                                                                         }
                                                                                         
                                                                                         class Square
                                                                                         {
                                                                                             private readonly double width;
                                                                                             public Square(double width)
                                                                                             {
                                                                                                 this.width = width;
                                                                                             }
                                                                                             internal double GetWidth()
                                                                                             {
                                                                                                 return width;
                                                                                             }
                                                                                         }
                                                                                         class Rectangle
                                                                                         {
                                                                                             private readonly double width;
                                                                                             private readonly double height;
                                                                                         
                                                                                             public Rectangle(double width, double height)
                                                                                             {
                                                                                                 this.width = width;
                                                                                                 this.height = height;
                                                                                             }
                                                                                             internal double GetWidth()
                                                                                             {
                                                                                                 return width;
                                                                                             }
                                                                                             internal double Getheight()
                                                                                             {
                                                                                                 return height;
                                                                                             }
                                                                                         }
                                                                                         class Circle
                                                                                         {
                                                                                             private readonly double radius;
                                                                                             public Circle(double radius)
                                                                                             {
                                                                                                 this.radius = radius;
                                                                                             }
                                                                                             internal double GetRadius()
                                                                                             {
                                                                                                 return radius;
                                                                                             }
                                                                                         }
                                                                                         class Program
                                                                                         {
                                                                                             static void Main(string[] args)
                                                                                             {
                                                                                                 List<object> figures = new List<object>()
                                                                                                 {
                                                                                                     new Square(5),
                                                                                         
                                                                                                 };
                                                                                                 AreaCalculator areaCalculator = new AreaCalculator(figures);
                                                                                         
                                                                                                 Debug.Assert(areaCalculator.Calculate() == 25);
                                                                                         
                                                                                                 List<object> figures2 = new List<object>()
                                                                                                 {
                                                                                                     new Square(5),
                                                                                                     new Rectangle(5,3),
                                                                                         
                                                                                                 };
                                                                                                 Debug.Assert(new AreaCalculator(figures2).Calculate() == (25 + 15));
                                                                                                 List<object> figures3 = new List<object>()
                                                                                                 {
                                                                                                     new Square(5),
                                                                                                     new Rectangle(5,3),
                                                                                                     new Circle(5),
                                                                                         
                                                                                                 };
                                                                                                 Debug.Assert(new AreaCalculator(figures3).Calculate() 
                                                                                                   == (25 + 15 + Math.PI * 25));
                                                                                             }
                                                                                         }

                                                                                        W drugim przypadku klasy figur implementują interfejs, który ma metodę do liczenia pola powierzchni klasy. Każda klasa sama implementuję liczenie swojego pola powierzchni. Kalkulator jedynie sumuje pola powierzchni.

                                                                                        class AreaCalculator
                                                                                           {
                                                                                               private readonly IEnumerable<IFigureAreaCalculator> figures;
                                                                                               public AreaCalculator(IEnumerable<IFigureAreaCalculator> figures)
                                                                                               {
                                                                                                   this.figures = figures;
                                                                                               }
                                                                                         
                                                                                               public double Calculate()
                                                                                               {
                                                                                                   return figures.Sum(x => x.GetArea());
                                                                                               }
                                                                                           }
                                                                                           interface IFigureAreaCalculator
                                                                                           {
                                                                                               double GetArea();
                                                                                           }
                                                                                           class Square : IFigureAreaCalculator
                                                                                           {
                                                                                               private readonly double width;
                                                                                               public Square(double width)
                                                                                               {
                                                                                                   this.width = width;
                                                                                               }
                                                                                         
                                                                                               public double GetArea()
                                                                                               {
                                                                                                   return width * width;
                                                                                               }
                                                                                         
                                                                                               internal double GetWidth()
                                                                                               {
                                                                                                   return width;
                                                                                               }
                                                                                           }
                                                                                           class Rectangle : IFigureAreaCalculator
                                                                                           {
                                                                                               private readonly double width;
                                                                                               private readonly double height;
                                                                                         
                                                                                               public Rectangle(double width, double height)
                                                                                               {
                                                                                                   this.width = width;
                                                                                                   this.height = height;
                                                                                               }
                                                                                               internal double GetWidth()
                                                                                               {
                                                                                                   return width;
                                                                                               }
                                                                                               internal double Getheight()
                                                                                               {
                                                                                                   return height;
                                                                                               }
                                                                                         
                                                                                               public double GetArea()
                                                                                               {
                                                                                                   return width * height;
                                                                                               }
                                                                                           }
                                                                                           class Circle : IFigureAreaCalculator
                                                                                           {
                                                                                               private readonly double radius;
                                                                                               public Circle(double radius)
                                                                                               {
                                                                                                   this.radius = radius;
                                                                                               }
                                                                                         
                                                                                               public double GetArea()
                                                                                               {
                                                                                                   return Math.PI * Math.Pow(radius, 2);
                                                                                               }
                                                                                         
                                                                                               internal double GetRadius()
                                                                                               {
                                                                                                   return radius;
                                                                                               }
                                                                                           }
                                                                                           class Program
                                                                                           {
                                                                                               static void Main(string[] args)
                                                                                               {
                                                                                                   var figures = new List<IFigureAreaCalculator>()
                                                                                                   {
                                                                                                       new Square(5),
                                                                                         
                                                                                                   };
                                                                                                   AreaCalculator areaCalculator = new AreaCalculator(figures);
                                                                                         
                                                                                                   Debug.Assert(areaCalculator.Calculate() == 25);
                                                                                         
                                                                                                   var figures2 = new List<IFigureAreaCalculator>()
                                                                                                   {
                                                                                                       new Square(5),
                                                                                                       new Rectangle(5,3),
                                                                                         
                                                                                                   };
                                                                                                   Debug.Assert(new AreaCalculator(figures2).Calculate() == (25 + 15));
                                                                                         
                                                                                                   var figures3 = new List<IFigureAreaCalculator>()
                                                                                                   {
                                                                                                       new Square(5),
                                                                                                       new Rectangle(5,3),
                                                                                                       new Circle(5),
                                                                                         
                                                                                                   };
                                                                                                   Debug.Assert(new AreaCalculator(figures3).Calculate() == (25 + 15 + Math.PI * 25));
                                                                                               }
                                                                                           }

                                                                                        Dodanie nowej figury nie będzie wymagało zmiany w klasie AreaCalculator.

                                                                                        Wszystkie posty związane z mini projektem: Poznaj zasady SOLID i OOP:

                                                                                          Źródła

                                                                                          Obraz główny

                                                                                          Materiały

                                                                                          CS jak Ćwiczenia Single responsibility principle, czyli zasada jednej odpowiedzialności

                                                                                          przez Karol Bocian | 4 marca, 2020

                                                                                          Single responsibility principle — Zasada jednej odpowiedzialności

                                                                                          Każda klasa powinna mieć tylko jedną odpowiedzialność (czyli tylko jeden powód do modyfikacji klasy) – jeden cel istnienia.

                                                                                          Jak wykorzystywać w praktyce SRP?

                                                                                          Łącz w jedno kod, który ma ten sam jeden powód do zmiany. Rozdzielaj od siebie kod, który ma wiele powodów do zmiany.

                                                                                          Trudności związane z SRP

                                                                                          Z zasadą jednej odpowiedzialności związane są pewne trudności:

                                                                                          • Nie jest zdefiniowane, czym jest zmiana.
                                                                                          • Nie jest zdefiniowane, czym jest odpowiedzialność.
                                                                                          • Wymaga przewidywania przyszłości.

                                                                                          Zasadę pojedynczej odpowiedzialności można przedefiniować.

                                                                                          Klasa, funkcja, metoda itp. powinna odpowiadać za pojedynczą logikę biznesową na jednym poziomie abstrakcji. (http://adam.wroclaw.pl/2014/12/zasada-pojedynczej-odpowiedzialnosci/)

                                                                                          Klasy powinny być organizowane tak, aby minimalizować złożoność. Powinny:

                                                                                          • Być na tyle małe, aby zmniejszać zależności.
                                                                                          • Być na tyle duże, aby maksymalizować spójność.

                                                                                          Domyślnie powinno się wybierać grupowanie funkcjonalności na rzecz rozdzielania kodu. (https://sklivvz.com/posts/i-dont-love-the-single-responsibility-principle)

                                                                                          Przykład

                                                                                          Klasa książka ma dwie odpowiedzialności:

                                                                                          1. Posiadanie informacji o sobie.
                                                                                          2. Drukowanie siebie.
                                                                                          
                                                                                             class Book
                                                                                              {
                                                                                                  private string title;
                                                                                                  private string content;
                                                                                                  public Book(string title, string content)
                                                                                                  {
                                                                                                      this.title = title;
                                                                                                      this.content = content;
                                                                                                  }
                                                                                          
                                                                                          
                                                                                          
                                                                                                  public void PrintBook()
                                                                                                  {
                                                                                                      Console.WriteLine(title);
                                                                                                      Console.WriteLine(content);
                                                                                                  }
                                                                                              }
                                                                                          
                                                                                              class Program
                                                                                              {
                                                                                                  static void Main(string[] args)
                                                                                                  {
                                                                                                      Book book = new Book("Interesting title", "Nice content");
                                                                                                      book.PrintBook();
                                                                                                  }
                                                                                              }
                                                                                          

                                                                                          W ramach refaktoryzacji wydzieliłem odpowiedzialność związaną z książką do oddzielnej klasy.

                                                                                          
                                                                                          class Book
                                                                                              {
                                                                                                  private string title;
                                                                                                  private string content;
                                                                                          
                                                                                                  public Book(string title, string content)
                                                                                                  {
                                                                                                      this.title = title;
                                                                                                      this.content = content;
                                                                                                  }
                                                                                          
                                                                                                  public string GetBookToPrint()
                                                                                                  {
                                                                                                      return $"{title}{Environment.NewLine}{content}";
                                                                                                  }
                                                                                              }
                                                                                          
                                                                                          
                                                                                              interface IPrinter
                                                                                              {
                                                                                                  void Print(string content);
                                                                                              }
                                                                                          
                                                                                              class BookPrinter : IPrinter
                                                                                              {
                                                                                                  public void Print(string content)
                                                                                                  {
                                                                                                      Console.WriteLine(content);
                                                                                                  }
                                                                                              }
                                                                                          
                                                                                              class Program
                                                                                              {
                                                                                                  static void Main(string[] args)
                                                                                                  {
                                                                                                      IPrinter printer = new BookPrinter();
                                                                                                      Book book = new Book("Interesting title", "Nice content");
                                                                                                      var bookToPrint = book.GetBookToPrint();
                                                                                                      printer.Print(bookToPrint);
                                                                                                  }
                                                                                              }
                                                                                          

                                                                                              }

                                                                                          Wszystkie posty związane z mini projektem: Poznaj zasady SOLID i OOP:

                                                                                            Źródła

                                                                                            Obraz główny

                                                                                            Materiały

                                                                                            D jak Dependency Inversion Principle, czyli Zasada odwrócenia zależności

                                                                                            przez Karol Bocian | 24 lutego, 2020

                                                                                            Dependency inversion principle — Zasada odwrócenia zależności

                                                                                            Wysokopoziomowe moduły nie powinny zależeć od modułów niskopoziomowych i detali, lecz zależność powinna wynikać z abstrakcji.

                                                                                            Wszystkie wysokopoziomowe moduły powinny być związane z niskopoziomowymi za pomocą abstrakcji. Abstrakcje nie powinny zależeć od detali, lecz to detale powinny być zależne od abstrakcji.

                                                                                            Pomocne w spełnieniu tej zasady jest przestrzeganie tych reguł:

                                                                                            • Każda zmienna w klasie jest referencja do abstrakcji.
                                                                                            • Wszystkie klasy dziedziczą po abstrakcji.
                                                                                            • Żadna klasy potomna nie przesłania metod z klasy bazowej.
                                                                                            • Ustawianie zmiennych realizowane jest przez wzorzec fabryki lub wstrzykiwania zależności.

                                                                                            Regułę tę można stosować do metod, funkcji, klas, modułów oraz pakietów.

                                                                                            Zalety

                                                                                            • Łatwiejsze wymienianie komponentów.
                                                                                            • Łatwiejsze wprowadzanie zmian w oprogramowaniu.
                                                                                            • Łatwiejsze ponowne wykorzystywanie komponentów.
                                                                                            • Łatwiejsze testowanie.

                                                                                            Wady

                                                                                            • Konieczność korzystania z interfejsów i klas abstrakcyjnych.
                                                                                            • Pracochłonność w tworzeniu stabilnych abstrakcji.
                                                                                            • Konieczność korzystania z fabryk lub wstrzykiwania zależności.

                                                                                            Przykład

                                                                                            • Klasa generująca raport (wysoki poziom) korzysta klasy logującej informacje o wyjątkach w aplikacji (niski poziom). Musi przekazać m.in. ścieżkę do folderu z logami. Zmiana klasy logującej do pliku na klasę logującą do bazy danych wymusi zmianę w klasie generującej raport, bo trzeba będzie przekazać inne dane do konstruktora klasy logującej.
                                                                                            • Klasa Kopiarka wykorzystująca klasę Czytnika i klasę Zapisywacza. Jeżeli mamy użyte klasy, a będziemy chcieli zmienić sposób zapisywania (z drukowania na drukarce, w generowanie pdfa), to będziemy musieli zmienić również klasę Kopiarka albo stworzyć nową klasę KopiarkaPdf. Gdyby klasa Kopiarka miała referencje do interfejsów IZapisywacz, to wystarczyłoby wstrzyknąć w nią odpowiednią implementację IZapisywacza, aby osiągnąć nasz cel.

                                                                                            Wszystkie posty związane z mini projektem: Poznaj zasady SOLID i OOP:

                                                                                              Źródła

                                                                                              Obraz główny

                                                                                              Materiały