// Deň 1: Pohovor
interviewer = "Poznáte všetky SOLID princípy?"
candidate = "Áno: Single Responsibility, Open/Closed..."
interviewer = "A Liskov Substitution? Vysvetlite!"
candidate = *explains perfectly*
interviewer = "Hmm..."

// Deň 30: Prvý deň v práci
tech_lead = "Tu máš 10,000 riadkový súbor. Pridaj feature."
new_developer = "Ale... SOLID? Clean Code?"
tech_lead = "Čo? Áno, áno... neskôr. Teraz hotfix."

// Deň 60: Code review
new_developer = "Mal by som refaktorovať túto triedu?"
senior = "Nemáme na to čas. Funguje to."
new_developer = "A testy?"
senior = "Aké testy?"

// Kontrola reality:
coverage = "0%"
solid_principles = "nikdy o nich v produkcii nepočuli"
tdd = "čo to je?"
clean_code = "možno v ďalšom šprinte..."

Pohovor, 2 hodiny:

Minúta 0-15: "Rozprávajte o sebe"
Ty: "10 rokov skúseností, Spring Boot, Angular..."
Interviewer: *pokyvuje hlavou* "OK, poďme na techniku."

Minúta 15-30: Algoritmy
"Napíšte na tabuľu quicksort."
"Aká je časová zložitosť?"
"A priestorová?"
*vnútorný hlas: "Kedy som naposledy písal quicksort? Rok 2008?"*

Minúta 30-45: Dizajnové vzory
"Rozdiel medzi Strategy a State?"
"Kedy použiť Singleton?"
"Prečo je Singleton anti-pattern?"
"Ale kedy ho teda použiť?"
"Ale prečo je anti-pattern?"
*mozog: prestal fungovať*

Minúta 45-60: Java špecifiká
"Rozdiel medzi String a StringBuilder?"
"Ako funguje HashMap internálne?"
"Čo je ConcurrentHashMap?"
"Prečo je synchronized nebezpečné?"

Minúta 60-90: Frameworkové znalosti
"Ako funguje Spring AOP?"
"Čo je Bean Lifecycle?"
"Rozdiel medzi @Component a @Service?"
"Kedy použiť @Transactional?"
"A propagácia?"
*vnútorný hlas: "Googlujem to každý týždeň..."*

Minúta 90-120: Testovanie a best practices
"TDD prístup?"
"Požadované pokrytie testami?"
"SOLID princípy?"
"Clean Code princípy?"

Koniec:
Interviewer: "Ďakujeme, ozveme sa."
Ty: *brain.exe prestal fungovať*

// Scenár A: Vieš príliš málo
interviewer = "Nepozná všetky princípy..."
rozhodnutie = "❌ Nedostatočná kvalifikácia"

// Scenár B: Vieš presne toľko
interviewer = "Vie všetko čo potrebujeme..."
rozhodnutie = "✅ Možno... porozmýšľame"

// Scenár C: Vieš príliš veľa
interviewer = "Vie viac ako ja..."
vnútorné_myšlienky = "Riziko. Bude ma spochybňovať."
rozhodnutie = "❌ Prekvalifikovaný / Nezapadá do tímu"

// Sladké miesto:
perfektný_kandidát = {
    znalosti: "Presne toľko čo ja + 10%",
    skúsenosti: "Nie viac ako moje",
    sebavedomie: "Stredné (nie ohrozujúce)",
    platové_očakávania: "Pod rozpočet"
}

// Realita:
perfektný_kandidát_nájdený = false
spokojili_sme_sa_s = "Najbližšou aproximáciou"

Interviewer robí 10 rokov s jednou technológiou:
- Spring Boot 2.3
- MySQL
- jQuery
- SVN

Kandidát má skúsenosti:
- Spring Boot 3.x
- PostgreSQL + MongoDB
- React + Angular
- Git + GitHub Actions

Výsledok:
"Nemá skúsenosti s našim stackom."

