{"title":"Filozofie projektowe","version":"3.2","locale":"pl","docname":"misc/design-philosophies","url":"/pl/3.2/misc/design-philosophies/","canonical":"https://djangodocs.dev/pl/3.2/misc/design-philosophies/","summary":"Ten dokument wyjaśnia podstawowe filozofie, którymi kierowali się deweloperzy Django podczas tworzenia frameworku. Celem jest wytłumaczenie przeszłości i…","html":"<h1>Filozofie projektowe<a class=\"heading-anchor\" href=\"#design-philosophies\"><span class=\"visually-hidden\">Link to this heading</span><span aria-hidden=\"true\">#</span></a></h1>\n<p>Ten dokument wyjaśnia podstawowe filozofie, którymi kierowali się deweloperzy Django podczas tworzenia frameworku. Celem jest wytłumaczenie przeszłości i pokierowanie przyszłością.</p>\n<section id=\"overall\">\n<h2>Ogółem<a class=\"heading-anchor\" href=\"#overall\"><span class=\"visually-hidden\">Link to this heading</span><span aria-hidden=\"true\">#</span></a></h2>\n<section id=\"loose-coupling\">\n<span id=\"id1\"></span><h3>Luźne powiązanie<a class=\"heading-anchor\" href=\"#loose-coupling\"><span class=\"visually-hidden\">Link to this heading</span><span aria-hidden=\"true\">#</span></a></h3>\n<p id=\"index-0\">Fundamentalną zasadą stosu Django jest <a class=\"reference external\" href=\"http://wiki.c2.com/?CouplingAndCohesion\">loose coupling and tight cohesion</a>. Różnorodne warstwy frameworka nie powinny wiedzieć o innych więcej niż to absolutnie konieczne.</p>\n<p>Na przykład, szablon nie wie nic o żądaniu, warstwa bazy danych nie wie nic o wyświetlaniu danych a widok nie martwi się szablonem używanym przez programistę.</p>\n<p>Jednakże Django przychodzi z pełnym zestawem dla wygody, a części zestawu są ze sobą niezależne gdzie tylko to możliwe.</p>\n</section>\n<section id=\"less-code\">\n<span id=\"id2\"></span><h3>Mniej kodu<a class=\"heading-anchor\" href=\"#less-code\"><span class=\"visually-hidden\">Link to this heading</span><span aria-hidden=\"true\">#</span></a></h3>\n<p>Aplikacje Django powinny używać tak mało kodu jak to możliwe. Django powinno w pełni wykorzystywać dynamiczne możliwości Pythona, tak jak w introspekcji.</p>\n</section>\n<section id=\"quick-development\">\n<span id=\"id3\"></span><h3>Szybki rozwój<a class=\"heading-anchor\" href=\"#quick-development\"><span class=\"visually-hidden\">Link to this heading</span><span aria-hidden=\"true\">#</span></a></h3>\n<p>Najważniejszym punktem w frameworku 21-ego wieku jest szybkie wykonanie powtarzalnych aspektów tworzenia strony internetowej. Django powinno pozwolić na niesamowicie szybkie wytwarzanie oprogramowania.</p>\n</section>\n<section id=\"don-t-repeat-yourself-dry\">\n<span id=\"dry\"></span><h3>Nie powtarzaj się (DRY)<a class=\"heading-anchor\" href=\"#don-t-repeat-yourself-dry\"><span class=\"visually-hidden\">Link to this heading</span><span aria-hidden=\"true\">#</span></a></h3>\n<p id=\"index-1\">Każdy unikalny pomysł i/lub część danych powinny żyć w jednym i tylko jednym miejscu. Redundancja jest zła. Normalizacja jest dobra.</p>\n<p>Framework, w granicach rozsądku, powinien domyślić się ile to możliwe z możliwe małej ilości danych.</p>\n<aside class=\"admonition admonition-seealso\">\n<p class=\"admonition-title\">Zobacz także</p>\n<p>«Dyskusja o DRY w Portland Pattern Repository»</p>\n</aside>\n</section>\n<section id=\"explicit-is-better-than-implicit\">\n<span id=\"id5\"></span><h3>Wprost jest lepiej niż nie wprost.<a class=\"heading-anchor\" href=\"#explicit-is-better-than-implicit\"><span class=\"visually-hidden\">Link to this heading</span><span aria-hidden=\"true\">#</span></a></h3>\n<p>To jest główna zasada Pythona zapisana w <span class=\"target\" id=\"index-6\"></span><a class=\"pep reference external\" href=\"https://peps.python.org/pep-0020/\"><strong>PEP 20</strong></a>, i oznacza że Django nie powinno wykonywać zbyt dużo „magii”. Magia nie powinna się zdarzyć bez naprawdę dobrego powodu. Magia jest warta użycia tylko jeśli stworzy ogromną wygodę nieosiągalną w inny sposób i nie zostanie zaimplementowana w sposób, który będzie dezorientował programistów próbujących nauczyć się jak ją wykorzystać.</p>\n</section>\n<section id=\"consistency\">\n<span id=\"id6\"></span><h3>Spójność<a class=\"heading-anchor\" href=\"#consistency\"><span class=\"visually-hidden\">Link to this heading</span><span aria-hidden=\"true\">#</span></a></h3>\n<p>Framework powinien być na spójny na każdym poziomie. Spójność dotyczy każdego poziomu od niskiego (używania stylu programowaniu w Pythonie) aż po wysoki (doświadczenie z używania Django).</p>\n</section>\n</section>\n<section id=\"models\">\n<h2>Modele<a class=\"heading-anchor\" href=\"#models\"><span class=\"visually-hidden\">Link to this heading</span><span aria-hidden=\"true\">#</span></a></h2>\n<section id=\"id7\">\n<h3>Wprost jest lepiej niż nie wprost.<a class=\"heading-anchor\" href=\"#id7\"><span class=\"visually-hidden\">Link to this heading</span><span aria-hidden=\"true\">#</span></a></h3>\n<p>Pola nie powinny przyjmować pewnych zachowań bazując jedynie na nazwie pola. To wymaga zbyt dużo wiedzy o systemie i jest podatne na błędy. Natomiast, zachowania powinny bazować na kluczowych argumentach i, w niektórych przypadkach na typie pola.</p>\n</section>\n<section id=\"include-all-relevant-domain-logic\">\n<h3>Uwzględnij całą istotną logikę domeny.<a class=\"heading-anchor\" href=\"#include-all-relevant-domain-logic\"><span class=\"visually-hidden\">Link to this heading</span><span aria-hidden=\"true\">#</span></a></h3>\n<p>Modele powinny hermetyzować każdy aspekt obiektu, zgodnie z wzorcem projektowym <a class=\"reference external\" href=\"https://www.martinfowler.com/eaaCatalog/activeRecord.html\">Active Record</a>, którego autorem jest Martin Fowler.</p>\n<p>To jest powód dla którego dane zarówno reprezentowane przez model i informacje o nim (to jest nazwa czytelna dla człowieka, opcje jak np. domyślne sortowanie itp.) są trzymane w klasie modelu; wszystkie informacje potrzebne do zrozumienia danego modelu powinny być w nim przechowywane.</p>\n</section>\n</section>\n<section id=\"database-api\">\n<h2>API baz danych<a class=\"heading-anchor\" href=\"#database-api\"><span class=\"visually-hidden\">Link to this heading</span><span aria-hidden=\"true\">#</span></a></h2>\n<p>Podstawowymi celami API baz danych są:</p>\n<section id=\"sql-efficiency\">\n<h3>Efektywność SQL<a class=\"heading-anchor\" href=\"#sql-efficiency\"><span class=\"visually-hidden\">Link to this heading</span><span aria-hidden=\"true\">#</span></a></h3>\n<p>Powinno się wykonywać zapytanie SQL tak rzadko jak to możliwe, dodatkowo powinno się optymalizować zapytania wewnętrznie.</p>\n<p>To jest powód dla którego programiści muszą odwołać się do  <code class=\"docutils literal notranslate\"><span class=\"pre\">save()</span></code> wprost, a framework nie robi tego po cichu w tle.</p>\n<p>To jest dodatkowy powód dlaczego metody <code class=\"docutils literal notranslate\"><span class=\"pre\">select_related()</span></code> <code class=\"docutils literal notranslate\"><span class=\"pre\">QuerySet</span></code> istnieją. Jest to opcjonalne poprawienie wydajności dla częstych przypadków wybierania „każdego powiązanego obiektu”.</p>\n</section>\n<section id=\"terse-powerful-syntax\">\n<h3>Zwięzła, silna składnia.<a class=\"heading-anchor\" href=\"#terse-powerful-syntax\"><span class=\"visually-hidden\">Link to this heading</span><span aria-hidden=\"true\">#</span></a></h3>\n<p>Interfejs bazy danych API powinien udostępniać bogatą, wyrazistą składnię przy możliwie małych nakładzie kodu.  Nie powinien polegać na importowaniu innych modułów lub pomocniczych obiektów.</p>\n<p>Połączenia tabel powinny być wykonywane automatycznie, w tle jeśli jest to konieczne.</p>\n<p>Każdy obiekt powinien mieć dostęp do każdego obiektu z którym jest w relacji, w danym systemie. Ten dostęp powinien być obustronny.</p>\n</section>\n<section id=\"option-to-drop-into-raw-sql-easily-when-needed\">\n<h3>Możliwość łatwego przełączenia się na surowy SQL, kiedy to konieczne.<a class=\"heading-anchor\" href=\"#option-to-drop-into-raw-sql-easily-when-needed\"><span class=\"visually-hidden\">Link to this heading</span><span aria-hidden=\"true\">#</span></a></h3>\n<p>API bazy danych powinno zauważać, że jest to skrót a niekoniecznie wszystko. Framework powinien ułatwiać pisanie spersonalizowanego SQL - całych formuł lub tylko własnych klauzuli <code class=\"docutils literal notranslate\"><span class=\"pre\">WHERE</span></code> jako własne parametry na wywołania API.</p>\n</section>\n</section>\n<section id=\"url-design\">\n<h2>Projekt URL<a class=\"heading-anchor\" href=\"#url-design\"><span class=\"visually-hidden\">Link to this heading</span><span aria-hidden=\"true\">#</span></a></h2>\n<section id=\"id8\">\n<h3>Luźne powiązanie<a class=\"heading-anchor\" href=\"#id8\"><span class=\"visually-hidden\">Link to this heading</span><span aria-hidden=\"true\">#</span></a></h3>\n<p>URLe w aplikacji Django nie powinny być połączone z podstawowym kodem Pythona. Łączenie URLi wraz z nazwami funkcji Pythona nazywa się Złą i Brzydką Rzeczą.</p>\n<p>Poza tym, system URL Django powinien pozwalać, by adresy URL tej samej aplikacji były różne w zależności od kontekstu. Na przykład, jedna strona może przechowywać historie w  <code class=\"docutils literal notranslate\"><span class=\"pre\">/stories/</span></code>, a inna może używać <code class=\"docutils literal notranslate\"><span class=\"pre\">/news/</span></code>.</p>\n</section>\n<section id=\"infinite-flexibility\">\n<h3>Nieskończona elastyczność<a class=\"heading-anchor\" href=\"#infinite-flexibility\"><span class=\"visually-hidden\">Link to this heading</span><span aria-hidden=\"true\">#</span></a></h3>\n<p>URLe powinny być elastyczne jak to tylko możliwe. Każdy wyobrażalny URL powinien być dostępny.</p>\n</section>\n<section id=\"encourage-best-practices\">\n<h3>Zalecane najlepsze praktyki<a class=\"heading-anchor\" href=\"#encourage-best-practices\"><span class=\"visually-hidden\">Link to this heading</span><span aria-hidden=\"true\">#</span></a></h3>\n<p>Framework powinien pozwalać programiście łatwo (albo nawet łatwiej) tworzyć ładne URLe niż brzydkie.</p>\n<p>Rozszerzenia plików w URLu strony internetowej powinny być unikane.</p>\n<p>Przecinki w URLach zasługują na surową karę.</p>\n</section>\n<section id=\"definitive-urls\">\n<span id=\"id9\"></span><h3>Ostateczne URLe<a class=\"heading-anchor\" href=\"#definitive-urls\"><span class=\"visually-hidden\">Link to this heading</span><span aria-hidden=\"true\">#</span></a></h3>\n<p id=\"index-3\">W zasadzie,  <code class=\"docutils literal notranslate\"><span class=\"pre\">foo.com/bar</span></code> i``foo.com/bar/`` są dwoma różnymi URLami, roboty wyszukiwarkowe (oraz niektore narzędzia analizujące ruch w sieci) mogłyby potraktować je jako oddzielne strony. Django powinno postarać się „normalizować” URLe aby roboty wyszukiwarkowe nie były zdezorientowane.</p>\n<p>To uzasadnia używanie ustawienia <a class=\"reference internal\" href=\"/pl/3.2/ref/settings/#std-setting-APPEND_SLASH\"><code class=\"xref std std-setting docutils literal notranslate\"><span class=\"pre\">APPEND_SLASH</span></code></a></p>\n</section>\n</section>\n<section id=\"template-system\">\n<h2>System szablonów<a class=\"heading-anchor\" href=\"#template-system\"><span class=\"visually-hidden\">Link to this heading</span><span aria-hidden=\"true\">#</span></a></h2>\n<section id=\"separate-logic-from-presentation\">\n<span id=\"separation-of-logic-and-presentation\"></span><h3>Oddzielenie logiki od prezentacji<a class=\"heading-anchor\" href=\"#separate-logic-from-presentation\"><span class=\"visually-hidden\">Link to this heading</span><span aria-hidden=\"true\">#</span></a></h3>\n<p>Widzimy, że system szablonów jako narzędzie kontroli prezentacji i prezentacja zorientowana na logikę to jest to. System szablonów nie powinien wspierać funkcjonalności wykraczających poza ten cel.</p>\n</section>\n<section id=\"discourage-redundancy\">\n<h3>Porzuć redundancje<a class=\"heading-anchor\" href=\"#discourage-redundancy\"><span class=\"visually-hidden\">Link to this heading</span><span aria-hidden=\"true\">#</span></a></h3>\n<p>Wiele z dynamicznych stron internetowych używa pewnego wspólnego sposobu projektowania - np. nagłówek, stopka, belka nawigacyjna itp. System szablonów Django powinien sprawić łatwym magazynowanie elementów w jednym miejscu, eliminując duplikaty kodu.</p>\n<p>To jest filozofia przemawiająca za  <a class=\"reference internal\" href=\"/pl/3.2/ref/templates/language/#template-inheritance\"><span class=\"std std-ref\">template inheritance</span></a>.</p>\n</section>\n<section id=\"be-decoupled-from-html\">\n<h3>Bądź oddzielony od HTML<a class=\"heading-anchor\" href=\"#be-decoupled-from-html\"><span class=\"visually-hidden\">Link to this heading</span><span aria-hidden=\"true\">#</span></a></h3>\n<p>System szablonów nie powinien być projektowany tylko jako generator kodu HTML. Powinien być równie dobry w generowaniu innych formatów bazujących na tekście lub po prostu zwykłym tekście.</p>\n</section>\n<section id=\"xml-should-not-be-used-for-template-languages\">\n<h3>XML nie powinien zostać użyty do języka szablonów.<a class=\"heading-anchor\" href=\"#xml-should-not-be-used-for-template-languages\"><span class=\"visually-hidden\">Link to this heading</span><span aria-hidden=\"true\">#</span></a></h3>\n<p id=\"index-4\">Użycie silnika XML do prasowania szablonów wprowadza nowy świat błędów ludzkich w edycji szablonów – i stwarza nieakceptowalny poziom narzutu w  przetwarzaniu szablonu</p>\n</section>\n<section id=\"assume-designer-competence\">\n<h3>Zakładaj kompetencje projektanta<a class=\"heading-anchor\" href=\"#assume-designer-competence\"><span class=\"visually-hidden\">Link to this heading</span><span aria-hidden=\"true\">#</span></a></h3>\n<p>System szablonów nie powinien być zaprojektowany w taki sposób by szablony ładnie wyświetlały się w edytorach WYSIWYG takich jak Dreamweaver. To jest zbyt dużym ograniczeniem i uniemożliwiłoby składni bycie tak ładną jak jest teraz. Django oczekuje od twórców szablonu łatwości edytowania bezpośrednio HTMLa.</p>\n</section>\n<section id=\"treat-whitespace-obviously\">\n<h3>Traktuj białe znaki dosłownie<a class=\"heading-anchor\" href=\"#treat-whitespace-obviously\"><span class=\"visually-hidden\">Link to this heading</span><span aria-hidden=\"true\">#</span></a></h3>\n<p>System szablonów nie powinien robić cudów z białymi znakami. Jeśli szablon zawiera biały znak, system powinien potraktować ten znak tak jak traktuje tekst - po prostu go wyświetlić. Każdy biały znak, który nie jest w znaczniku szablonu, powinien być wyświetlony.</p>\n</section>\n<section id=\"don-t-invent-a-programming-language\">\n<h3>Nie wymyślaj języka programowania<a class=\"heading-anchor\" href=\"#don-t-invent-a-programming-language\"><span class=\"visually-hidden\">Link to this heading</span><span aria-hidden=\"true\">#</span></a></h3>\n<p>Celem jest to, by nie wymyślać języka programowania. Celem jest, by zaoferować na tyle programistyczno-podobnej funkcjonalności, takiej jak branching czy pętle, na ile jest to niezbędne do tworzenia decyzji związanych z prezentacją. <a class=\"reference internal\" href=\"/pl/3.2/topics/templates/#template-language-intro\"><span class=\"std std-ref\">Django Template Language (DTL)</span></a> próbuje uniknąć zaawansowanej logiki.</p>\n<p>System szablonów Django rozpoznaje szablony częściej pisane przez projektantów a nie programistów. W związku z tym nie powinien przyjmować wiedzy o Pythonie.</p>\n</section>\n<section id=\"safety-and-security\">\n<h3>Bezpieczeństwo i ochrona<a class=\"heading-anchor\" href=\"#safety-and-security\"><span class=\"visually-hidden\">Link to this heading</span><span aria-hidden=\"true\">#</span></a></h3>\n<p>System szablonów, w oryginale, powinien zabraniać wstawiania złośliwego kodu - takiego jak komendy usuwające rekordy w bazie danych.</p>\n<p>To kolejny powód, dla którego system szablonów nie zezwala na standardowy kod w Pythonie.</p>\n</section>\n<section id=\"extensibility\">\n<h3>Rozszerzalność<a class=\"heading-anchor\" href=\"#extensibility\"><span class=\"visually-hidden\">Link to this heading</span><span aria-hidden=\"true\">#</span></a></h3>\n<p>System szablonów powinien rozpoznawać że zaawansowani twórcy szablonów mogą chcieć rozszerzyć tę technologię.</p>\n<p>To jest filozofia stoją za wyspecjalizowanymi tagami szablonów i filtrami.</p>\n</section>\n</section>\n<section id=\"views\">\n<h2>Widoki<a class=\"heading-anchor\" href=\"#views\"><span class=\"visually-hidden\">Link to this heading</span><span aria-hidden=\"true\">#</span></a></h2>\n<section id=\"simplicity\">\n<h3>Prostota<a class=\"heading-anchor\" href=\"#simplicity\"><span class=\"visually-hidden\">Link to this heading</span><span aria-hidden=\"true\">#</span></a></h3>\n<p>Pisanie widoku powinno być tak proste jak pisanie funkcji w Pythonie. Developerzy nie powinni być zmuszeni do tworzenia klasy, kiedy wystarczy tylko funkcja.</p>\n</section>\n<section id=\"use-request-objects\">\n<h3>Używaj obiektów zapytań<a class=\"heading-anchor\" href=\"#use-request-objects\"><span class=\"visually-hidden\">Link to this heading</span><span aria-hidden=\"true\">#</span></a></h3>\n<p>Widoki powinny mieć dostęp do obiektów zapytań - obiektów, które przechowują metadane o obecnym zapytaniu. Obiekt powinien być przekazywany bezpośrednio do funkcji widoku, nie powinna ona musieć korzystać z danych zapytania przez globalną zmienną. To czyni testowanie widoków przez przekazywanie ‚fałszywych’ obiektów zapytań lekkim, łatwym i przyjemnym.</p>\n</section>\n<section id=\"id10\">\n<h3>Luźne powiązanie<a class=\"heading-anchor\" href=\"#id10\"><span class=\"visually-hidden\">Link to this heading</span><span aria-hidden=\"true\">#</span></a></h3>\n<p>Dla widoku nie powinno mieć znaczenia jakiego systemu szablonów używa developer - ani czy w ogóle używa jakiegoś systemu szablonów.</p>\n</section>\n<section id=\"differentiate-between-get-and-post\">\n<h3>Różnice pomiędzy GET a POST<a class=\"heading-anchor\" href=\"#differentiate-between-get-and-post\"><span class=\"visually-hidden\">Link to this heading</span><span aria-hidden=\"true\">#</span></a></h3>\n<p>GET i POST są rozłączne; programiści powinni wprost użyć jednego lub drugiego. Framework powinien umożliwiać łatwe rozróżnienie między danymi pochodzącymi z GET lub POST.</p>\n</section>\n</section>\n<section id=\"cache-framework\">\n<span id=\"cache-design-philosophy\"></span><h2>Framework pamięci podręcznej<a class=\"heading-anchor\" href=\"#cache-framework\"><span class=\"visually-hidden\">Link to this heading</span><span aria-hidden=\"true\">#</span></a></h2>\n<p>Głównymi celami Django  <a class=\"reference internal\" href=\"/pl/3.2/topics/cache/\"><span class=\"doc\">cache framework</span></a> są:</p>\n<section id=\"id11\">\n<h3>Mniej kodu<a class=\"heading-anchor\" href=\"#id11\"><span class=\"visually-hidden\">Link to this heading</span><span aria-hidden=\"true\">#</span></a></h3>\n<p>Pamięć podręczna powinna być szybką jak tylko to możliwe. Stąd też, cały kod frameworka otaczający backend pamięci podręcznej powinien być ograniczony do absolutnego minimum, w szczególności w przypadku metody <code class=\"docutils literal notranslate\"><span class=\"pre\">get()</span></code></p>\n</section>\n<section id=\"id12\">\n<h3>Spójność<a class=\"heading-anchor\" href=\"#id12\"><span class=\"visually-hidden\">Link to this heading</span><span aria-hidden=\"true\">#</span></a></h3>\n<p>API pamięci podręcznej powinno zapewniać spójny interfejs w zróżnicowanych pamięciach podręcznych backendów.</p>\n</section>\n<section id=\"id13\">\n<h3>Rozszerzalność<a class=\"heading-anchor\" href=\"#id13\"><span class=\"visually-hidden\">Link to this heading</span><span aria-hidden=\"true\">#</span></a></h3>\n<p>API pamięci podręcznej powinno być rozszerzalne na poziomie aplikacji zależnie od potrzeb developera (dla przykładu, zobacz <a class=\"reference internal\" href=\"/pl/3.2/topics/cache/#cache-key-transformation\"><span class=\"std std-ref\">Cache key transformation</span></a>).</p>\n</section>\n</section>","rootId":"design-philosophies","toc":[{"title":"Ogółem","anchor":"overall","children":[{"title":"Luźne powiązanie","anchor":"loose-coupling","children":[]},{"title":"Mniej kodu","anchor":"less-code","children":[]},{"title":"Szybki rozwój","anchor":"quick-development","children":[]},{"title":"Nie powtarzaj się (DRY)","anchor":"don-t-repeat-yourself-dry","children":[]},{"title":"Wprost jest lepiej niż nie wprost.","anchor":"explicit-is-better-than-implicit","children":[]},{"title":"Spójność","anchor":"consistency","children":[]}]},{"title":"Modele","anchor":"models","children":[{"title":"Wprost jest lepiej niż nie wprost.","anchor":"id7","children":[]},{"title":"Uwzględnij całą istotną logikę domeny.","anchor":"include-all-relevant-domain-logic","children":[]}]},{"title":"API baz danych","anchor":"database-api","children":[{"title":"Efektywność SQL","anchor":"sql-efficiency","children":[]},{"title":"Zwięzła, silna składnia.","anchor":"terse-powerful-syntax","children":[]},{"title":"Możliwość łatwego przełączenia się na surowy SQL, kiedy to konieczne.","anchor":"option-to-drop-into-raw-sql-easily-when-needed","children":[]}]},{"title":"Projekt URL","anchor":"url-design","children":[{"title":"Luźne powiązanie","anchor":"id8","children":[]},{"title":"Nieskończona elastyczność","anchor":"infinite-flexibility","children":[]},{"title":"Zalecane najlepsze praktyki","anchor":"encourage-best-practices","children":[]},{"title":"Ostateczne URLe","anchor":"definitive-urls","children":[]}]},{"title":"System szablonów","anchor":"template-system","children":[{"title":"Oddzielenie logiki od prezentacji","anchor":"separate-logic-from-presentation","children":[]},{"title":"Porzuć redundancje","anchor":"discourage-redundancy","children":[]},{"title":"Bądź oddzielony od HTML","anchor":"be-decoupled-from-html","children":[]},{"title":"XML nie powinien zostać użyty do języka szablonów.","anchor":"xml-should-not-be-used-for-template-languages","children":[]},{"title":"Zakładaj kompetencje projektanta","anchor":"assume-designer-competence","children":[]},{"title":"Traktuj białe znaki dosłownie","anchor":"treat-whitespace-obviously","children":[]},{"title":"Nie wymyślaj języka programowania","anchor":"don-t-invent-a-programming-language","children":[]},{"title":"Bezpieczeństwo i ochrona","anchor":"safety-and-security","children":[]},{"title":"Rozszerzalność","anchor":"extensibility","children":[]}]},{"title":"Widoki","anchor":"views","children":[{"title":"Prostota","anchor":"simplicity","children":[]},{"title":"Używaj obiektów zapytań","anchor":"use-request-objects","children":[]},{"title":"Luźne powiązanie","anchor":"id10","children":[]},{"title":"Różnice pomiędzy GET a POST","anchor":"differentiate-between-get-and-post","children":[]}]},{"title":"Framework pamięci podręcznej","anchor":"cache-framework","children":[{"title":"Mniej kodu","anchor":"id11","children":[]},{"title":"Spójność","anchor":"id12","children":[]},{"title":"Rozszerzalność","anchor":"id13","children":[]}]}],"breadcrumbs":[{"docname":"misc/index","title":"Meta-dokumentacja i rozmaitości","url":"/pl/3.2/misc/"}],"prev":{"docname":"misc/api-stability","title":"Stabilność API","url":"/pl/3.2/misc/api-stability/"},"next":{"docname":"misc/distributions","title":"Dystrybucje Django od osób trzecich","url":"/pl/3.2/misc/distributions/"},"formats":{"html":"/pl/3.2/misc/design-philosophies/","markdown":"/pl/3.2/misc/design-philosophies.md","json":"/pl/3.2/misc/design-philosophies.json"},"source":"https://github.com/django/django/blob/stable/3.2.x/docs/misc/design-philosophies.txt","official":"https://docs.djangoproject.com/pl/3.2/misc/design-philosophies/","inVersions":["6.1","6.0","5.2","5.1","5.0","4.2","4.1","4.0","3.2","3.1","3.0","2.2","2.1","2.0","1.11","1.10"],"inLocales":["en","zh-hans","fr","ja","id","it","pt-br","ko","es","el","pl"]}