Съдържание на курса
Урок 01 — Първият ми екран работи
От Dorian Chávez · съосновател и Chief Executive Officer на Hábil ·
Преди да четете, седем думи. По един ред за всяка; останалите от поредицата идват в урока, в който се използват.
- Kotlin: езикът, на който пишете приложението. Файловете му завършват на
.kt. - Compose (Jetpack Compose): библиотеката на Android за изграждане на екрани чрез писане на функции на Kotlin.
- Composable функция: функция, маркирана с
@Composable, която описва част от екрана. - Скица: рисунката как трябва да изглежда екранът. С нея сравнявате.
- Модификатор: това, което казва на един елемент колко място заема и колко отстъп оставя.
- Състояние: данна, която екранът помни и която може да се променя, например „бутонът вече е натиснат“.
- Симулиран тест: тест, който изчертава вашия екран в паметта на компютъра ви, без емулатор, и търси в него онова, което трябва да е там.
Какво отнасяте: приветствения екран на магазина —име, мото и бутон— написан от вас, и умението да четете екран на Compose ред по ред и да казвате какво променя всеки ред на екрана.
Новата идея на този урок (единствената, която се оценява): в Compose екранът е функция, която описва онова, което се вижда. Няма отделен файл с оформление: четете функцията и знаете какво ще се появи.
Бележка за текстовете на приложението. Проектът на курса носи екранните си текстове на испански, а файловете в
lecciones/ не са преведени: автоматичните проверки на курса (verifica) търсят тъкмо тези текстове. Затова в
блоковете с код, в изходите на терминала и в скиците на екрана текстовете остават така, както са в проекта, а в
прозата урокът ги цитира на български и първия път дава оригинала в скоби: името „Магазинът“ (в проекта: „La
tienda“), мотото „Вашите поръчки, в джоба ви“ („Tus órdenes, en tu bolsillo“), бутонът „Вход“ („Entrar“) и
поздравът „Здравейте!“ („¡Hola!“).
Сцената
Искате от Claude Code приветствения екран. След малко имате кратък файл на Kotlin. Компилира се. Тестовете минават в зелено. Инсталирате го, натискате „Вход“ и се появява поздравът. Затваряте компютъра.
На следващия ден някой отваря приложението до скицата и ви пита: „защо поздравът излиза над бутона, когато тук
е под него?“. Отваряте файла. Виждате remember, mutableStateOf, Modifier, един if по средата на екрана.
Не знаете кой от тези редове мести поздрава.
Този код съществува: това е листингът от упражнение 1.3, а неговите тестове излизат 4 от 4 в зелено, макар поздравът да е на грешното място (измерено на 18 ноември 2026 г.). Зеленото казва, че поздравът се появява. Не казва къде.
Затова уроците вървят в този ред: четете един екран, пишете един на ръка, искате промяна от Claude Code и накрая обяснявате —без помощ— какво прави всеки блок от онова, което е генерирал.
Преди да започнете
Какво ви трябва:
| Върши работа | Не върши работа | |
|---|---|---|
| Предишен урок | 00 завършен: зададен ANDROID_HOME и емулатор или вашият телефон |
Да го прескочите: без SDK проектът не се компилира |
| Знания | Да програмирате на някакъв език и да сте правили интерфейс | Не се предполагат Kotlin и Compose |
Началният проект. От корена на хранилището на поредицата:
git pull
cd lecciones/01-mi-primera-pantalla/inicio
Там работите. До него е solucion/, с решения екран: той е за сравнение накрая, не за преписване.
Какво вече носи проектът (скелето). Не го пишете вие и тук не се оценява, но си струва да знаете защо е там:
| Какво носи | Къде | Защо |
|---|---|---|
org.gradle.jvmargs=-Xmx4g |
gradle.properties |
Дава 4 GB памет на Gradle, инструмента, който компилира. Без нея компилирането с Firebase (урок 03) се провали с „Java heap space“ (измерено на 13 ноември 2026 г.) |
gradlew вече генериран |
коренът на проекта | Скриптът, който сваля и пуска точната версия на Gradle. Генерирането му с gradle wrapper вътре в проект с AGP 9.4 се провали (измерено на 13 ноември). Не го генерирайте наново |
sdk=36 |
app/src/test/resources/robolectric.properties |
Симулираните тестове използват копие на Android 36. Без да е зададено, взимаха Android 37 и нито един не се изпълни (измерено на 13 ноември) |
jvmToolchain(25) |
app/build.gradle.kts |
При опита от 13 ноември Robolectric, докато зареждаше своя Android 36, не стартира с Java 17 и поиска Java 21 или по-нова. Затова проектът фиксира 25 |
Скицата. Ето какво трябва да се вижда накрая:
┌────────────────────────────────┐
│ │
│ La tienda │ ← име, с едър шрифт
│ Tus órdenes, en tu bolsillo │ ← мото
│ [ Entrar ] │ ← бутон
│ ¡Hola! │ ← появява се само след като натиснете «Entrar»
│ │
└────────────────────────────────┘
Всичко центрирано, по средата на екрана, с 24 dp отстъп.
dp е единицата на Android за размери: приблизително един пиксел на екран със средна плътност, нагласена така, че да изглежда със същия размер и на по-плътни екрани.
Стъпка 1 · Прочетете един екран, преди да го пуснете
Отворете app/src/main/java/mx/habil/ejemplo/tienda/Bienvenida.kt. Ето как идва:
@Composable
fun Bienvenida() {
Column(
modifier = Modifier.fillMaxSize().padding(24.dp),
verticalArrangement = Arrangement.Center
) {
Text("Aquí va tu pantalla")
Text("Lección 01")
}
}
Първо предвидете. В корена на хранилището създайте папката за отговори, ако още я няма (mkdir -p respuestas),
и в нея файла respuestas/01.md. Там отиват вашите предвиждания и обяснения. Преди да пуснете каквото и да е,
напишете три реда: колко текста ще се виждат?, един до друг или един под друг?, залепени вляво или центрирани?
За да предвидите, четете функцията отвън навътре:
@Composableмаркира функцията като такава, която описва екран.fun Bienvenida()е функция на Kotlin. Не връща нищо: описва онова, което трябва да се вижда.Column( … ) { … }подрежда онова, което носи вътре, във вертикална последователност: един под друг.Text("…")показва текст. Всяко извикване е един елемент.Modifier.fillMaxSize().padding(24.dp)казва, че колоната заема цялото пространство, което ѝ е дадено, и оставя 24 dp отстъп.verticalArrangement = Arrangement.Centerпоставя съдържанието по средата на височината. За хоризонталното никой не е казал нищо, а вColumnто започва по подразбиране отAlignment.Start: страната, откъдето започва текстът.
Сега го пуснете. С отворен емулатор или с включен телефон:
./gradlew installDebug # компилира и инсталира; не отваря приложението
Отворете го от списъка с приложения и сравнете с вашите три реда. Ако някое предвиждане е излязло грешно, не го изтривайте: напишете отдолу кой ред от кода би ви дал отговора. В емулатора от опита (Pixel 9, Android 37, 18 ноември 2026 г.) се видяха два текста, „Тук е вашият екран“ („Aquí va tu pantalla“) и под него „Урок 01“ („Lección 01“), по средата на височината и залепени вляво.
Второ предвиждане. Ами ако махнете Column и оставите двата Text сами? Според документацията на Android
Compose ги слага един върху друг. Опитайте, запишете какво виждате и върнете Column.
Кой извиква Bienvenida()? MainActivity.kt, в същата папка: редът ѝ setContent { Bienvenida() } казва коя
функция чертае екрана. Него не го променяте.
Доказва се с: вашето написано предвиждане, сравнено с изпълнението (цел 1.1).
Стъпка 2 · Kotlin: онова, което вече познавате, с друго име
Достатъчно е да разпознаете три неща, които вече ползвате на друг език.
| В Kotlin | Какво е | Къде го виждате |
|---|---|---|
val nombre = "La tienda" |
Променлива, на която се присвоява стойност веднъж и вече не се променя | val pantalla = … в BienvenidaTest.kt |
var saludando = false |
Променлива, която може да се променя | Пишете я в стъпка 4 |
fun doble(n: Int): Int { return n * 2 } |
Функция: име, параметри с техния тип и тип на върнатата стойност | fun Bienvenida() |
fun doble(n: Int) = n * 2 |
Същата, в кратък вид: тялото е израз, а типът на върнатата стойност се извежда | |
Bundle? |
Тип, който може да е null. Без ? не може |
savedInstanceState: Bundle? в MainActivity.kt |
Три подробности, които наистина се различават от други езици:
- Типът стои след името:
n: Int. При променлива почти никога не го пишете: вval x = 5Kotlin заключава, че еInt. - Null стойностите се декларират. Променлива
Stringне може да съхраняваnull. Ако може да липсва, типът еString?, и тогаваlema.lengthе грешка при компилиране;lema?.lengthвръщаnull, акоlemaе null; аlema?.length ?: 0връща0в този случай. - Скобите накрая са функция, която подавате на друга. В
Column( … ) { … }онова, което е между къдравите скоби, е функция без име (ламбда). Ако последният параметър на една функция е друга функция, Kotlin позволява да я напишете извън кръглите скоби. Затова Compose изглежда като вложени блокове.
Доказва се с: преговора 1.4, в „Вашите упражнения“.
Стъпка 3 · Напишете приветствието, на ръка
Тази стъпка е ваша, без Claude Code: това са около десет реда.
Първо предвидете. Колко извиквания на composable функции ще са ви нужни вътре в Column и коя от тях ще носи
друга вътре в себе си?
В Bienvenida.kt:
- Добавете три реда към блока с
import. Единimportказва на Kotlin от коя библиотека идва всяко име:
import androidx.compose.material3.Button
import androidx.compose.material3.MaterialTheme
import androidx.compose.ui.Alignment
- Центрирайте хоризонталното. Сложете запетая след
Arrangement.Centerи отдолу параметъра, който липсваше:
verticalArrangement = Arrangement.Center,
horizontalAlignment = Alignment.CenterHorizontally
- Сменете двата текста с трите елемента от скицата:
Text("La tienda", style = MaterialTheme.typography.headlineLarge)
Text("Tus órdenes, en tu bolsillo")
Button(onClick = { }) {
Text("Entrar")
}
style = MaterialTheme.typography.headlineLarge дава на името един от размерите на шрифта на Material, набора от
визуални компоненти на Android. Button носи две неща: onClick, функцията, която се извиква, когато някой го
натисне —засега празна—, и между къдравите скоби онова, което се вижда вътре в бутона, а то е още един Text.
Пуснете verifica. От корена на хранилището:
./lecciones/01-mi-primera-pantalla/verifica
Не променя вашия код: пуска симулираните тестове (./gradlew testDebugUnitTest) и ви превежда резултата.
Първия път има нужда от мрежа и отнема време, защото сваля библиотеката за тестове (Robolectric) и копие на
Android: при опита от 13 ноември беше 1 минута и 21 секунди на Mac; следващите, секунди.
Вървите добре, ако виждате три зелени отметки и една червена:
✅ Simulado: la pantalla muestra el nombre «La tienda»
✅ Simulado: la pantalla muestra el lema «Tus órdenes, en tu bolsillo»
✅ Simulado: hay un elemento «Entrar» con acción de toque y rol de botón
❌ Al tocar el botón «Entrar» no aparece «¡Hola!» (o ya estaba desde antes): ese cambio lo pides en el paso 4
Resultado: 3 de 4 pruebas en verde (1 en rojo, 0 con error, 0 saltadas), leído de …
(Това е изходът на verifica, точно както го отпечатва скриптът, на испански. На български казва: екранът показва
името; екранът показва мотото; има елемент „Вход“ с действие при докосване и роля на бутон; и, в червено,
„при натискане на бутона „Вход“ не се появява „Здравейте!“ (или вече е било там): тази промяна я искате в стъпка
4“; и резултатът, 3 от 4 теста в зелено.)
Това червено е очакваното: бутонът още не прави нищо. В червено излиза и отметката за respuestas/01.md, която
още не сте попълнили.
Какво доказва всяка отметка и какво не. „Simulado“ (симулиран) значи, че тестът е изчертал вашата функция в
паметта и е намерил този текст, и че „Вход“ може да се докосне и е обявен за бутон (Text, на който добавяте само
докосване, не минава). Не доказва размера на шрифта, отстъпа, центрирането нито реда: това го виждате вие, с
./gradlew installDebug и скицата до себе си.
Доказва се с: симулираният verifica намира трите елемента и вие сте сравнили инсталираното приложение със
скицата (цел 1.2).
Стъпка 4 · С Claude Code: нека бутонът поздравява
Тук влиза инструментът и влиза винаги по един и същ начин: предвиждате → искате от него → четете какво е генерирал →
пускате verifica → обяснявате със свои думи.
- Предвидете. Напишете в
respuestas/01.md: за да се появи „Здравейте!“ само след натискане на бутона, какво трябва да помни екранът? Кой от редовете, които вече сте написали, ще се промени? - Поискайте от Claude Code, застанали в
inicio/: „ВBienvenida.ktнаправи така, че при натискане на "Entrar" да се появява текстът "¡Hola!" под бутона. Преди натискането не трябва да се вижда. Не променяй нищо друго и не пипай тестовете.“ - Прочетете цялата промяна, преди да я приемете. Не е нужно да е идентична с тази, но трябва да носи тези три части:
var saludando by remember { mutableStateOf(false) } // 1. състоянието
…
Button(onClick = { saludando = true }) { // 2. събитието
Text("Entrar")
}
if (saludando) { // 3. екранът чете състоянието
Text("¡Hola!")
}
- Пуснете
verifica. Сега четирите теста трябва да излязат в зелено. - Обяснете, в два реда от
respuestas/01.md, какво става между натискането на бутона и появата на поздрава.
Днес не проектирате състояние от нулата: само проследявате промяната, която предлага Claude Code. Кое състояние си струва да се пази и как да се съхрани е централната идея на урок 02. За да го проследите, трябва да знаете какво прави всяка част:
mutableStateOf(false)създава стойност, която Compose наблюдава. Когато се промени, Compose насрочва обновяването на частта от екрана, която я е прочела. Това се нарича прекомпозиция.remember { … }пази тази стойност, докато този екран е жив. Това не е запис на диска: ако Android създаде екрана наново, тя се връща наfalse.byпозволява да използватеsaludandoкато обикновена променлива. Иска дваimport:androidx.compose.runtime.getValueиandroidx.compose.runtime.setValue.onClick = { saludando = true }е събитието: променя само състоянието. Не чертае нищо.if (saludando) { Text("¡Hola!") }е обикновен Kotlin вътре в екрана: ако състоянието еtrue, този текст съществува; ако не, не съществува.
Идеята на урока, цялата: натискате → състоянието се променя → Compose обновява онова, което е прочело това
състояние, а тук това е if → описанието на екрана вече включва поздрава. Никой не „добавя“ текста. И Compose
може да изпълни наново само необходимото: не пишете код, предполагайки, че цялата функция ще се изпълни.
Ако някой ред още не ви е ясен, спрете тук: поискайте от Claude Code да го обясни, проверете го с малка промяна и
с verifica, и продължете, когато можете да го кажете със свои думи.
Стъпка 5 · Без ИИ: обяснете пет блока и поправете един
Това е упражнение 1.3 и се прави без Claude Code, върху вашия собствен Bienvenida.kt. Ако вашият вече
отговаря на скицата, за поправката използвайте този листинг, който е един възможен отговор на същата заявка:
19 @Composable
20 fun Bienvenida() {
21 var saludando by remember { mutableStateOf(false) }
22
23 Column(
24 modifier = Modifier.fillMaxSize().padding(24.dp),
25 verticalArrangement = Arrangement.Center,
26 horizontalAlignment = Alignment.CenterHorizontally
27 ) {
28 Text("La tienda", style = MaterialTheme.typography.headlineLarge)
29 Text("Tus órdenes, en tu bolsillo")
30 if (saludando) {
31 Text("¡Hola!")
32 }
33 Button(onClick = { saludando = true }) {
34 Text("Entrar")
35 }
36 }
37 }
С този листинг verifica дава 4 от 4 в зелено (измерено на 18 ноември 2026 г.). И въпреки това не отговаря на
скицата.
Правите две неща, писмено, в respuestas/01.md:
- Обяснете пет блока, по един от всеки вид: състояние, текст, модификатор, събитие и
функция. За всеки напишете реда му във формата
Bienvenida.kt:21и какво се променя на екрана, ако го махнете или го промените. „Пази булева стойност“ не е видим ефект; „без този ред поздравът никога не се появява“ е. - Поправете блока, който не отговаря на скицата. Кажете кой е и защо тестовете не го засичат, поправете го,
пуснете
verificaи инсталирайте приложението отново.
verifica само проверява, че сте записали поне пет препратки във формата Bienvenida.kt:N; не оценява вашите
обяснения нито поправката. А 4 от 4 потвърждава поведение, не как изглежда. Упражнение 1.3 е завършено, когато
можете да отметнете и четирите:
- Налице са петте вида: състояние, текст, модификатор, събитие и функция.
- Всеки казва ефект, който се вижда на екрана.
- Обяснихте защо поздравът излизаше отгоре и защо тестовете не го засякоха.
- След преместването 4 от 4 остава в зелено и в инсталираното приложение видяхте „¡Hola!“ под „Entrar“. Запишете това наблюдение до поправката.
Доказва се с: упражнение 1.3 (цел 1.3).
Вашите упражнения
1.2 и 1.3 се правят без ИИ.
| # | Правите | Готово е, когато |
|---|---|---|
| 1.1 | Предвиждате какво чертае функцията от стъпка 1 и я пускате | Имате вашите три реда и онова, което видяхте |
| 1.2 | Пишете име, мото и бутон по скицата | verifica отбелязва в зелено трите елемента и сте сравнили инсталираното приложение със скицата: групата центрирана и името с едър шрифт |
| 1.3 | Обяснявате пет блока и поправяте онзи, който не отговаря на скицата | Отметнахте четирите квадратчета от стъпка 5: 4 от 4 остава в зелено и видяхте поздрава под бутона в инсталираното приложение |
| 1.4 | Отговаряте на преговора по Kotlin | Четири от пет верни, всеки със своето защо |
Преговор 1.4. Отговорете, без да пускате кода. verifica не оценява вашите предвиждания нито този преговор:
сравнете ги сами със „Сравнете отговорите си“ и запазете онова, което сте написали.
val nombre = "La tienda"и на следващия редnombre = "Otra". Компилира ли се?var saludando = false. Никой не е написал типа. Кой е той и кой го е решил?fun doble(n: Int) = n * 2. Какво връщаdoble(4)и от какъв тип е?- В
MainActivity.ktпишеsavedInstanceState: Bundle?. Какво ви подсказва този?? val lema: String? = null. Какво става сlema.length, сlema?.lengthи сlema?.length ?: 0?
Време: отделете около два часа, с компилирането и вашите предвиждания. Това е оценка: ще я нагласим според времето, което отнеме на първата група.
Не ви ли тръгва?
Съобщенията на английски са тези, които компилаторът на поредицата (Kotlin 2.4.21) даде на 18 ноември 2026 г.
| Виждате | Вероятна причина | Какво правите |
|---|---|---|
Unresolved reference 'Button' |
Липсва import за това име или е написан грешно |
Добавете import от стъпка 3 и проверете главните букви |
'val' cannot be reassigned |
Декларирахте състоянието с val и после го променяте |
Трябва да е var saludando by remember { … } |
Property delegate must have a 'getValue(…)' method |
Използвахте by без двата му import |
Добавете getValue и setValue (стъпка 4) |
| „Las pruebas no llegaron a correr“ (тестовете не стигнаха до изпълнение) | Кодът не се компилира | Прочетете реда, който започва с e:: носи файл, ред и колона |
| ❌ при бутона, с видимо „Entrar“ | Това е Text, самостоятелен или с clickable: не е обявен за бутон |
Трябва да е Button с Text вътре |
| ❌ при поздрава, макар да се вижда „¡Hola!“ | Поздравът е винаги там, а не само след натискане | Отива вътре в if (saludando) |
BienvenidaTest.kt се е променил |
Някой (вие или Claude Code) е пипнал тестовете | Възстановете го с командата, която дава съобщението, и повторете заявката, като поискате да не ги пипа |
На Linux Mint 22.3 (x86_64) verifica на този урок излезе в зелено върху решението: 4 от 4, за 64 секунди,
включително първото компилиране (18 ноември 2026 г.). Ако вашият SDK не носи build-tools, Gradle ги сваля сам
първия път.
В заключение
Отговорете, без да четете отново:
- Какво е екранът в Compose, в едно изречение?
- Натискате „Entrar“ и се появява „¡Hola!“. Какво се случи по средата, по ред?
- Вашите четири симулирани теста са в зелено. Кажете едно нещо, което това доказва, и едно, което не доказва.
Какво следва: в урок 02 приложението има повече от един екран и преминава от единия към другия.
Сравнете отговорите си
Стъпка 1. Два текста, един под друг (Column), по средата на височината (Arrangement.Center) и от лявата
страна (никой не е посочил хоризонталното подравняване).
Стъпка 3. Четири извиквания: Text, Text, Button и, вътре в бутона, още един Text.
Упражнение 1.3, върху листинга от стъпка 5:
| Блок | Ред | Видим ефект |
|---|---|---|
| Състояние | Bienvenida.kt:21 |
Без него поздравът не може да се появи след докосването |
| Текст | Bienvenida.kt:28 |
Това е името; без style би се видяло със същия размер като мотото |
| Модификатор | Bienvenida.kt:24 |
Без fillMaxSize() колоната заема само онова, което мери съдържанието ѝ: няма вече място, в което да се центрира |
| Събитие | Bienvenida.kt:33 |
С onClick = { } бутонът може да се докосне, но нищо не се случва |
| Функция | Bienvenida.kt:20 |
Това е целият екран; MainActivity я извиква |
Блокът, който не отговаря на скицата, е този на редове 30 до 32: той е преди бутона, така че поздравът излиза над „Entrar“, а скицата го иска отдолу. Поправя се, като преместите тези три реда след ред 35. Тестовете не го засичат, защото проверяват текстът да съществува и да се вижда, не на коя позиция е.
Преговор 1.4:
- Не.
valне може да се присвоява повторно; компилаторът казва'val' cannot be reassigned. Boolean. Kotlin го е заключил от стойносттаfalse.- Връща
8, от типInt: тялото е израз, а типът на върнатата стойност се извежда. - Че този параметър може да пристигне като
null, а Kotlin не ви позволява да го ползвате, без да вземете предвид този случай. lema.lengthне се компилира;lema?.lengthдаваnull;lema?.length ?: 0дава0.
В заключение:
- Функция, маркирана с
@Composable, която описва онова, което се вижда. onClickпромени състоянието наtrue; Compose изпълни функцията наново;ifвече включва текста.- Доказва, че трите елемента и поздравът съществуват и че бутонът отговаря. Не доказва как изглеждат нито в какъв ред са.
Източници на урока
Отворени на 18 ноември 2026 г.
- Android Developers. Thinking in Compose. https://developer.android.com/develop/ui/compose/mental-model
- Android Developers. Jetpack Compose Tutorial. https://developer.android.com/develop/ui/compose/tutorial
- Android Developers. Compose layout basics. https://developer.android.com/develop/ui/compose/layouts/basics
- Android Developers. Column (стойности по подразбиране). https://developer.android.com/reference/kotlin/androidx/compose/foundation/layout/Column.composable
- Android Developers. Compose modifiers. https://developer.android.com/develop/ui/compose/modifiers
- Android Developers. State and Jetpack Compose. https://developer.android.com/develop/ui/compose/state
- Android Developers. Button. https://developer.android.com/develop/ui/compose/components/button
- Android Developers. Style text и Material Design 3 in Compose. https://developer.android.com/develop/ui/compose/text/style-text · https://developer.android.com/develop/ui/compose/designsystems/material3
- Android Developers. Support different pixel densities (dp). https://developer.android.com/training/multiscreen/screendensities
- Android Developers. Test your Compose layout. https://developer.android.com/develop/ui/compose/testing
- Android Developers. Role и SemanticsMatcher (роля на бутон в тестовете). https://developer.android.com/reference/kotlin/androidx/compose/ui/semantics/Role · https://developer.android.com/reference/kotlin/androidx/compose/ui/test/SemanticsMatcher
- Android Developers. Robolectric strategies. https://developer.android.com/training/testing/local-tests/robolectric
- Kotlin. Basic syntax. https://kotlinlang.org/docs/basic-syntax.html
- Kotlin. Null safety. https://kotlinlang.org/docs/null-safety.html
- Kotlin. Higher-order functions and lambdas. https://kotlinlang.org/docs/lambdas.html
- Собствено измерване: опит на Mac с Apple silicon на 13 ноември 2026 г. (паметта на Gradle,
gradle wrapper, Java и Android на симулираните тестове) и на 18 ноември 2026 г. (verificaвърхуinicio/,solucion/и листинга на 1.3; съобщенията на компилатора).
Външен преглед (18 ноември 2026 г.): С ПРОМЕНИ, 3 с висок приоритет, 5 със среден и 2 с нисък; приложен.
Предпочитате имейл? Пишете ни на hola@habil.mx