From d35306e637181eb30098ade75a893f4934a4d990 Mon Sep 17 00:00:00 2001 From: Syndamia Date: Wed, 21 Feb 2024 22:10:49 +0200 Subject: [te/oop-2023/w1] Added presentations and exercises --- src/teaching/oop-2023/week1/good-software.md | 519 +++++++++++++++++++++++++++ 1 file changed, 519 insertions(+) create mode 100644 src/teaching/oop-2023/week1/good-software.md (limited to 'src/teaching/oop-2023/week1/good-software.md') diff --git a/src/teaching/oop-2023/week1/good-software.md b/src/teaching/oop-2023/week1/good-software.md new file mode 100644 index 0000000..9e2e833 --- /dev/null +++ b/src/teaching/oop-2023/week1/good-software.md @@ -0,0 +1,519 @@ +# Основни добри софтуерни практики - ООП, Седмица 1, 22.02.2024 + +Миналия семестър не ни стигна времето да обсъдим домашното по-сериозно. +Главния проблем, който забелязах, беше колко грозно и нагласено бяха написани решенията. +Като въведение в ООП, ще поговорим по тази тема. + +&&presentation + +&&clide &¢ered &&font35 + +# Основни идеи
при добро писане на код + +&&/font &&/centered &&/clide + + + +&&slide &&font35 + +## Какво прави програмиста с чужд код? + +&&lineb4 + +1. Чете +2. Разучава как се ползва/какво прави +3. Използва го/Модифицира го + +Добър код прави тези задачи лесни! + +&&/font &&/slide + + + +&&slide &&font35 + +## Подобряване на четене + +&&lineb3 + +- Лично вярвам, че четимост е по-важна от конвенции +- Човек вижда най-лесно "контрастни" шаблони + + +``` + . . 0.00.0 010010 815213 + 000000 000000 738438 +. . .0000. 100001 122481 + .... 0....0 011110 511119 +``` + +&&/font &&/slide + + + +Както виждате, в примера има усмихнато личице, "закодирано" по различни начини. +С точка и шпации е най-ясно, като заменим шпациите с нули става по-неясно, като заменим точките с единици става още повече и като заменим нулите със случайни не-единични цифри, става пък съвсем невидимо. +Важното е шаблона да се намира в среда на други шаблони, иначе трудно се забелязва. + +При код, ще илюстрирам идеята си с един пример, но няма да задълбавам, следващата секция е много по-важна. +Пък и тази тема е малко религиозна и ще чувате различни мнения според човека който питате. + + + +&&clide + +Труден за четене код *(забелязвате ли грешките?)*: + +&&font22 + +``` +int a, b; +std::cout << "Enter coordinates" << std::endl; +std::cin >> a; +if (a == -1) return layerNavigation(board, rows, cols, layers); +if (a < 0 || a >= rows || b < 0 || a >= cols) return false; +for (int i = 0; i < layers; i++) { +if (board[a][b][i] == ' ') { + for (int j = 0; j < 8; j++){ + if (enptyRow[j] != ' ') { + emptyRow[j] = board[a][b][i]; + board[a][b][i] = ' '; + return true; + } + } + return false; +} +} +``` + +&&/font &&/clide + + + +Нарочно съм премахнал оцветяването, то драстично помага, но тук повече се интересуваме от "формата" на код. + +Вмъкнал съм три грешки: едно нещо липсва, има една печатна и една логическа грешка. +Разбира се, ако се зачетете дума по дума сигурно ще ги откриете, но сега да сравним. + + + +&&clide + +По-лесен за четене код *(а сега виждат ли се по-лесно?)*: + +&&font18 + +``` +std::cout << "Enter coordinates" << std::endl; +int a, b; + +std::cin >> a; +if (a == -1) { + return layerNavigation(board, rows, cols, layers); +} + +if (a < 0 || a >= rows || b < 0 || a >= cols) { + return false; +} + +for (int i = 0; i < layers; i++) +{ + if (board[a][b][i] == ' ') + { + for (int j = 0; j < 8; j++) + { + if (enptyRow[j] != ' ') { + emptyRow[j] = board[a][b][i]; + board[a][b][i] = ' '; + + return true; + } + } + return false; + } +} +``` + +&&/font &&/clide + + + +Би трябвало да е малко по-лесно, в последния `if` имаме "e**n**ptyRow", което е печатната грешка, `!=` което трябва да бъде `==` и липсва въвеждането на `b` след първия `if`. + +Примерът не е перфектен, но илюстрира какво се опитвам да кажа: формата на код е от огромно значение, обръщайте ѝ внимание. + + + +&&slide + +## Абстракцията - улеснява изучаване И употреба/модификация + +&&lineb1 + +- Разделяме обработване на стойностите от директната имплементацията +- Създаваме нови "машинни инструкции" + +&&lineb1 + +- `doX()` е по-лошо от `do(X)` + - можем да преизползваме `do()` за неща, различни от `X` + - един път разбрано, всяка употреба на `do()` също е разбрана; този стил кара `do()` да бъде по-обща функция, което я прави по-лесна за разбиране + - модификация на `do(X)` се свежда до заменяне на `do()` с `doOther()` или до заменяне на `X` с `Y`; променяме "инструкцията" или променяме данната + +&&/slide + + + +Нека сега разгледаме няколко примера, първият е много груб и елементарен, но служи за добро начало: + + + +&&clide + + +```cpp +Лошо - doX() │ Добро - do(X) + │ +int fib5() │ int fib(int n) +{ │ { + int prev = 0, curr = 1; │ int prev = 0, curr = 1; + for (int i = 1; i < 5; i++) │ for (int i = 1; i < n; i++) + { │ { + int tempPrev = prev; │ int tempPrev = prev; + prev = curr; │ prev = curr; + curr = curr + prev; │ curr = curr + prev; + } │ } + return curr; │ return curr; +} │ } +``` + +&&/clide + + + +Би трябвало да е супер очевидно, никой няма да пише отделна функция на Фибоначи за всяко число. + +Нека сега да разгледаме няколко "реални" примера, свързани с домашното (за припомняне, условието се намира [тук](https://learn.fmi.uni-sofia.bg/mod/assign/view.php?id=296069)). +Самите решения няма винаги да са добре форматирани, това е направено с цел да се поберат добре в слайда. + +Първия е върху функция, която приема координатите на плочка, премахва я от дъската (ако съществува) и я слага в края на празния ред. + + + +&&slide + +Лошо - `doX()` в тялото на функцията + +```cpp +void tryTakeTile(char** board, int rows, int cols, + char emptyRow[8]) { + int x, y; + std::cin >> x >> y; + if (x<0 || x>=rows || y<0 || y>=cols || board[x][y] == ' ') { + std::cout << "Invalid coordinates!" << std::endl; + } + else { + int emptyRowIndex = -1; + for (int i = 0; i < 8; i++) { + if (emptyRow[i] == ' ') { + emptyRowIndex = i; + break; + } + } + emptyRow[emptyRowIndex] = board[x][y]; + board[x][y] = ' '; + } +} +``` + +&&/slide + + + +Повечето предадени работи са имплементирали функционалността по точно този начин. +Замислете се обаче, какво става ако сменим типа данна, тоест ако дъската е триизмерна? +Тогава трябва да добавим още една `int` променлива, още едно условие в `if`, трябва да я добавим при трите индексирания на `board`. + +Какво става ако променим самата структура от данни за `emptyRow` (за сега сте учили само масиви, но скоро ще видите, че има и други начини да съхраняваш редица информация), тогава ще трябва да пренапишем целия цикъл. + +Тоест, ако променим нещо, трябва да пренапишем значителни части от самия код, и като разширим това върху 10-20 функции, изведнъж малка промяна става голяма. +Нека сега да пренапишем функцията, използвайки колкото се може повече абстракция. + + +&&clide + +Добро - `do(X)` + +```cpp +bool tryReadCoordinates(int& x, int& y) { + std::cin >> x >> y; + if (!availablePosition(board, rows, cols, x, y)) { + std::cout << "Invalid coordinates!" << std::endl; + return false; + } + return true; +} + +void tryTakeTile(char** board, int rows, int cols, + char emptyRow[8]) { + int x, y; + if (tryReadCoordinates(x, y)) { + appendToArray(emptyRow, 8, board[x][y]); + board[x][y] = ' '; + } +} +``` + +&&/clide + + + +Искаме трето измерение на `board`? +Няма проблем, написали сме нова `tryReadCoordinates`, която приема три променливи, и в `tryTakeTile` добавяме една декларация и обновяваме двете индексирания на `board`. +Ако `emptyRow` стане друг тип данна, просто променяме функцията да бъде `appendToOtherDataType` и сме готови. + +И ако тази промяна трябва да се направи в много функции, даже бихме могли да употребяваме функционалност на самия текстов редактор да търси и заменя срещания на един низ с друг. + +Нека сега да увеличим сложността още малко, да разгледаме функция за генерирането на дъската. +Отново, повечето предадени решения изглеждаха подобни на примера. + + + +&&slide + +Лошо - всички цикли са `doX()` + +```cpp +void generateLayer(char** layer, int rows, int cols, + char* tiles, int* tileCounts, int tilesSize) { + for (int i = 0; i < rows; i++) { + for (int j = 0; j < cols; j++) { + layer[i][j] = ' '; + } + } + for (int i = 0; i < tilesSize; i++) { + for (int j = 0; j < tileCounts[i]; j++) { + int x, y; + do { // randNum(x,y) връща случайно число∈[x,y] + x = randNum(0, rows - 1); + y = randNum(0, cols - 1); + } while(layer[x][y] != ' '); + layer[x][y] = tileCounts[i]; + } + } +} +``` + +&&/slide + + + +Стария проблем, някакви цикли, ако искаме да променям някоя данна или как нещо работи, трябва да пренапишем половината функция. + +Този сегмент е по-интересен за променяне от преди, понеже за да го направим хубаво трябва да променим самата ни логика. +Запълването със шпации е ясно, обаче случайното поставяне на плочки не е. + +Ако имаме функция `placeRandomЕлемент` която само поставя една плочка в слоя, пак ще имаме вложени цикли, трябва да има начин да останем с един цикъл. +Ако направим `placeRandomElementNTimes`, тогава пък абстрахираната функция става твърде специфична и вече имаме `doX()` при самата нея. + +Чрез функционално програмиране този проблем може да се разреши лесно, обаче вие ще го учите следващия семестър. +С достатъчно размишления, може да стигнем до следния вариант: вместо всяка плочка да я поставяме на случайна позиция, защо не поставим всички плочки една след друга и не разбъркаме слоя? + + + +&&clide + +Добро - `do(X)` + +```cpp +void generateLayer(char** layer, int rows, int cols, + char* tiles, int* tileCounts, int tilesSize) { + fillMatrix(layer, rows, cols, '\0'); + for (int i = 0; i < tilesSize; i++) { + // appendToMatrix(mat,rows,cols,fill,max): + // замества първите (най-много) max празни клетки с fill + // връща колко клетки наистина е заместило + appendToMatrix(layer, rows, cols, + tiles[i], tileCounts[i]); + } + shuffleMatrix(layer, rows, cols); +} +``` + +**Бонус:** работи по-коректно от преди + +&&/clide + + + +В предходния вариант, ако примерно цялата е пълна освен една клетка, и трябва да поставим една финална плочка, тогава трябва да чакаме докато случайните стойности се напаснат точно с координатите на тази една клетка. +Това може да се случи след половин секунда, но може да отнеме и един час докато се случи. +Даже, този проблем става все по-тегав с времето: с всяка запълнена клетка, шанса случайните стойности да ударят на заети координати се увеличава. + +Докато тук, нямаме този проблем, отнема някакво консистентно предопределено време да разбъркаме матрицата. +Как имплементираме `shuffleMatrix` си има и своите тънкости, но най-елементарния начин е просто да направим сортираш алгоритъм, при който вместо да сравним две стойности, използваме случайна стойност, която определя дали ще разменим плочките. + +Друго хубаво нещо на решения с абстракция, е един лек лавинен ефект, където веднъж като почнем да мислим за абстракции, намираме къде да ги ползваме навсякъде. +Да разгледаме същата функция, обаче при D подточка. + + + +&&clide + +Решения със слоеве правят същото. Лошо - `doX()` при циклите: + +```cpp +void generate(char*** board, int rows, int cols, int layers, + char* tiles, int* tileCounts, int tilesSize) { + ... + do { + x = randNum(0, rows - 1); y = randNum(0, cols - 1); + layer = randNum(0, layers - 1); + } while(layer[x][y][layer] != ' '); + ... +} +``` + +&&/clide + + + +Без абстракция отново ще пренапишем голяма част от `generate` функцията, за да се побере на слайда съм оставил само "най-сложната" промяна - случайните стойности. +Пак, имаше решения на подточката, без преизползване на `generate` за един слой. +Айде да разгледаме решението, заедно с абстрахираната `generate`. + + + +&&slide + +Добро - `do(X)` + +```cpp +void generateLayer(char** layer, int rows, int cols, + char* tiles, int* tileCounts, int tilesSize) { + fillMatrix(layer, rows, cols, '\0'); + for (int i = 0; i < tilesSize; i++) { + int actuallyAppended = + appendToMatrix(layer, rows, cols, + tiles[i], tileCounts[i]); + tileCounts[i] -= actuallyAppended; + } + shuffleMatrix(layer, rows, cols); +} +void generate(char*** board, int rows, int cols, int layers, + char* tiles, int* tileCounts, int tilesSize) { + for (int i = 0; i < layers; i++) { + generateLayer(board[i], rows, cols, + tiles, tileCounts, tilesSize); + } +} +``` + +&&/slide + + + +Супер елементарно, има-няма 5-6 реда код промяна, при генериране за всеки слой, просто извикваме функцията за генериране върху един слой, за всеки слой. +А в самата функция само премахваме броя вмъкнати плочки от сумата на даден тип. + +Наблюдателните са забелязали, че в "ръчното" решение слоевете са третия индекс, тоест имаме `board[x][y][layer]`, докато в това решение е първия, тоест `board[layer][x][y]`. +Разликата е значителна, но от гледна точка на код, особено когато използваме абстракция, промяната е лесна. + +Иначе, в момента се намираме в много добра позиция, без абстракция как правим рестартирането на играта? +По условие броя и типовете плочки трябва да се запазят, но позиции не. +Истината е, че става малко тромаво: цикълът за намираме на позиции се преизползва, и броя плочки трябва да се запази. + +Обаче, сега това става с едно `shuffleMatrix`, не е нужно нищо специално да правим! + + + +&&clide &&font35 + +### Абстракцията - подобрява и коментари + +- Целта на коментарите е да направи разбиране и модификация на код по-лесни. +- В повечето случаи, коментарът трябва да ни дава *нова* информация или да *свърже* парчета информация + +&&/font &&/clide + + + +Да разгледаме следния пример. + + + +&&clide + +Лошо: + +```cpp +// Fill matrix with '\0' +for (int i = 0; i < rows; i++) { + for (int j = 0; j < cols; j++) { + matrix[i][j] = '\0'; + } +} +``` + +Добро: + +```cpp +// Prepare matrix for functionX +// (for which empty cells are '\0') +for (int i = 0; i < rows; i++) { + for (int j = 0; j < cols; j++) { + matrix[i][j] = '\0'; + } +} +``` + + +&&/clide + + + +При добрия вариант, получаваме нова информация, че това запълване се случва понеже ще подаваме към някаква си `functionX`, и че евентуално може да има други функции, при които празни клетки може да не се обозначават с `'\0'`. +В лошия можем да стигнем до същото заключение като погледнем самия код. + + + +Умението да разрешиш един проблем *не те* прави добър програмист, да го разрешиш по четим, разширяем, лесен, ефикасен, ... начин *те* прави добър програмист. + + + +&&slide &&font35 + +## Изводи + +&&lineb4 + +- Форматирайте/подравнявайте си кода, искате лесно четене +- Вдигайте абстракция + - Обширни функции > код за конкретни стойности + - Преизползване на възможно най-много код + - Коментари които дават или разширяват знание + +&&/font &&/slide -- cgit v1.3.1-26-gb76a From 86a913d3e15803d7a8775d86601e19cf5f720b96 Mon Sep 17 00:00:00 2001 From: Syndamia Date: Fri, 23 Feb 2024 21:30:56 +0200 Subject: (te/oop-2023/w1) Reworked presentations into MEL format, from Presentation.awk's ftags --- src/teaching/oop-2023/week1/good-software.md | 86 ++++++++++++++-------------- src/teaching/oop-2023/week1/organization.md | 20 +++---- 2 files changed, 53 insertions(+), 53 deletions(-) (limited to 'src/teaching/oop-2023/week1/good-software.md') diff --git a/src/teaching/oop-2023/week1/good-software.md b/src/teaching/oop-2023/week1/good-software.md index 9e2e833..bd34bb2 100644 --- a/src/teaching/oop-2023/week1/good-software.md +++ b/src/teaching/oop-2023/week1/good-software.md @@ -4,21 +4,21 @@ Главния проблем, който забелязах, беше колко грозно и нагласено бяха написани решенията. Като въведение в ООП, ще поговорим по тази тема. -&&presentation +&.presentation -&&clide &¢ered &&font35 +&[title # Основни идеи
при добро писане на код -&&/font &&/centered &&/clide +&] -&&slide &&font35 +&[slide35 ## Какво прави програмиста с чужд код? -&&lineb4 +&.br4 1. Чете 2. Разучава как се ползва/какво прави @@ -26,15 +26,15 @@ Добър код прави тези задачи лесни! -&&/font &&/slide +&] -&&slide &&font35 +&[slide35 ## Подобряване на четене -&&lineb3 +&.br4 - Лично вярвам, че четимост е по-важна от конвенции - Човек вижда най-лесно "контрастни" шаблони @@ -47,7 +47,7 @@ .... 0....0 011110 511119 ``` -&&/font &&/slide +&] @@ -60,11 +60,11 @@ -&&clide +&[vcen Труден за четене код *(забелязвате ли грешките?)*: -&&font22 +&(font22 ``` int a, b; @@ -86,7 +86,7 @@ if (board[a][b][i] == ' ') { } ``` -&&/font &&/clide +&) &] @@ -97,11 +97,11 @@ if (board[a][b][i] == ' ') { -&&clide +&[vcen По-лесен за четене код *(а сега виждат ли се по-лесно?)*: -&&font18 +&(font18 ``` std::cout << "Enter coordinates" << std::endl; @@ -134,7 +134,7 @@ for (int i = 0; i < layers; i++) } ``` -&&/font &&/clide +&) &] @@ -144,23 +144,23 @@ for (int i = 0; i < layers; i++) -&&slide +&[slide ## Абстракцията - улеснява изучаване И употреба/модификация -&&lineb1 +&.br1 - Разделяме обработване на стойностите от директната имплементацията - Създаваме нови "машинни инструкции" -&&lineb1 +&.br1 - `doX()` е по-лошо от `do(X)` - можем да преизползваме `do()` за неща, различни от `X` - един път разбрано, всяка употреба на `do()` също е разбрана; този стил кара `do()` да бъде по-обща функция, което я прави по-лесна за разбиране - модификация на `do(X)` се свежда до заменяне на `do()` с `doOther()` или до заменяне на `X` с `Y`; променяме "инструкцията" или променяме данната -&&/slide +&] @@ -168,7 +168,7 @@ for (int i = 0; i < layers; i++) -&&clide +&[vcen ```cpp @@ -187,7 +187,7 @@ int fib5() │ int fib(int n) } │ } ``` -&&/clide +&] @@ -200,7 +200,7 @@ int fib5() │ int fib(int n) -&&slide +&[slide Лошо - `doX()` в тялото на функцията @@ -226,7 +226,7 @@ void tryTakeTile(char** board, int rows, int cols, } ``` -&&/slide +&] @@ -240,7 +240,7 @@ void tryTakeTile(char** board, int rows, int cols, Нека сега да пренапишем функцията, използвайки колкото се може повече абстракция. -&&clide +&[vcen Добро - `do(X)` @@ -264,7 +264,7 @@ void tryTakeTile(char** board, int rows, int cols, } ``` -&&/clide +&] @@ -279,7 +279,7 @@ void tryTakeTile(char** board, int rows, int cols, -&&slide +&[slide Лошо - всички цикли са `doX()` @@ -304,7 +304,7 @@ void generateLayer(char** layer, int rows, int cols, } ``` -&&/slide +&] @@ -321,7 +321,7 @@ void generateLayer(char** layer, int rows, int cols, -&&clide +&[vcen Добро - `do(X)` @@ -342,7 +342,7 @@ void generateLayer(char** layer, int rows, int cols, **Бонус:** работи по-коректно от преди -&&/clide +&] @@ -358,7 +358,7 @@ void generateLayer(char** layer, int rows, int cols, -&&clide +&[vcen Решения със слоеве правят същото. Лошо - `doX()` при циклите: @@ -374,7 +374,7 @@ void generate(char*** board, int rows, int cols, int layers, } ``` -&&/clide +&] @@ -384,7 +384,7 @@ void generate(char*** board, int rows, int cols, int layers, -&&slide +&[slide Добро - `do(X)` @@ -409,7 +409,7 @@ void generate(char*** board, int rows, int cols, int layers, } ``` -&&/slide +&] @@ -427,14 +427,14 @@ void generate(char*** board, int rows, int cols, int layers, -&&clide &&font35 +&[vcen35 ### Абстракцията - подобрява и коментари - Целта на коментарите е да направи разбиране и модификация на код по-лесни. - В повечето случаи, коментарът трябва да ни дава *нова* информация или да *свърже* парчета информация -&&/font &&/clide +&] @@ -442,7 +442,7 @@ void generate(char*** board, int rows, int cols, int layers, -&&clide +&[vcen Лошо: @@ -468,7 +468,7 @@ for (int i = 0; i < rows; i++) { ``` -&&/clide +&] @@ -482,17 +482,17 @@ for (int i = 0; i < rows; i++) { -&&clide +&[vcen > For practical reasons, the demonstration programs must be small, many times smaller than the "life-size programs" I have in mind. My basic problem is that precisely this difference in scale is one of the major sources of our difficulties in programming! — Edsger W. Dijkstra, [Notes on Structured Programming, On our inability to do much](https://www.cs.utexas.edu/users/EWD/ewd02xx/EWD249.PDF) -&&lineb1 +&.br1 Решение на цялото домашно, с описаните методи TODO -&&/clide +&] @@ -504,11 +504,11 @@ for (int i = 0; i < rows; i++) { -&&slide &&font35 +&[slide35 ## Изводи -&&lineb4 +&.br4 - Форматирайте/подравнявайте си кода, искате лесно четене - Вдигайте абстракция @@ -516,4 +516,4 @@ for (int i = 0; i < rows; i++) { - Преизползване на възможно най-много код - Коментари които дават или разширяват знание -&&/font &&/slide +&] diff --git a/src/teaching/oop-2023/week1/organization.md b/src/teaching/oop-2023/week1/organization.md index 866b93a..dfdeafa 100644 --- a/src/teaching/oop-2023/week1/organization.md +++ b/src/teaching/oop-2023/week1/organization.md @@ -1,12 +1,12 @@ # Организация - ООП, Седмица 1, 22.02.2024 -&&presentation +&.presentation -&&clide &¢ered &&font35 +&[title35 # Добре дошли в ООП -&&/font &&/centered &&/clide +&] @@ -14,13 +14,13 @@ -&&clide &&font35 +&[vcen35 - ООП практикум е избираема, която няма смисъл да не запишете - Само плюсове за вас - Оценката е според контролни/изпити по ООП -&&/font &&/clide +&] @@ -29,14 +29,14 @@ -&&clide &&font35 +&[vcen35 - Освобождаване от изпит според работата ви по време на практикум - Няма намаляване на оценка - Оценявам общите ви умения
Важното е да умеете да сте програмисти: коректност, брой и трудност на решени задачи се зачитат по-малко отколкото успех да напишете прилично-изглеждаща програма (дори с малко мой тласък) -&&/font &&/clide +&] @@ -44,16 +44,16 @@ -&&clide &&font35 +&[vcen35 - Зачитат се **единствено нещата, качени в GitHub classroom, качени в срок** - До **15** минути след края на часа - Както преди, не е нужно да присъствате, за да качвате решения - Ако случайно някой не знае как се ползва: -&¢ered [syndamia.com/upp-2023/week1/setup.html?a](../upp-2023/week1/setup.html?a) &&/centered +&(centered [syndamia.com/upp-2023/week1/setup.html?a](../upp-2023/week1/setup.html?a) &) -&&/font &&/clide +&] -- cgit v1.3.1-26-gb76a From 535bf9a4649e0e73450b1c7bed7460a9c3225706 Mon Sep 17 00:00:00 2001 From: Syndamia Date: Mon, 26 Feb 2024 09:10:47 +0200 Subject: (te/oop-2023/w1) Updated presentations with new MEL-Presentation tag names --- src/teaching/oop-2023/week1/good-software.md | 18 +++++++++--------- src/teaching/oop-2023/week1/organization.md | 6 +++--- 2 files changed, 12 insertions(+), 12 deletions(-) (limited to 'src/teaching/oop-2023/week1/good-software.md') diff --git a/src/teaching/oop-2023/week1/good-software.md b/src/teaching/oop-2023/week1/good-software.md index bd34bb2..79a51b0 100644 --- a/src/teaching/oop-2023/week1/good-software.md +++ b/src/teaching/oop-2023/week1/good-software.md @@ -60,7 +60,7 @@ -&[vcen +&[middle Труден за четене код *(забелязвате ли грешките?)*: @@ -97,7 +97,7 @@ if (board[a][b][i] == ' ') { -&[vcen +&[middle По-лесен за четене код *(а сега виждат ли се по-лесно?)*: @@ -168,7 +168,7 @@ for (int i = 0; i < layers; i++) -&[vcen +&[middle ```cpp @@ -240,7 +240,7 @@ void tryTakeTile(char** board, int rows, int cols, Нека сега да пренапишем функцията, използвайки колкото се може повече абстракция. -&[vcen +&[middle Добро - `do(X)` @@ -321,7 +321,7 @@ void generateLayer(char** layer, int rows, int cols, -&[vcen +&[middle Добро - `do(X)` @@ -358,7 +358,7 @@ void generateLayer(char** layer, int rows, int cols, -&[vcen +&[middle Решения със слоеве правят същото. Лошо - `doX()` при циклите: @@ -427,7 +427,7 @@ void generate(char*** board, int rows, int cols, int layers, -&[vcen35 +&[middle35 ### Абстракцията - подобрява и коментари @@ -442,7 +442,7 @@ void generate(char*** board, int rows, int cols, int layers, -&[vcen +&[middle Лошо: @@ -482,7 +482,7 @@ for (int i = 0; i < rows; i++) { -&[vcen +&[middle > For practical reasons, the demonstration programs must be small, many times smaller than the "life-size programs" I have in mind. My basic problem is that precisely this difference in scale is one of the major sources of our difficulties in programming! diff --git a/src/teaching/oop-2023/week1/organization.md b/src/teaching/oop-2023/week1/organization.md index dfdeafa..92fdcc8 100644 --- a/src/teaching/oop-2023/week1/organization.md +++ b/src/teaching/oop-2023/week1/organization.md @@ -14,7 +14,7 @@ -&[vcen35 +&[middle35 - ООП практикум е избираема, която няма смисъл да не запишете - Само плюсове за вас @@ -29,7 +29,7 @@ -&[vcen35 +&[middle35 - Освобождаване от изпит според работата ви по време на практикум - Няма намаляване на оценка @@ -44,7 +44,7 @@ -&[vcen35 +&[middle35 - Зачитат се **единствено нещата, качени в GitHub classroom, качени в срок** - До **15** минути след края на часа -- cgit v1.3.1-26-gb76a