Aktywne Wpisy
mirko_anonim +7
✨️ Czy zmiana nazwiska po ślubie jest ważna? Ⓘ
Latem przyszłego roku planuję ślub. Jednak mam jeden ogromny zgrzyt, który dosłownie czuję jak strzał w serce. Moja narzeczona nie planuje zmieniać nazwiska – nawet nie chce podwójnego.
Od początku przygotowań na wszystko się zgadzałem. Wybór sali, muzyka, jedzenia, fotografa, nawet podróż poślubna jest wybrana stricte pod nią. Ona chce ceremonię na plaży, zgadzam się. Chce konkretną muzykę, zgadzam się. Fotograf, jedzenie, podróż poślubna –
Latem przyszłego roku planuję ślub. Jednak mam jeden ogromny zgrzyt, który dosłownie czuję jak strzał w serce. Moja narzeczona nie planuje zmieniać nazwiska – nawet nie chce podwójnego.
Od początku przygotowań na wszystko się zgadzałem. Wybór sali, muzyka, jedzenia, fotografa, nawet podróż poślubna jest wybrana stricte pod nią. Ona chce ceremonię na plaży, zgadzam się. Chce konkretną muzykę, zgadzam się. Fotograf, jedzenie, podróż poślubna –
wash-and-go +257
Wiki Gabor, tak ona ma 18 lat. #muzyka
źródło: temp_file8944781778672110786
Pobierz
Aktywne Znaleziska
Realistyczny czas nauki pod rekrutacje - 120 dni - ale tutaj mamy skompresowaną wersję 60 dni z-----------a (tylko po to, by zostać olanym po 5 etapach rekrutacji)
Format dnia (stały rytm — łatwiej budować nawyk):
09:00–10:00 — Warm-up: algorytm / zadanie kodujące (1h) — szybkie zadanie/analiza złożoności.
10:00–13:00 — Deep dive (teoria + notatki) (3h) — kluczowe koncepcje + czytanie doc/książek.
13:00–14:00 — Lunch + artykuł / video (1h) — lekka teoria lub case study.
14:00–16:00 — Hands-on / ćwiczenia praktyczne (2h) — implementacje, laby, infra.
16:15–17:15 — Interview practice / system design / mock (1h) — krótkie Q&A, projektowanie, whiteboard.
17:15–17:30 — Daily review (15 min) — zapisz 3 rzeczy, których się nauczyłeś + 1 problem do powtórki.
Poniżej: Dzień po dniu (Day 1 → Day 60), podzielone na tygodnie tematyczne. Każdy dzień zawiera konkretne zadania/cele. Na końcu: materiały rekomendowane, checklisty i wskazówki do livecoding / rozmów.
Struktura organizacyjna
Sprinty:
1.) Sprint = 1 tydzień (7 dni), każdy tydzień ma swój temat przewodni (np. JVM, Spring, Bazy danych).
- Na koniec sprintu: Retrospekcja + przegląd wiedzy + mini-projekt lub test.
2.) Daily (15–20 min codziennie):
- Planowanie dnia: ustal cel główny (deep dive lub projekt) i 1–2 zadania dodatkowe.
- Code kata lub LeetCode (1 zadanie): utrwalanie algorytmów.
- Flashcards/anki (5–10 min): powtórka teorii.
- Krótka refleksja wieczorem: co działa, co poprawić jutro
Jak wdrożyć daily i sprinty
- Rano: 15 min daily (1 algorytm + flashcards z teorii z wczoraj).
- Po lunchu: deep dive w temat tygodnia (2–3h).
- Popołudnie: hands-on coding/demo (2h).
- Wieczór (15 min): zapis notatek, checklista progresu.
- Weekend: Retrospekcja Sprintu – checklisty, pytania, mini-projekt.
Sprint 1 (Tydzień 1) — JVM, Java zaawansowana i Concurrency
Cel tygodnia: pełne zrozumienie JVM, classloading, GC, pamięć, Java Memory Model, concurrency primitives, locki, atomic, volatile, ThreadPool, ForkJoin.
Mini-flashcards: Garbage Collectors, Memory Model, Locki.
Day 1
Warm-up: analiza O(n)/O(log n) + proste zadanie na tablicy.
Deep dive: architektura JVM, klasloadery, bytecode (jak działa javac → java).
Hands-on: uruchom jcmd, jmap, jstat na prostym programie; wygeneruj heap dump.
Interview practice: pytania o classloader i różnice między JRE a JDK.
Day 2
Warm-up: zadanie na wskaźniki/indeksy.
Deep dive: Garbage Collectors (G1, ZGC, Shenandoah) — kiedy jaki wybierać i dlaczego.
Hands-on: eksperyment z flagami JVM (-Xmx, -Xms, -XX:+UseG1GC) i profilowanie.
Mock: opisz GC pause, stop-the-world i jak ich unikać.
Day 3
Warm-up: zadanie na konkurencję (producer/consumer).
Deep dive: Java Memory Model, volatile, synchronized, final, happens-before.
Hands-on: napisz concurrent counter z AtomicLong i z synchronized → porównaj wydajność.
Interview practice: pytania na pamięć i widoczność (visibility).
teoria OS: scheduling, context switching, deadlock prevention.
Day 4
Warm-up: zadanie na lock-free thinking (CAS).
Deep dive: Lock, ReadWriteLock, StampedLock, ReentrantLock — kiedy używać.
Hands-on: implementuj prosty cache z ReadWriteLock.
Mock: scenariusze deadlock + jak debugować.
Day 5
Warm-up: task związany z thread pools.
Deep dive: ExecutorService, ForkJoinPool, work-stealing, tuning thread pool.
Hands-on: paralelizuj zadanie CPU-bound vs IO-bound, porównaj wyniki.
Interview practice: pytania o ThreadPoolExecutor params.
Day 6
Warm-up: małe zadanie z kolekcjami.
Deep dive: Collections concurrency: ConcurrentHashMap, CopyOnWriteArrayList.
(ConcurrentHashMap): hands-on: symulacja deadlock w bash (Linux kill, top, ps).
Hands-on: profiluj Mp-y pod wieloma wątkami.
Mock: opisz implementację ConcurrentHashMap (segmenty/stripes vs CAS buckets).
Day 7
Przegląd tygodnia: powtórka notatek, flashcards.
Duży hands-on: mini-projekt — prosty concurrent crawler (wiele wątków, limiting).
Przygotuj listę pytań, które sprawiały trudność.
Sprint 2 (Tydzień 2) — Spring Core, Boot, Security
Cel: Spring Core, Boot, MVC, Data, Security, AOP, transakcje, konfiguracja, testy w Spring. Krótkie daily o debugowaniu Spring context.
Day 8
Warm-up: zadanie na string/parsowanie.
Deep dive: Spring Core — IoC/DI, Bean lifecycle, autowiring, profiles.
Hands-on: stwórz małą aplikację Spring Boot konfigurując bean scope i profile.
Mock: pytania o DI vs Service Locator.
Day 9
Warm-up: prosty algorytm.
Deep dive: Spring Boot autoconfiguration, starters, actuator.
Hands-on: dodaj Actuator, healthchecks, custom metrics.
Interview: jak autoconfigure działa (ConditionalOn…).
Day 10
Warm-up: zadanie na stack/queue.
Deep dive: Spring MVC / REST controllers — request handling, @ControllerAdvice, validation.
Hands-on: zbuduj REST API z walidacją i globalnym handlerem błędów.
Mock: różnice między @RestController a @Controller.
Day 11
Warm-up: daty i time zone task (przydatne w API).
Deep dive: Spring Data JPA — entitites, lazy vs eager, N+1 problem, JPQL.
Hands-on: zaprojektuj encje i zoptymalizuj zapytania (profilowanie SQL).
Interview: transakcje i izolacje.
Day 12
Warm-up: zadanie SQL logiczne.
Deep dive: Spring Transaction Management, programmatic vs declarative.
Hands-on: scenariusze rollback, nested transactions, propagation.
Mock: jak debugować problemy transakcyjne.
Day 13
Warm-up: krótkie zad. na mapy.
Deep dive: Spring Security (authn/authz), JWT, OAuth basics. OWASP Top 10, CSRF, XSS, SQLi.
Hands-on: zabezpiecz endpointy, dodaj JWT auth.
Interview: różnice JWT vs sessions.
Day 14
Przegląd: praktyczny mini-projekt — service z DB, zabezpieczeniem, actuator, testami integracyjnymi.
Napraw błędy, utwórz checklistę do rozmowy o Spring.
Sprint 3 (Tydzień 3) — Bazy danych, Elasticsearch
Hands-on: zrób query plan dla trzech różnych zapytań i zapisz w notatkach screeny z explain plan.
Cel: pogłębione umiejętności w SQL tuning, modelowaniu NoSQL (DynamoDB), oraz zaawansowane możliwości Elasticsearch.
Day 15
Warm-up: zadanie na sortowanie.
Deep dive: relacyjne bazy — indeksy, explain plan, query tuning.
Hands-on: optymalizuj zapytania, stwórz indexy, porównaj plan.
Mock: pytania o ACID, isolation levels.
Day 16
Warm-up: zadanie na agregacje.
Deep dive: transakcje rozproszone — 2PC, eventual consistency.
Hands-on: symulacja prostego distributed transaction scenario.
Interview: jak rozwiązać cross-db transactions.
Day 17
Warm-up: zadanie na hashing.
Deep dive: NoSQL — DynamoDB: modelowanie klucza, GSIs, LSIs, provisioning vs on-demand.
Hands-on: zaprojektuj tabelę DynamoDB dla systemu events.
Mock: kiedy NoSQL vs RDBMS.
Day 18
Warm-up: zadanie na sliding window.
Deep dive: projektowanie schematu dla szerokich tabel, punktualne odczyty vs skany.
Hands-on: przykładowe zapytania, skan vs query, cost optimization.
Interview: access patterns design.
Day 19
Warm-up: zadanie na string matching.
Deep dive: Elasticsearch — analiza indeksu, tokenizery, analyzers, mapping.
Hands-on: indeksuj dokumenty, testuj różne analyzers, wykonaj fuzz/phrase queries.
Mock: różnice ES vs DB, kiedy używać.
Day 20
Warm-up: grafowe myślenie (krótkie).
Deep dive: agregacje, paginacja, scrolly/point-in-time, shard/replica, reindexing.
Hands-on: napisz agregację (terms + sub-aggs), przetestuj performance.
Interview: scaling ES (shard sizing).
Day 21
Przegląd tygodnia + mini-zadanie: zaimplementuj search endpoint używający ES + fallback do DB.
Tydzień 4 — AWS i chmura (praktyczne wzorce)
Cel: dogłębne praktyczne użycie S3, DynamoDB, SNS/SQS, Lambda, CloudWatch, IAM, deployment patterns (serverless + containers).
Daily: 5 min CLI AWS (np. aws s3 ls, aws dynamodb list-tables – jeśli masz środowisko).
Day 22
Warm-up: zad. logiczne.
Deep dive: IAM, zasady bezpieczeństwa, least-privilege.
Hands-on: utwórz role i policy (lokalnie lub symulacja).
Mock: jak zaprojektować politykę IAM dla mikroserwisu.
Day 23
Warm-up: zad. tablicowe.
Deep dive: S3 — lifecycle, wersjonowanie, konsystencja, pre-signed URLs.
DNS TTL, propagacja, CDN edge computing.
Hands-on: upload/download, lifecycle rules i encryption (SSE).
Interview: S3 consistency model.
Day 24
Warm-up: krótkie zad. asynchroniczne.
Deep dive: SNS vs SQS — wzorce pub/sub, FIFO queues, deduplikacja, visibility timeout.
Hands-on: zbuduj prosty event chain SNS→SQS→Lambda.
Mock: retry/poison message handling.
Day 25
Warm-up: lambda reasoning.
Deep dive: Lambda cold start, pakowanie dependencies, monitoring.
Hands-on: napisanie niewielkiej Lambda w Java (z handlerem), testowanie lokalne.
Interview: koszty i ograniczenia Lambdy.
Day 26
Warm-up: zad. skalowania.
Deep dive: DynamoDB operacje, backup, streams (Kinesis/Dynamo streams) i integracja z Lambdą.
Hands-on: zaprojektuj event-driven flow z DynamoDB Streams.
Mock: kiedy wybrać DynamoDB Streams vs Kinesis.
Day 27
Warm-up: krótkie zadanie.
Deep dive: CloudWatch Logs/Metrics/Alarms + X-Ray basics.
Hands-on: skonfiguruj metryki custom i alarm.
Interview: observability na produkcji.
Day 28
Przegląd tygodnia: deploy prostego mikroserwisu (np. Spring Boot) na AWS — wybierz model: ECS / Elastic Beanstalk / Lambda (w zależności od preferencji) i zrób minimalny deployment lub dokumentację krok po kroku.
Sprint 5 (Tydzień 5) — Architektura systemów
Extra daily: tcpdump/wireshark – zrzut pakietów, analiza handshake.
Cel: system design: skalowanie, odporność, consistency, microservices patterns, SAGA, CQRS, caching, CDN.
Diagram na koniec sprintu: jeden system design (chat, log pipeline).
Day 29
Warm-up: problem grafowy.
Deep dive: monolith → microservices — zalety i wady, granice usług.
Hands-on: decompositional exercise: rozbij przykład monolitu (e-commerce).
Mock: pytania o bounded contexts.
Day 30
Warm-up: zad. logiki.
Deep dive: API design — REST best practices, versioning, HATEOAS, idempotency.
Hands-on: zaprojektuj REST API z paginacją, filtrami, wersjonowaniem.
Mock: zaprojektuj endpoint do checkoutu.
Day 31
Warm-up: zadanie związane z cache.
Deep dive: caching strategies (cache aside, write-through, write-behind), invalidation problems.
Hands-on: zbuduj cache layer (Redis/ehcache) i mierz cache hit ratio.
Interview: cache invalidation scenarios.
Day 32
Warm-up: zadanie o sieciach.
Deep dive: resiliency patterns — circuit breaker, bulkhead, retry with backoff, timeout.
(resiliency): OSI vs TCP/IP, różnice TCP/UDP, QUIC, HTTP/2/3.
Hands-on: implementuj retry + circuit breaker (Resilience4j).
Mock: dyskusja o SLA/SLI/SLO.
Day 33
Warm-up: problem z kolejkowaniem.
Deep dive: SAGA vs 2PC, eventual consistency patterns, compensating transactions.
Hands-on: zaprojektuj proces zamówienia z SAGA (orchestrator vs choreography).
Mock: tradeoffs consistency vs availability.
Day 34
Warm-up: load balancing thinking.
Deep dive: partitioning/sharding, multi-region architectures, CDN, geo-redundancy.
Load balancing algorytmy + sticky sessions, health checks.
Hands-on: zaprojektuj sharding dla bardzo dużej tabeli użytkowników.
Interview: jak testować disaster recovery.
Day 35
Przegląd tygodnia: przygotuj 2 duże system designy: (a) skalowalny system chatowy, (b) system do logów/analizy czasu rzeczywistego. Przygotuj diagramy i opis komponentów.
Sprint 6 (Tydzień 6) — DevOps i CI/CD
Extra daily (Sprint 6): 10-min ćwiczenie strace, lsof, htop.
Cel: Git zaawansowany, Docker, k8s podstawy (jeśli potrzebne), CI/CD, monitoring, logging, bezpieczeństwo pipeline.
Day 36
Warm-up: git challenge (rewriting history mental).
Deep dive: Git advanced — rebase, cherry-pick, reflog, bisect, submodules, hooks.
Hands-on: zrób git bisect na bugu w repo.
Mock: scenariusze merge conflicts + resolution.
Day 37
Warm-up: zad. workflow.
Deep dive: branching strategies (GitFlow, trunk-based).
Hands-on: przygotuj release flow i script do automatycznych bumpów wersji.
Interview: jak przeprowadzić rollback.
Day 38
Warm-up: Docker mental map.
Deep dive: Docker internals, layers, multi-stage builds, image size optimization.
Hands-on: dockerize aplikację Spring Boot, zbuduj multi-stage image.
Mock: pytania o zabezpieczenia image (scan).
Day 39
Warm-up: orchesty basics.
Deep dive: Kubernetes podstawy (pods, svc, deployments, configmap, secrets) — jeżeli firma używa ECS zamiast K8s, pokaż analogie.
Hands-on: uruchom aplikację w minikube / kind (lokalnie).
Interview: readiness vs liveness probes.
Day 40
Warm-up: zad. CI/CD logiczne.
Deep dive: CI/CD pipelines (Jenkins/GitHub Actions/GitLab CI), pipeline as code.
Hands-on: stwórz pipeline do build/test/deploy (np. GitHub Actions).
Mock: co uwzględnić w pipeline (security scans, tests, canary).
Day 41
Warm-up: log aggregation thinking.
Deep dive: logging/monitoring/observability — ELK/Opensearch, CloudWatch, metrics (Prometheus/Grafana idea).
Hands-on: skonfiguruj log shipping + proste dashboardy.
Interview: jak zdiagnozować memory leak w prod.
Day 42
Przegląd tygodnia: end-to-end — dockerize, CI pipeline, deploy to local k8s/ECS, obserwowalność. Przygotuj krótkie demo.
Weekend (Sprint 6): Linux scripting – mini skrypt do monitoringu procesów.
Sprint 7 (Tydzień 7) — Algorytmy + Struktury danych
Cel: intensywna praktyka z leet-style problems, techniki rozwiązywania, wzorce.
Daily review: krótka analiza złożoności rozwiązania w Big-O.
Day 43
Warm-up: array/two-pointers problem.
Deep dive: common patterns (two pointers, sliding window, prefix sum).
Hands-on: rozwiąż 3 zadania średnie.
Mock: livecoding — mów głośno plan.
Day 44
Warm-up: linked list task.
Deep dive: linked lists, reversing, detect cycle, merge lists.
Hands-on: rozwiąż 3 zadania (w tym 1 hard).
Interview: jak testujesz swoją funkcję (casey edge).
Day 45
Warm-up: stack/queue task.
Deep dive: stack/queue, monotonic stack, heap usage.
Hands-on: priority queue problems (k-largest).
Livecoding: 45-min mock (nagrane/na żywo).
Day 46
Warm-up: tree traversal.
Deep dive: BST, tree traversal (DFS/BFS), recursion → iterative approaches.
Hands-on: trzy zadania na drzewo (balanced check, LCA).
Interview porównaj recursive vs iterative.
Day 47
Warm-up: graph basics.
Deep dive: graphs, BFS/DFS, Dijkstra, topological sort.
Hands-on: 2 graph problems.
Mock: whiteboard explanation grafu.
Day 48
Warm-up: DP small.
Deep dive: dynamic programming patterns (memoization, bottom-up).
Hands-on: solve subset sum, longest increasing subsequence.
Livecoding: heavy hard problem (simulate presure).
Day 49
Przegląd tygodnia: 2x mock interviews z pełnym feedbackiem. Przećwicz wyjaśnianie złożoności, edge cases i testowanie.
Sprint 8 (Tydzień 8) — Testowanie, async, performance
Cel: TDD, unit/integration/contract tests, asynchroniczne wzorce (CompletableFuture, Reactor), performance tuning i monitorowanie.
Day 50
Warm-up: prosty unit test challenge.
Deep dive: różnice unit/integration/e2e/contract tests. Mocking frameworks (Mockito), testcontainers.
Hands-on: napisz testy integracyjne dla serwisu z DB (Testcontainers).
Mock: pytania o coverage i wartość testów.
Day 51
Warm-up: asynchroniczne myślenie.
Deep dive: CompletableFuture, ExecutorService + backpressure. TLS handshake, JWT security, SecureRandom, KeyStore.
Hands-on: implementuj pipeline async (CF + exceptions handling).
Interview: jak debugować race conditions.
Day 52
Warm-up: reactive idea.
Deep dive: reaktywne programowanie — Project Reactor (Flux/Mono), kiedy stosować vs traditional threading.
Hands-on: refactor endpoint do Flux z backpressure.
Mock: pytania o hot vs cold streams.
Day 53
Warm-up: profiling mindset.
Deep dive: profiling JVM (async profiler / VisualVM), heap dumps, CPU hotspots.
Hands-on: znajdź i usuń memory leak w prostym demo.
Interview: typowe przyczyny GC pressure.
Day 54
Warm-up: load testing mental.
Deep dive: performance testing tools (JMeter, Gatling), benchmarking best practices.
Hands-on: przygotuj scenariusz load test dla endpointu i przeprowadź ramp up.
Mock: interpretacja wyników (latency, throughput).
Day 55
Warm-up: integracje.
Deep dive: REST vs gRPC, contract testing, idempotency, retries, circuit breakers.
Hands-on: implementuj idempotent POST (idempotency token) + contract tests (e.g., Pact idea).
Interview: porównaj REST/gRPC w kontekście microservices.
Day 56
Przegląd tygodnia: dokumentacja test strategy + demo asynchronicznego workflow z monitoringiem; podsumuj najlepsze praktyki.
Sprint 9 (Dni 57–60) — Ostatni Sprint: Mocki, system design, CV. Mock interviews, system design capstone, CV i soft skills
Cel: zrealizuj pełną symulację dnia rekrutacyjnego: livecoding + system design + behavior. Popraw błędy, przygotuj portfolio.
Day 57
09:00–12:00 — Livecoding 1 (60–90 min) — trudne zadanie, potem 30 min feedback.
13:00–17:00 — System design 1 (scalowalny system), 45 min prezentacja + 45 min Q&A.
17:15–17:30 — notatki.
Day 58
09:00–12:00 — Livecoding 2 (praktyka szybkości + czytelności).
13:00–17:00 — Technical deep dive: security / infra hardening checklist dla app.
17:15–17:30 — aktualizacja CV/LinkedIn bullets (technologie, achievements, metrics).
Day 59
09:00–12:00 — System design 2 (event-driven architecture / multi-region).
13:00–17:00 — Mock behavioral interview (STAR method) + techniczne pytania follow-up.
17:15–17:30 — feedback log.
Day 60
- 09:00–12:00 — Full rehearsal: Livecoding (45m) + System Design (45m).
- 13:00–16:00 — porządki: repo z przykładami, README + instrukcje uruchomienia demo serwisu.
- 16:00–17:00 — plan kolejnych 30 dni (utrzymanie skillów) i checklist do pierwszej rozmowy.
Metryki postępu (jak mierzyć)
- Algorytmy: liczba rozwiązań: cel → 40–60 zadań (mix easy/medium/hard).
- Mock interviews: min. 6 pełnych mocków (3 livecoding + 3 system design) z zapisem i feedbackiem.
- Projects: min. 2 demo-projects na GitHub (1 microservice + 1 search/DB demo).
- CV: 3 metrykalne osiągnięcia (np. „zwiększyłem throughput o X%”, „zmniejszyłem latency o Y ms”).
Wskazówki do livecoding i rozmowy technicznej
- Najpierw zrozum problem — powtórz własnymi słowami i doprecyzuj constraints (input size, memory).
- Zaproponuj prosty rozwiązanie O(n^2) jeśli trzeba, potem ulepszaj.
- Mów na głos swoje myślenie: trade-offs, edge cases, złożoność.
- Testuj przykłady ręcznie (edge cases).
- Przy system design: zacznij od wymagań funkcjonalnych i niefunkcjonalnych (QPS, latencja, SLA), potem high-level, potem komponenty, storage, skalowanie, bottlenecks, monitoring.
- Dla behavioral: używaj STAR (Situation, Task, Action, Result) i miej 4–6 historii (leadership, conflict, failure+lesson, impact, technical challenge).
Co zrobić po tych 60 dniach
- Kontynuować utrzymanie: 2–3h tygodniowo na algorytmy + 1 demo/month.
- Przygotuj cheatsheet z najczęstszymi pytaniami i krótkimi odpowiedziami (JVM tuning, common Spring configs, AWS patterns).
- Umawiaj mocki co tydzień aż do rekrutacji.
#pracait #pracbaza #java #programista15k #programowanie @Ksiega_dusz
specjalnie dla @Ksiega_dusz podział na sprinty ( ͡°( ͡° ͜ʖ( ͡° ͜ʖ ͡°)ʖ ͡°) ͡°)
Jak widzę te wszystkie tematy to mam wrażenie że otrzymuję stawkę powyżej swoich kompetencji ( ͡° ͜ʖ ͡°)