Summary Files Commits Branches @commit @diff @stats
path: root / src / teaching / oop-2023 / week1
diff options
context:
space:
mode:
Commitbebe00ac39236bbfe6d00c5e620e2f26ba098ae8 (patch)
Author
 Kamen Mladenov <kamen@syndamia.com>
2026-09-14 12:36:01 +0300
Committer
 Kamen Mladenov <kamen@syndamia.com>
2026-09-14 12:36:01 +0300
Files3e48ba1a7a555de51db3ed77dcf81ce15f844dbb /src/teaching/oop-2023/week1
syndamia.com-bebe00ac39236bbfe6d00c5e620e2f26ba098ae8.tar
syndamia.com-bebe00ac39236bbfe6d00c5e620e2f26ba098ae8.tar.gz
syndamia.com-bebe00ac39236bbfe6d00c5e620e2f26ba098ae8.zip
Parent918bac7614e560678d51bfba2a25582a3284bdd9 (diff)
Parent3bf2c2004c1c3ea1748983247e1fcf12913d587f (diff)
Merge branch 'update_dunbar' into 'master'
feat!: Update dunbar markup See merge request Syndamia/syndamiadotcom!17
3 files changed, 91 insertions, 71 deletions
-rw-r--r--src/teaching/oop-2023/week1/good-software.du87
-rw-r--r--src/teaching/oop-2023/week1/index.du60
-rw-r--r--src/teaching/oop-2023/week1/organization.du15
diff --git a/src/teaching/oop-2023/week1/good-software.du b/src/teaching/oop-2023/week1/good-software.du
index 3f8fd9a..237cec2 100644
--- a/src/teaching/oop-2023/week1/good-software.du
+++ b/src/teaching/oop-2023/week1/good-software.du
@@ -1,4 +1,7 @@
-# Основни добри софтуерни практики - ООП, Седмица 1, 22.02.2024
+'def title Основни добри софтуерни практики - ООП, Седмица 1, 22.02.2024
+'def desc Миналия семестър не ни стигна времето да обсъдим домашното по-сериозно. Главния проблем, който забелязах, беше колко грозно и нагласено бяха написани решенията. Ще поговорим по тази тема.
+
+# {title}
\n
@@ -6,7 +9,7 @@
Главния проблем, който забелязах, беше колко грозно и нагласено бяха написани решенията.
Като въведение в ООП, ще поговорим по тази тема.
-[$presentation-controller]
+{presentation-controller}
:title_slide
@@ -18,7 +21,7 @@
## Какво прави програмиста с чужд код?
-[$br4]
+{br4}
.numbered
1. Чете
@@ -32,17 +35,19 @@
## Подобряване на четене
-[$br4]
+{br4}
.unordered
- Лично вярвам, че четимост е по-важна от конвенции
- Човек вижда най-лесно "контрастни" шаблони
```
+'emplace
. . 0.00.0 010010 815213
000000 000000 738438
. . .0000. 100001 122481
.... 0....0 011110 511119
+'endemplace
Както виждате, в примера има усмихнато личице, "закодирано" по различни начини.
@@ -54,7 +59,7 @@
:middle_slide
-Труден за четене код [*(забелязвате ли грешките?)*]:
+Труден за четене код {i (забелязвате ли грешките?)}:
.font22
```
@@ -84,7 +89,7 @@ if (board[a][b][i] == ' ') {
:middle_slide
-По-лесен за четене код [*(а сега виждат ли се по-лесно?)*]:
+По-лесен за четене код {i (а сега виждат ли се по-лесно?)}:
:font18
:code
@@ -120,7 +125,7 @@ for (int i = 0; i < layers; i++)
-Би трябвало да е малко по-лесно, в последния [`if`] имаме "e[=n=]ptyRow", което е печатната грешка, [`!=`] което трябва да бъде [`==`] и липсва въвеждането на [`b`] след първия [`if`].
+Би трябвало да е малко по-лесно, в последния {` if} имаме "e{b n}ptyRow", което е печатната грешка, {` !=} което трябва да бъде {` ==} и липсва въвеждането на {` b} след първия {` if}.
Примерът не е перфектен, но илюстрира какво се опитвам да кажа: формата на код е от огромно значение, обръщайте ѝ внимание.
@@ -130,20 +135,20 @@ for (int i = 0; i < layers; i++)
## Абстракцията - улеснява изучаване И употреба/модификация
-[$br1]
+{br1}
.bulleted
- Разделяме обработване на стойностите от директната имплементацията
- Създаваме нови "машинни инструкции"
-[$br1]
+{br1}
.bulleted
-- [`doX()`] е по-лошо от [`do(X)`]
+- {` doX()} е по-лошо от {` do(X)}
.unordered
- - можем да преизползваме [`do()`] за неща, различни от [`X`]
- - един път разбрано, всяка употреба на [`do()`] също е разбрана; този стил кара [`do()`] да бъде по-обща функция, което я прави по-лесна за разбиране
- - модификация на [`do(X)`] се свежда до заменяне на [`do()`] с [`doOther()`] или до заменяне на [`X`] с [`Y`]; променяме "инструкцията" или променяме данната
+ - можем да преизползваме {` do()} за неща, различни от {` X}
+ - един път разбрано, всяка употреба на {` do()} също е разбрана; този стил кара {` do()} да бъде по-обща функция, което я прави по-лесна за разбиране
+ - модификация на {` do(X)} се свежда до заменяне на {` do()} с {` doOther()} или до заменяне на {` X} с {` Y}; променяме "инструкцията" или променяме данната
Нека сега разгледаме няколко примера, първият е много груб и елементарен, но служи за добро начало:
@@ -168,14 +173,14 @@ int fib5() │ int fib(int n)
Би трябвало да е супер очевидно, никой няма да пише отделна функция на Фибоначи за всяко число.
-Нека сега да разгледаме няколко "реални" примера, свързани с домашното (за припомняне, условието се намира [url https://learn.fmi.uni-sofia.bg/mod/assign/view.php?id=296069 тук]).
+Нека сега да разгледаме няколко "реални" примера, свързани с домашното (за припомняне, условието се намира {url тук;https://learn.fmi.uni-sofia.bg/mod/assign/view.php?id=296069}).
Самите решения няма винаги да са добре форматирани, това е направено с цел да се поберат добре в слайда.
Първия е върху функция, която приема координатите на плочка, премахва я от дъската (ако съществува) и я слага в края на празния ред.
:slide
-Лошо - [`doX()`] в тялото на функцията
+Лошо - {` doX()} в тялото на функцията
```cpp
void tryTakeTile(char** board, int rows, int cols,
@@ -201,16 +206,16 @@ void tryTakeTile(char** board, int rows, int cols,
Повечето предадени работи са имплементирали функционалността по точно този начин.
Замислете се обаче, какво става ако сменим типа данна, тоест ако дъската е триизмерна?
-Тогава трябва да добавим още една [`int`] променлива, още едно условие в [`if`], трябва да я добавим при трите индексирания на [`board`].
+Тогава трябва да добавим още една {` int} променлива, още едно условие в {` if}, трябва да я добавим при трите индексирания на {` board}.
-Какво става ако променим самата структура от данни за [`emptyRow`] (за сега сте учили само масиви, но скоро ще видите, че има и други начини да съхраняваш редица информация), тогава ще трябва да пренапишем целия цикъл.
+Какво става ако променим самата структура от данни за {` emptyRow} (за сега сте учили само масиви, но скоро ще видите, че има и други начини да съхраняваш редица информация), тогава ще трябва да пренапишем целия цикъл.
Тоест, ако променим нещо, трябва да пренапишем значителни части от самия код, и като разширим това върху 10-20 функции, изведнъж малка промяна става голяма.
Нека сега да пренапишем функцията, използвайки колкото се може повече абстракция.
:middle_slide
-Добро - [`do(X)`]
+Добро - {` do(X)}
:code_cpp
bool tryReadCoordinates(int& x, int& y) {
@@ -233,9 +238,9 @@ void tryTakeTile(char** board, int rows, int cols,
-Искаме трето измерение на [`board`]?
-Няма проблем, написали сме нова [`tryReadCoordinates`], която приема три променливи, и в [`tryTakeTile`] добавяме една декларация и обновяваме двете индексирания на [`board`].
-Ако [`emptyRow`] стане друг тип данна, просто променяме функцията да бъде [`appendToOtherDataType`] и сме готови.
+Искаме трето измерение на {` board}?
+Няма проблем, написали сме нова {` tryReadCoordinates}, която приема три променливи, и в {` tryTakeTile} добавяме една декларация и обновяваме двете индексирания на {` board}.
+Ако {` emptyRow} стане друг тип данна, просто променяме функцията да бъде {` appendToOtherDataType} и сме готови.
И ако тази промяна трябва да се направи в много функции, даже бихме могли да употребяваме функционалност на самия текстов редактор да търси и заменя срещания на един низ с друг.
@@ -244,7 +249,7 @@ void tryTakeTile(char** board, int rows, int cols,
:slide
-Лошо - всички цикли са [`doX()`]
+Лошо - всички цикли са {` doX()}
```cpp
void generateLayer(char** layer, int rows, int cols,
@@ -272,15 +277,15 @@ void generateLayer(char** layer, int rows, int cols,
Този сегмент е по-интересен за променяне от преди, понеже за да го направим хубаво трябва да променим самата ни логика.
Запълването със шпации е ясно, обаче случайното поставяне на плочки не е.
-Ако имаме функция [`placeRandomЕлемент`] която само поставя една плочка в слоя, пак ще имаме вложени цикли, трябва да има начин да останем с един цикъл.
-Ако направим [`placeRandomElementNTimes`], тогава пък абстрахираната функция става твърде специфична и вече имаме [`doX()`] при самата нея.
+Ако имаме функция {` placeRandomЕлемент} която само поставя една плочка в слоя, пак ще имаме вложени цикли, трябва да има начин да останем с един цикъл.
+Ако направим {` placeRandomElementNTimes}, тогава пък абстрахираната функция става твърде специфична и вече имаме {` doX()} при самата нея.
Чрез функционално програмиране този проблем може да се разреши лесно, обаче вие ще го учите следващия семестър.
С достатъчно размишления, може да стигнем до следния вариант: вместо всяка плочка да я поставяме на случайна позиция, защо не поставим всички плочки една след друга и не разбъркаме слоя?
:middle_slide
-Добро - [`do(X)`]
+Добро - {` do(X)}
```cpp
void generateLayer(char** layer, int rows, int cols,
@@ -296,7 +301,7 @@ void generateLayer(char** layer, int rows, int cols,
shuffleMatrix(layer, rows, cols);
}
-[=Бонус:=] работи по-коректно от преди
+{b Бонус:} работи по-коректно от преди
В предходния вариант, ако примерно цялата е пълна освен една клетка, и трябва да поставим една финална плочка, тогава трябва да чакаме докато случайните стойности се напаснат точно с координатите на тази една клетка.
@@ -304,16 +309,17 @@ void generateLayer(char** layer, int rows, int cols,
Даже, този проблем става все по-тегав с времето: с всяка запълнена клетка, шанса случайните стойности да ударят на заети координати се увеличава.
Докато тук, нямаме този проблем, отнема някакво консистентно предопределено време да разбъркаме матрицата.
-Как имплементираме [`shuffleMatrix`] си има и своите тънкости, но най-елементарния начин е просто да направим сортираш алгоритъм, при който вместо да сравним две стойности, използваме случайна стойност, която определя дали ще разменим плочките.
+Как имплементираме {` shuffleMatrix} си има и своите тънкости, но най-елементарния начин е просто да направим сортираш алгоритъм, при който вместо да сравним две стойности, използваме случайна стойност, която определя дали ще разменим плочките.
Друго хубаво нещо на решения с абстракция, е един лек лавинен ефект, където веднъж като почнем да мислим за абстракции, намираме къде да ги ползваме навсякъде.
Да разгледаме същата функция, обаче при D подточка.
:middle_slide
-Решения със слоеве правят същото. Лошо - [`doX()`] при циклите:
+Решения със слоеве правят същото. Лошо - {` doX()} при циклите:
```cpp
+'emplace
void generate(char*** board, int rows, int cols, int layers,
char* tiles, int* tileCounts, int tilesSize) {
...
@@ -323,15 +329,16 @@ void generate(char*** board, int rows, int cols, int layers,
} while(layer[x][y][layer] != ' ');
...
}
+'endemplace
-Без абстракция отново ще пренапишем голяма част от [`generate`] функцията, за да се побере на слайда съм оставил само "най-сложната" промяна - случайните стойности.
-Пак, имаше решения на подточката, без преизползване на [`generate`] за един слой.
-Айде да разгледаме решението, заедно с абстрахираната [`generate`].
+Без абстракция отново ще пренапишем голяма част от {` generate} функцията, за да се побере на слайда съм оставил само "най-сложната" промяна - случайните стойности.
+Пак, имаше решения на подточката, без преизползване на {` generate} за един слой.
+Айде да разгледаме решението, заедно с абстрахираната {` generate}.
:slide
-Добро - [`do(X)`]
+Добро - {` do(X)}
```cpp
void generateLayer(char** layer, int rows, int cols,
@@ -357,14 +364,14 @@ void generate(char*** board, int rows, int cols, int layers,
Супер елементарно, има-няма 5-6 реда код промяна, при генериране за всеки слой, просто извикваме функцията за генериране върху един слой, за всеки слой.
А в самата функция само премахваме броя вмъкнати плочки от сумата на даден тип.
-Наблюдателните са забелязали, че в "ръчното" решение слоевете са третия индекс, тоест имаме [`board[x][y][layer]`], докато в това решение е първия, тоест [`board[layer][x][y]`].
+Наблюдателните са забелязали, че в "ръчното" решение слоевете са третия индекс, тоест имаме {` board[x][y][layer]}, докато в това решение е първия, тоест {` board[layer][x][y]}.
Разликата е значителна, но от гледна точка на код, особено когато използваме абстракция, промяната е лесна.
Иначе, в момента се намираме в много добра позиция, без абстракция как правим рестартирането на играта?
По условие броя и типовете плочки трябва да се запазят, но позиции не.
Истината е, че става малко тромаво: цикълът за намираме на позиции се преизползва, и броя плочки трябва да се запази.
-Обаче, сега това става с едно [`shuffleMatrix`], не е нужно нищо специално да правим!
+Обаче, сега това става с едно {` shuffleMatrix}, не е нужно нищо специално да правим!
:middle_slide35
@@ -372,7 +379,7 @@ void generate(char*** board, int rows, int cols, int layers,
.unordered
- Целта на коментарите е да направи разбиране и модификация на код по-лесни.
-- В повечето случаи, коментарът трябва да ни дава [*нова*] информация или да [*свърже*] парчета информация
+- В повечето случаи, коментарът трябва да ни дава {i нова} информация или да {i свърже} парчета информация
Да разгледаме следния пример.
@@ -401,7 +408,7 @@ for (int i = 0; i < rows; i++) {
}
-При добрия вариант, получаваме нова информация, че това запълване се случва понеже ще подаваме към някаква си [`functionX`], и че евентуално може да има други функции, при които празни клетки може да не се обозначават с [`'\0'`].
+При добрия вариант, получаваме нова информация, че това запълване се случва понеже ще подаваме към някаква си {` functionX}, и че евентуално може да има други функции, при които празни клетки може да не се обозначават с {` '\0'}.
В лошия можем да стигнем до същото заключение като погледнем самия код.
:comment
@@ -412,9 +419,9 @@ for (int i = 0; i < rows; i++) {
.quote 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!
-&mdash; Edsger W. Dijkstra, [url https://www.cs.utexas.edu/users/EWD/ewd02xx/EWD249.PDF Notes on Structured Programming, On our inability to do much]
+&mdash; Edsger W. Dijkstra, {url Notes on Structured Programming, On our inability to do much;https://www.cs.utexas.edu/users/EWD/ewd02xx/EWD249.PDF}
-[$br1]
+{br1}
Решение на цялото домашно, с описаните методи TODO
@@ -424,13 +431,13 @@ for (int i = 0; i < rows; i++) {
-Умението да разрешиш един проблем [*не те*] прави добър програмист, да го разрешиш по четим, разширяем, лесен, ефикасен, ... начин [*те*] прави добър програмист.
+Умението да разрешиш един проблем {i не те} прави добър програмист, да го разрешиш по четим, разширяем, лесен, ефикасен, ... начин {i те} прави добър програмист.
:slide35
## Изводи
-[$br4]
+{br4}
.unordered
- Форматирайте/подравнявайте си кода, искате лесно четене
diff --git a/src/teaching/oop-2023/week1/index.du b/src/teaching/oop-2023/week1/index.du
index f229343..5dd5787 100644
--- a/src/teaching/oop-2023/week1/index.du
+++ b/src/teaching/oop-2023/week1/index.du
@@ -1,17 +1,20 @@
-# Задачи - ООП, Седмица 1, 22.02.2024
+'def title Задачи - ООП, Седмица 1, 22.02.2024
+'def desc Условия на задачите за упражнение
+
+# {title}
\n
-GitHub classroom: [url https://classroom.github.com/a/UPJOzHty classroom.github.com/a/UPJOzHty]
+GitHub classroom: {url classroom.github.com/a/UPJOzHty;https://classroom.github.com/a/UPJOzHty}
## Задача 1
-.solution-link [url https://github.com/Syndamia/oop-2023-solutions/blob/main/week01/Exercise1.cpp Решение]
+.solution-link {url Решение;https://github.com/Syndamia/oop-2023-solutions/blob/main/week01/Exercise1.cpp}
Имплементирайте низ чрез структура.
В структурата трябва да запазвате указател към низа и неговата дължина.
-Имплементирайте функция [`concatString`], която приема две структури от този тип и връща низ, пак в същата структура, който е конкатенация (слепване) на първите два низа.
+Имплементирайте функция {` concatString}, която приема две структури от този тип и връща низ, пак в същата структура, който е конкатенация (слепване) на първите два низа.
.question Има ли значение дали типовете на аргументите, или на върнатата стойност, са референции или указатели (или нито едното)?
@@ -19,35 +22,36 @@ GitHub classroom: [url https://classroom.github.com/a/UPJOzHty classroom.github.
## Задача 2
-.solution-link [url https://github.com/Syndamia/oop-2023-solutions/blob/main/week01/Exercise2.cpp Решение]
+.solution-link {url Решение;https://github.com/Syndamia/oop-2023-solutions/blob/main/week01/Exercise2.cpp}
Имплементирайте структура за динамично-заделен масив от целочислени числа.
Тя трябва да запазва указател към масива, размера на масива и бройката на елементи в масива.
Заделянето на динамична памет е бавна операция, затова винаги ще заделяме повече клетки, отколкото са ни нужни.
-Имплементирайте функция [`resize`], която удвоява размера на масива (нека първоначалния размер на масива е 2), на подадена стойност от тип вашата структура.
+Имплементирайте функция {` resize}, която удвоява размера на масива (нека първоначалния размер на масива е 2), на подадена стойност от тип вашата структура.
-Имплементирайте функция [`addToEnd`], която приема (инстанция на) структурата ви и вмъква елемент в първата незаета позиция.
+Имплементирайте функция {` addToEnd}, която приема (инстанция на) структурата ви и вмъква елемент в първата незаета позиция.
В самия код тествайте функциите (не е нужен потребителски вход).
## Задача 3
-.solution-link [url https://github.com/Syndamia/oop-2023-solutions/blob/main/week01/Exercise3.cpp Решение]
+.solution-link {url Решение;https://github.com/Syndamia/oop-2023-solutions/blob/main/week01/Exercise3.cpp}
Разглеждате "пакети" (логове) информация от редица датчици.
Един пакет запазва времето, когато информацията е била отчетена от датчиците, и стойностите на всички датчици: температура, атмосферно налягане, влажност и надморска височина.
Всички типове данни са целочислени.
От входа получавате N, броя пакети, които трябва да запазите, и след това 5N на брой целочислени стойности.
-Накрая получавате буква: [`t`], [`p`], [`h`], [`e`], всяка съответства на някоя отделна стойност от датчиците.
+Накрая получавате буква: {` t}, {` p}, {` h}, {` e}, всяка съответства на някоя отделна стойност от датчиците.
Трябва да изкарате на екрана всичките стойности от пакетите, подредени в нарастващ ред на времето, като всички след първата са разликите им спрямо първата.
-[=Пример:=]
+{b Пример:}
-:table_2
+:table
+:2
|= Вход
|= Изход
@@ -65,29 +69,31 @@ p
|: -15 87 109 79 3 75
+
## Задача 4
-.solution-link [url https://github.com/Syndamia/oop-2023-solutions/blob/main/week01/Exercise4.cpp Решение]
+.solution-link {url Решение;https://github.com/Syndamia/oop-2023-solutions/blob/main/week01/Exercise4.cpp}
-'footnote sabre Защото една от първите индустрии, които са се нуждаели от компютърни системи, била [url https://en.wikipedia.org/wiki/Sabre_%28travel_reservation_system%29#History авиационната индустрия].
+'footnote sabre Защото една от първите индустрии, които са се нуждаели от компютърни системи, била {url авиационната индустрия;https://en.wikipedia.org/wiki/Sabre_%28travel_reservation_system%29#History}.
-Направете структура за съхранение на полети[$sabre].
+Направете структура за съхранение на полети{sabre}.
Трябва да запазите имената на началния и крайния град като низове (допускаме, че няма шпации в имената на градовете), часът на излитане и на кацане в целочислен формат (като на циферблат на дигитален часовник, без разделителното двоеточие) и цената на полета в тип с плаваща запетая (в долари).
### а) въвеждане
-.solution-link [url https://github.com/Syndamia/oop-2023-solutions/blob/main/week01/Exercise4.cpp#L15-L36 Решение]
+.solution-link {url Решение;https://github.com/Syndamia/oop-2023-solutions/blob/main/week01/Exercise4.cpp#L15-L36}
От входа получавате N, това определя броя полети, които трябва да се добавят в системата.
Всеки полет е редица от 5 стойности, в реда в който са дефинирани.
-[*Напомням, че това е нагласено да ползвате [`std::cin`] вместо ръчно да обработвате целия ред.*]
+{i Напомням, че това е нагласено да ползвате {` std::cin} вместо ръчно да обработвате целия ред.}
Изкарайте началните и крайните градове, както и цената на полетите, подредени в нарастващ ред на час на излитане.
-[=Пример:=]
+{b Пример:}
-:table_2
+:table
+:2
|= Вход
|= Изход
@@ -109,9 +115,10 @@ Berlin Paris 140
Paris NewYork 500
+
### б) търсене
-.solution-link [url https://github.com/Syndamia/oop-2023-solutions/blob/main/week01/Exercise4.cpp#L38-L247 Решение]
+.solution-link {url Решение;https://github.com/Syndamia/oop-2023-solutions/blob/main/week01/Exercise4.cpp#L38-L247}
След като се въведат всички полети, получавате от входа два низа - имена на градове.
Трябва да изкарате най-евтиния, и след него най-бързия, вариант за пътуване от първия град към втория.
@@ -119,9 +126,10 @@ Paris NewYork 500
Прикачване между полети е позволено, така че под "вариант" трябва да изкарате всичките полети, които са решение.
За един полет е нужно да изкарате само началния град, крайния град, час на излитане и цена, като градовете трябва да са подредени в нарастващ ред на часа на излитане.
-[=Пример:=]
+{b Пример:}
-:table_2
+:table
+:2
|= Вход
|= Изход
@@ -144,11 +152,12 @@ Quickest:
Sofia NewYork 0610 800
+
## Задача 5
-.solution-link [url https://github.com/Syndamia/oop-2023-solutions/blob/main/week01/Exercise5.cpp Решение]
+.solution-link {url Решение;https://github.com/Syndamia/oop-2023-solutions/blob/main/week01/Exercise5.cpp}
-Имате система за потребители, всеки потребител си има име и приятели (един приятел е [=указател към потребител=]).
+Имате система за потребители, всеки потребител си има име и приятели (един приятел е {b указател към потребител}).
В началото се въвежда N, това е броят потребители в системата.
За един потребител, първо се въвежда на нов ред името му, след това броя на неговите приятели и накрая, на отделни редове, имената на всички тези приятели.
@@ -156,9 +165,10 @@ Sofia NewYork 0610 800
Накрая получавате едно име, това е началния потребител.
Трябва да намерите, започвайки от него, с колко други потребителя има някаква приятелска връзка (директна, приятел на приятел, приятел на приятел на приятел, ...).
-[=Пример:=]
+{b Пример:}
-:table_2
+:table
+:2
|= Вход
|= Изход
diff --git a/src/teaching/oop-2023/week1/organization.du b/src/teaching/oop-2023/week1/organization.du
index 3732566..b16b1f3 100644
--- a/src/teaching/oop-2023/week1/organization.du
+++ b/src/teaching/oop-2023/week1/organization.du
@@ -1,8 +1,11 @@
-# Организация - ООП, Седмица 1, 22.02.2024
+'def title Организация - ООП, Седмица 1, 22.02.2024
+'def desc Организационни бележки и новини
+
+# {title}
\n
-[$presentation-controller]
+{presentation-controller}
:title_slide35
@@ -39,16 +42,16 @@
:middle_slide35
:unordered
-- Зачитат се [=единствено нещата, качени в GitHub classroom, качени в срок=]
+- Зачитат се {b единствено нещата, качени в GitHub classroom, качени в срок}
.unordered
- - До [=15=] минути след края на часа
+ - До {b 15} минути след края на часа
- Както преди, не е нужно да присъствате, за да качвате решения
- Ако случайно някой не знае как се ползва:
-.centered [url ../upp-2023/week1/setup.html?a syndamia.com/upp-2023/week1/setup.html?a]
+.centered {url syndamia.com/upp-2023/week1/setup.html?a;../upp-2023/week1/setup.html?a}
Който по време на УП е използвал GitHub classroom не би трябвало да прави нещо, продължавате си по старо му, със същите акаунти.
-Разбира се, за всякакви проблеми се [url ../upp-2023/week1/welcome.html?a#section-4 свържете с мен].
+Разбира се, за всякакви проблеми се {url свържете с мен;../upp-2023/week1/welcome.html?a#section-4}.