Interviewer: "Používame Test-Driven Development."
Kandidát: "Skvelé! Ja tiež preferujem TDD."
Interviewer: "A code coverage?"
Kandidát: "Minimálne 80%."
Interviewer: "Perfektné!"

# Kontrola test coverage
mvn test jacoco:report

# Výstup:
[INFO] Code Coverage: 0%
[INFO] Tests: 0
[INFO] Test Classes: 0

# Počkať, čo?

# Kontrola posledného commitu
git log --all --since="1 year ago" --grep="test"

# Výstup:
# (nič)

# Kontrola CI/CD
cat .gitlab-ci.yml

# Výstup:
stages:
  - build
  - deploy
# Žiadna 'test' fáza

Ty: "Kde sú testy?"
Tím: "Aké testy?"
Ty: "Unit testy? Integračné testy?"
Tím: "Nemáme čas na testy."
Ty: "Ale na pohovore..."
Tím: "Áno, áno... to je pre kandidátov."
Ty: *tichý výkrik*

Interviewer: "Aký je váš prístup k dizajnu?"
Kandidát: "SOLID princípy, Clean Code..."
Interviewer: "Presne! My tiež!"

// UserController.java (3,500 riadkov)
@RestController
public class UserController {
    
    // Injektované závislosti: 15 služieb
    @Autowired private UserService userService;
    @Autowired private EmailService emailService;
    @Autowired private SmsService smsService;
    @Autowired private NotificationService notificationService;
    @Autowired private LoggingService loggingService;
    @Autowired private AuditService auditService;
    @Autowired private CacheService cacheService;
    @Autowired private ValidationService validationService;
    @Autowired private AuthService authService;
    @Autowired private PermissionService permissionService;
    @Autowired private ReportService reportService;
    @Autowired private AnalyticsService analyticsService;
    @Autowired private SearchService searchService;
    @Autowired private ExportService exportService;
    @Autowired private ImportService importService;
    
    @PostMapping("/users")
    public ResponseEntity createUser(@RequestBody UserDTO dto) {
        // 500 riadkov kódu
        // - Validácia
        // - Biznis logika
        // - Databázové operácie
        // - Odosielanie emailov
        // - Odosielanie SMS
        // - Notifikácie
        // - Logovanie
        // - Audit
        // - Aktualizácia cache
        // - Analytics event
        // - Generovanie reportu
        // Všetko v JEDNEJ metóde!
        
        // Kde je Single Responsibility?
    }
    
    // ... ďalších 50 podobných metód
}

// Komentáre v kóde:
// TODO: Zrefaktorovať tento neporiadok
// TODO: Rozdeliť do služieb
// TODO: Pridať testy
// TODO: Aplikovať SOLID
// (Komentáre z roku 2019, stále tu v 2024)

Ty: "Toto porušuje Single Responsibility..."
Senior: "Funguje to. Netreba sa toho dotýkať."
Ty: "Ale mohli by sme zrefaktorovať..."
Senior: "Nie je čas. Ďalší feature."

Interviewer: "Čítali ste Clean Code?"
Kandidát: "Áno, Robert Martin je skvelý!"
Interviewer: "My to dodržiavame! Čisté názvy, malé funkcie..."

// OrderService.java

public class OrderService {
    
    // Metóda 1: Čo toto robí?
    public void processOrder(Order o) {
        // 800 riadkov kódu
        // Žiadne komentáre
        // Premenné: a, b, c, tmp, tmp2, result, r
        // Vnorené if: 8 úrovní hlboko
        // Viacero returnov na náhodných miestach
        // Vedľajšie efekty všade
        
        if (o.getType() == 1) {
            if (o.getStatus() != null) {
                if (!o.getStatus().equals("")) {
                    if (o.getItems() != null && o.getItems().size() > 0) {
                        for (Item i : o.getItems()) {
                            if (i.getPrice() > 0) {
                                if (i.getQuantity() > 0) {
                                    // Biznis logika niekde tu
                                    // Veľa šťastia pri hľadaní!
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    
    // Metóda 2: Kreatívne pomenovanie
    public String doIt(String s, int n) {
        String tmp = s;
        for (int i = 0; i < n; i++) {
            tmp = tmp + "x";
        }
        return tmp;
    }
    
    // Metóda 3: Magické čísla všade
    public boolean validate(Order order) {
        if (order.getTotal() > 1000 && 
            order.getItems().size() < 50 &&
            order.getWeight() < 100 &&
            order.getStatus() == 3) {
            return true;
        }
        return false;
    }
}

// Git blame:
// Autor: Architekt (odišiel z firmy pred 5 rokmi)
// Posledná úprava: 2019
// Komentáre: 0
// Testy: 0
// TODO: Prepísať (z roku 2019)

Symptóm:
  skúsenosti_interviewera: "10 rokov s tým istým stackom"
  znalosti_interviewera: "Hlboké ale úzke"
  strach_interviewera: "Byť nahradený alebo spochybnený"

Správanie:
  testuje_všetko: true
  pýta_triviálne_otázky: true
  zameriava_sa_na_teóriu: true
  ignoruje_praktické_skúsenosti: true

Výsledok:
  zamestná_juniora: "Bezpečné, žiadna hrozba"
  odmietne_seniora: "Prekvalifikovaný / Príliš drahý"
  
Realita:
  problémy_projektu: "Pretrvávajú navždy"
  technický_dlh: "Rastie exponenciálne"
  frustrácia_tímu: "Vysoká"

Inventár: "Ako funguje HashMap internálne?"
Kandidát: "Hash funkcia, buckets, riešenie kolízií..."
Inventár: "Dobré. A load factor?"
Kandidát: "Predvolene 0.75, rehashing pri 75% kapacity..."
Inventár: "Hmm... A prečo práve 0.75?"
Kandidát: "Rovnováha medzi pamäťou a výkonom..."
Inventár: "A aký algoritmus používa pri rehashing?"
Kandidát: "Ehm... kapacita * 2..."
Inventár: "❌ Nedostatočná znalosť internej implementácie"

// Medzitým v produkcii:
// HashMap použitý: 5x v celom kóde
// Problém s výkonom HashMap: 0 (nikdy)
// Čas stratený na teórii: 2 hodiny
// Skutočný problém na riešenie: 
//   - 0% pokrytie testami
//   - 10,000 riadkové triedy
//   - Žiadna dokumentácia
//   - Legacy kód z roku 2015

Javisko pohovoru:
  hovoríme: "Používame TDD"
  hovoríme: "Dodržiavame SOLID"
  hovoríme: "Praktizujeme Clean Code"
  hovoríme: "Máme 80% pokrytie"
  hovoríme: "Robíme code reviews"

Produkčná realita:
  tdd: false
  solid: false
  clean_code: false
  pokrytie: 0%
  code_reviews: "Schválené bez čítania"

Prečo to divadlo?
  nábor: "Musíme znieť profesionálne"
  kandidáti: "Chcú počuť best practices"
  všetci: "Predstierajú že je to pravda"
  
Pravda:
  nikto_tomu_neverí: true
  všetci_hrajú_hru: true
  nič_sa_nezmení: true

// Pohovor
Kandidát: "Aká je vaša definícia 'done'?"
Interviewer: "Testy prejdú, pokrytie >80%, code review, nasadené."

// Produkcia (Týždeň 3)
Ty: "Môžem vidieť CI/CD pipeline?"
Tím: "Nemáme."
Ty: "Ale ako testujete?"
Tím: "Manuálne. Na produkcii."
Ty: "..."
Tím: "Funguje to roky!"

// Rok 2024 - AI všade

// Pohovor:
interviewer = "Používate AI nástroje?"
kandidát = "Áno, GitHub Copilot, ChatGPT..."
interviewer = "Super! Budúcnosť!"

// Produkcia:
rok_codebase = 2015
posledný_refaktoring = 2017
pokrytie_testami = 0%
ci_cd = false
code_reviews = "Občas"
dokumentácia = "Možno vo wiki"

// Problém:
ai_nástroje = "Nepomôžu s legacy neporiadkom"
copilot = "Navrhuje podľa existujúcich vzorov (zlých)"
chatgpt = "Nevie opraviť 10 rokov technického dlhu"

// Irónia:
rozprávame_o_ai = "Na každom meetingu"
používame_ai_na = "Písanie commit správ"
ignorujeme = "Základný softvérový inžiniering"

// Výsledok:
produktivita = "Rovnaká ako 2015"
kvalita_kódu = "Horšia (AI zosilňuje zlé vzory)"
technický_dlh = "Raketovo rastie"

Manažér: "Použite AI na zrýchlenie vývoja!"

Developer používa Copilot:
// Copilot navrhuje podľa existujúceho kódu
// Existujúci kód = 0 testov, zlé vzory

Výsledok:
// AI generuje kód v rovnako zlom štýle
// Teraz máme VIAC zlého kódu, rýchlejšie!

Príklad:
// Existujúci kód:
public void doSomething(String s, int n) { ... }

// Návrh Copilota:
public void doSomethingElse(String s2, int n2) { ... }

// Perfektné! Rovnako zlé pomenovanie, rovnaká zlá štruktúra!
// Technický dlh zvýšený: +20%

Namiesto:
  "Vysvetlite SOLID princípy" (teória)

Skúste:
  "Ukážte mi vaše GitHub projekty" (prax)
  "Prejdime si tento kód" (reálny kód)
  "Ako by ste riešili X?" (praktický problém)

Zamerajte sa na:
  ✅ Schopnosť riešiť problémy
  ✅ Komunikačné zručnosti
  ✅ Reálne skúsenosti
  ✅ Kód čo napísali
  
Vynechajte:
  ❌ Teoretické triviality
  ❌ Algoritmické hádanky (pokiaľ nie sú potrebné)
  ❌ Pomenovanie dizajnových vzorov
  ❌ Vnútornosti frameworkov

Interviewer: "Tu je náš aktuálny problém..."
*Ukáže reálny produkčný problém*

Kandidát: "OK, skúsim..."
*Diskutuje prístup, pýta sa otázky, načrtne riešenie*

Výsledok:
✅ Vidíte ako premýšľa
✅ Vidíte ako komunikuje
✅ Vidíte jeho skúsenosti
✅ Relevantné pre skutočnú prácu

Zlý popis práce:
  používame: "TDD, SOLID, Clean Code, mikro služby"
  realita: "Legacy monolit, 0% pokrytie, žiadne testy"
  
  výsledok: "Sklamaní noví zamestnanci, vysoká fluktuácia"

Dobrý popis práce:
  máme: "Legacy kódovú bázu z roku 2015"
  potrebujeme: "Pomoc s modernizáciou a pridávaním testov"
  ponúkame: "Slobodu zlepšovať, čas na refaktoring"
  
  výsledok: "Správne očakávania, šťastný tím"

Divadelná verzia:
"Používame najmodernejšie technológie, TDD, mikroslužby..."

Úprimná verzia:
"Máme PHP monolit z roku 2010, ktorý potrebuje lásku.
Zatiaľ žiadne testy. Chceme to zmeniť. 
Ak ťa baví refaktoring a modernizácia, budeš sa tu cítiť dobre."

Ktorá pritiahne lepších kandidátov?
Úprimná verzia! Ľudia čo CHCÚ veci opravovať! ✅

Testujte čo má zmysel:
  ✅ Vedia napísať fungujúci kód?
  ✅ Vedia čítať existujúci kód?
  ✅ Vedia ladiť problémy?
  ✅ Vedia sa rýchlo učiť?
  ✅ Vedia komunikovať?

Netestujte:
  ❌ Naspamätané algoritmy
  ❌ Názvy dizajnových vzorov
  ❌ Vnútornosti frameworkov
  ❌ Kvízové otázky

// Dajte tento kód:
public class OrderProcessor {
    public void process(Order order) {
        if (order.getTotal() > 1000) {
            order.setDiscount(0.1);
        }
        order.setProcessed(true);
        save(order);
    }
}

// Opýtajte sa:
"Produkční používatelia hlásia, že zľavy nie sú správne aplikované.
Ako by ste to ladili?"

// Dobré odpovede:
✅ "Pridám logovanie, nech vidím skutočné hodnoty"
✅ "Napíšem test na reprodukciu problému"
✅ "Skontrolujem v databáze objednávky > 1000"
✅ "Pozriem sa na výpočet order.getTotal()"

// Zlé odpovede:
❌ "Vysvetlím vnútornosti HashMap"
❌ "Odrecitujem SOLID princípy"
❌ "Nakreslím UML diagram"

Kandidát: Prihlásil sa do startupu
Pozícia: Senior Java Developer

Pohovor (2 hodiny):
- 30 min: Chat o skúsenostiach (reálne projekty)
- 60 min: Párové programovanie na reálnom probléme
- 30 min: Otázky z oboch strán

Párové programovanie:
"Naše API je pomalé. Tu je výstup z profilera. Vyšetrite."

Kandidát:
✅ Analyzoval profiler
✅ Našiel N+1 query problém
✅ Navrhol riešenie
✅ Diskutoval kompromisy
✅ Pýtal sa na stratégiu cache

Výsledok:
Prijatý! Začal o týždeň.

Realita:
- Projekt BOL pomalý (ako povedali)
- CHCELI to opraviť (ako povedali)
- Testy existovali (ako povedali)
- Code reviews sa robili (ako povedali)

Spokojnosť: 10/10 ✅

Kandidát: Prihlásil sa do korporácie
Pozícia: Java Architekt

Pohovor (4 hodiny):
- 1 hodina: Otázky na algoritmy
- 1 hodina: Dizajnové vzory
- 1 hodina: Systémový dizajn
- 1 hodina: Behaviorálne otázky

Výsledok:
Prijatý! Začal o mesiac.

Kontrola reality (Týždeň 1):
- Žiadna architektúra (len legacy monolit)
- Žiadne dizajnové vzory (len procedurálny kód)
- Žiadny systémový dizajn (jeden server)
- Testy: 0%
- Dokumentácia: 0%
- Technický dlh: Maximum

Skutočná rola:
"Opravuj bugy v 15-ročnom kóde."

Spokojnosť: 2/10
Odišiel po 3 mesiacoch.

Kandidát: Prihlásil sa do agentúry
Pozícia: Full-stack Developer

Pohovor (1 hodina):
- 15 min: "Máme starú PHP aplikáciu, žiadne testy"
- 15 min: "Chceme modernizovať"
- 30 min: "Môžeš pomôcť? Ukáž mi príklady."

Kandidát ukázal:
✅ Podobný migračný projekt
✅ Pred/po kód
✅ Ako pridali testy
✅ Výsledky (pokrytie, výkon)

Výsledok:
Prijatý! Začal o 2 týždne.

Realita:
- Projekt BOL starý PHP (ako povedali)
- CHCELI modernizovať (ako povedali)
- DALI čas na refaktoring (ako povedali)
- OCENILI zlepšenia (ako povedali)

Spokojnosť: 9/10 ✅
Stále tam po 2 rokoch.

Pred pohovorom:
  ✅ Vedz čo skutočne robíte (nie divadlo)
  ✅ Vedz čo skutočne potrebujete
  ✅ Buď úprimný v popise práce
  ✅ Priprav relevantné otázky

Počas pohovoru:
  ✅ Zameraj sa na praktické zručnosti
  ✅ Ukáž reálne problémy
  ✅ Hodnoť riešenie problémov
  ✅ Skontroluj kultúrnu zhodu

Po pohovore:
  ✅ Poskytni spätnú väzbu (ak odmietnutý)
  ✅ Buď úprimný o role
  ✅ Nepredávaj sny
  ✅ Nastav reálne očakávania

Červené vlajky, že to robíš zle:
  ❌ Pýtaš sa otázky čo si musel googlať
  ❌ Testuješ znalosti čo nepoužívaš
  ❌ Odmietaš prekvalifikovaných kandidátov
  ❌ Sľubuješ čo nemáš

opýtaj_sa_seba = {
    "Naozaj používame TDD?": false,
    "Naozaj máme testy?": false,
    "Naozaj dodržiavame SOLID?": false,
    "Naozaj robíme code reviews?": false
}

if (VŠETKO_FALSE) {
    akcia = "Prestaň predstierať na pohovoroch! Buď úprimný!"
}

lepší_prístup = {
    "Máme legacy kód": true,
    "Chceme sa zlepšiť": true,
    "Potrebujeme s tým pomôcť": true,
    "Máš záujem?": spýtaj_sa_kandidáta
}

výsledok = "Lepšie zhody, šťastnejší tím, menšia fluktuácia"

Počas pohovoru, sleduj:
  🚩 Len teoretické otázky
  🚩 Žiadne praktické hodnotenie
  🚩 Nevedia ukázať skutočný kód
  🚩 Vágne o praktikách
  🚩 "Dodržiavame VŠETKY best practices"
  🚩 Perfektné odpovede na každú otázku
  🚩 Žiadne úprimné výzvy spomenuté

Dobré znamenia:
  ✅ Praktické problémy
  ✅ Reálny kód na preskúmanie
  ✅ Úprimní o výzvach
  ✅ Konkrétni o praktikách
  ✅ Otvorení o oblastiach na zlepšenie
  ✅ Tím ťa stretne
  ✅ Ukážu skutočný workspace

Nepýtaj sa:
❌ "Používate TDD?" (každý povie áno)
❌ "Dodržiavate SOLID?" (každý povie áno)
❌ "Máte testy?" (každý povie áno)

Namiesto toho sa spýtaj:
✅ "Môžem vidieť váš CI/CD pipeline?"
✅ "Aké máte pokrytie testami?"
✅ "Môžete mi ukázať váš kód?"
✅ "Aká je vaša najväčšia technická výzva?"
✅ "Čo by ste zlepšili, keby ste mali čas?"
✅ "Aká stará je vaša hlavná aplikácia?"
✅ "Kedy bol posledný veľký refaktoring?"

Ak nevedia odpovedať alebo sa vyhýbajú:
🚩 Červená vlajka! Divadlo odhalené!

Pohovor = Divadlo
- Pýtame sa na veci čo nepoužívame
- Sľubujeme veci čo nerobíme
- Testujeme znalosti čo nepotrebujeme

Realita = Chaos
- Legacy kód bez testov
- Žiadne best practices
- Technický dlh do neba

Výsledok = Frustrácia
- Kandidáti sklamaní
- Firmy nemajú správnych ľudí
- Projekty trpia

Riešenie = Úprimnosť
- Povedz pravdu o projekte
- Testuj praktické zručnosti
- Oceň reálnu skúsenosť
- Daj čas na zlepšovanie

Pre interviewerov:
  ✅ Buď úprimný o tom čo máte
  ✅ Testuj čo skutočne potrebuješ
  ✅ Hodnoť praktické zručnosti
  ✅ Neboj sa silných kandidátov

Pre kandidátov:
  ✅ Pýtaj sa na reálne praktiky
  ✅ Vyžiadaj si ukážku kódu
  ✅ Skontroluj skutočný workflow
  ✅ Dôveruj svojim červeným vlajkám

Pre firmy:
  ✅ Daj čas na zlepšenia
  ✅ Oceň pragmatizmus pred teóriou
  ✅ Zamestnávaj pre potenciál
  ✅ Podporuj učenie

// Najlepšia otázka na pohovore:
"Tu je náš problém. Ako by si to riešil?"

// Najlepšia odpoveď:
"Pozrime sa na to spolu..."

// Výsledok:
vzájomné_porozumenie = true
realistické_očakávania = true
dobrá_zhoda = true
šťastný_tím = true

// Bonus:
divadlo = false // Konečne!