Słowo „localhost” przez miesiące spowalniało moją wyszukiwarkę wiedzy

Laptop z kartą graficzną RTX 5070 Ti przerabiał trzydzieści plików w pięć, sześć minut. Na sześciu firmowych dyskach Google czekało ich 21 678, razem 10,4 GB do przeczytania, więc rachunek wyszedł na około 60 godzin ciągłej pracy komputera, na którym jednocześnie pracuję. W małej firmie, w której jeden laptop jest stanowiskiem właściciela i maszyną do automatów, to dwie i pół doby wyjęte z normalnej pracy. Moja pierwsza decyzja tamtego wieczoru dotyczyła mocy: pozwoliłem indeksowaniu brać do 90% procesora i pamięci zamiast dotychczasowych 80%.

Trzydzieści cztery minuty później okazało się, że karta, procesor i pamięć przez większość czasu stały bezczynnie. Każde z tysięcy zapytań do lokalnego modelu, który zamienia tekst na wektory, zaczynało się od mniej więcej dwóch sekund czekania na połączenie, które nie mogło dojść do skutku. Program pukał pod adres „localhost”, Windows próbował go najpierw w wersji IPv6, a model słuchał wyłącznie pod 127.0.0.1. Ten sam pomiar z adresem wpisanym cyframi dał 0,015 sekundy.

Spis treści

Trzydzieści plików na pięć minut

Wyszukiwarka wiedzy, o której mowa, działa u mnie od wiosny. Zadaję jej pytanie zwykłym zdaniem, a ona przeszukuje notatki, oferty, maile i dokumenty firmy, po czym podaje fragmenty, z których odpowiedź da się złożyć. Jak zbudowałem własną wyszukiwarkę wiedzy o klientach i co mi dała w codziennej pracy, opisałem w kwietniu. Tutaj ważny jest jeden szczegół techniczny. Żeby wyszukiwarka mogła cokolwiek znaleźć, każdy dokument trzeba najpierw pociąć na kawałki i każdy kawałek zamienić na wektor, czyli ciąg liczb opisujący jego znaczenie. Robi to mały model językowy uruchomiony lokalnie, na moim laptopie, przez program Ollama. Nic z tych dokumentów nie wychodzi do zewnętrznej chmury.

Na początku października postanowiłem, że indeks ma objąć wszystko: dyski współdzielone, pocztę, notatki zespołu, serwery. Pierwsze w kolejce były dyski Google, 21 678 plików po odrzuceniu wideo, obrazów, archiwów i wszystkiego powyżej 15 MB. Pierwsza partia ruszyła przed 22:00 i przeszła bez błędu: 30 plików, 82 kawałki tekstu, szczytowe obciążenie procesora 21%. Potem przyszła druga partia, trzecia, i tempo ustaliło się na mniej więcej trzydziestu plikach co pięć, sześć minut.

Do tego doszedł bezpiecznik, który sam kiedyś wymyśliłem. Indeksowanie pauzuje, gdy procesor albo pamięć przekraczają ustalony próg, bo poprzedni laptop przy takim obciążeniu się przegrzewał i wyłączał. Pamięć nowego laptopa stała na 80 - 81% bez żadnego indeksowania, więc bezpiecznik zatrzymywał pracę co chwilę. Z tych dwóch liczb, tempa i liczby plików, wyszło mi 60 godzin.

Był jeszcze trzeci objaw, do którego zdążyłem przywyknąć. Starszy indeks, ten obejmujący repozytorium z notatkami i kodem firmy, od miesięcy nie nadążał za tym, co do repozytorium przybywało. Tego wieczoru znał 2709 plików z 5069, czyli nieco ponad połowę. Wyszukiwarka odpowiadała na pytania, tylko o części dokumentów po prostu nie wiedziała, a ja tłumaczyłem to sobie słabym sprzętem i tym, że indeks dogania zaległości nocami.

Pierwszy odruch: więcej mocy

Historia ze sprzętem zaczęła się we wrześniu. Na poprzednim laptopie z procesorem sprzed kilku lat pełne przeliczenie archiwum z dysku sieciowego wbijało procesor na 94%, a komputer potrafił się przy tym wyłączyć z przegrzania. Zmierzyłem, że winny jest właśnie model liczący wektory, bo zajmuje wszystkie rdzenie, i ograniczyłem go do trzech z ośmiu. Pomogło na chwilę. Model uruchamia dodatkowy proces roboczy dopiero w trakcie liczenia i ten proces omijał moje ograniczenie, więc nawet przy bezczynnym laptopie widziałem skoki do 98%. Zapisałem wtedy wniosek, który wydawał się rozsądny: ten komputer jest na to za słaby, ciężkie indeksowanie trzeba przenieść na serwer z kartą graficzną.

Na początku października przesiadłem się na nowy laptop i przeniosłem na niego wszystkie automaty, co samo w sobie było osobną przygodą, opisaną w tekście o tym, jak przenieść firmowy komputer bez gubienia automatów. Nowy ma 16 rdzeni, 31,5 GB pamięci i kartę graficzną z 12 GB własnej pamięci. Indeksowanie na nim było szybsze niż na starym, ale nie o tyle, o ile różnią się te dwie maszyny. Przy karcie, która potrafi liczyć ponad sto kawałków tekstu na sekundę, trzydzieści plików w pięć minut powinno mnie zaniepokoić od razu.

Nie zaniepokoiło. Patrzyłem na pamięć zajętą w 81% i widziałem w niej wyjaśnienie. O 23:01 podjąłem decyzję: na tym laptopie indeksowanie może brać do 90% procesora i 90% pamięci, model dostaje sześć rdzeni zamiast trzech, a żeby nie powtórzyć wrześniowych wyłączeń, dochodzi trzeci bezpiecznik, temperatura. Od 90°C partia czeka, aż procesor zejdzie poniżej 80°C. Wszystko to miało sens jako ochrona sprzętu. Jako odpowiedź na pytanie, dlaczego jest wolno, było strzałem w ciemno, bo nikt jeszcze nie sprawdził, na co schodzi czas jednej partii.

W głowie miałem już następny krok. Serwer z mocną kartą graficzną i tak był w planach, a ten wieczór dokładał do niego argumentów. Gdyby nie pomiar, który przyszedł pół godziny później, wydałbym pieniądze na rozwiązanie problemu, którego sprzęt nie powodował.

Gdzie podziały się dwie sekundy?

Pomiar był najprostszy z możliwych: jedno zapytanie do modelu, zmierzone od wysłania do odpowiedzi. Około dwóch sekund. Potem to samo zapytanie z adresem 127.0.0.1 zamiast słowa „localhost”: 0,015 sekundy. Model, karta i tekst się nie zmieniły, zmienił się tylko zapis adresu.

Dwa przyciski w jednym domofonie

Słowo „localhost” oznacza „ten komputer”. Problem w tym, że ten komputer ma dwa adresy pętli zwrotnej: starszy, IPv4, czyli 127.0.0.1, i nowszy, IPv6, zapisywany jako ::1. Działa to jak domofon z dwoma przyciskami do tego samego mieszkania, przy czym lokator słyszy tylko jeden dzwonek. Windows z zasady woli IPv6, co Microsoft opisuje w swojej dokumentacji wprost: domyślnie system faworyzuje adresy IPv6. Naciska więc najpierw przycisk ::1. Ollama w domyślnych ustawieniach nasłuchuje pod 127.0.0.1, port 11434, więc pod ::1 nikt nie odbiera.

Dlaczego Windows czeka, a Linux nie

Na Linuksie próba połączenia z portem, pod którym nikt nie nasłuchuje, kończy się natychmiastową odmową i program od razu przechodzi do drugiego adresu. Windows dostaje tę samą odmowę, ale traktuje ją jak usterkę, która może zaraz minąć, i ponawia próbę jeszcze kilka razy. Daniel Stenberg, autor programu curl, opisał to zachowanie w 2024 roku: system powtarza próbę do trzech dodatkowych razy, a na samym komputerze potrafi to zająć kilka sekund. U mnie wychodziło około dwóch.

Python, w którym napisane są moje indeksery, robi przy tym dokładnie to, co obiecuje. Funkcja zestawiająca połączenie próbuje kolejno wszystkich adresów, które zwrócił system, aż któryś zadziała. Pierwszy na liście był ::1, drugi 127.0.0.1. Połączenie zawsze się udawało, tylko z opóźnieniem, i dlatego nigdzie nie pojawił się żaden błąd ani ostrzeżenie.

Dlaczego nikt tego nie zauważył

Przy pojedynczym pytaniu do wyszukiwarki dwie sekundy giną w tle. Wpisuję pytanie, czekam, aż model przeczyta znalezione fragmenty i ułoży odpowiedź, i całość trwa kilka sekund. Gdyby ktoś mi powiedział, że dwie z nich to pukanie do pustych drzwi, nie uwierzyłbym, bo przecież „AI myśli”. Przeglądarka też niczego nie zdradza, bo nowoczesne przeglądarki próbują obu adresów równolegle i biorą ten, który odpowie pierwszy. Kłopot pokazuje się dopiero w programie, który robi to samo tysiące razy pod rząd.

Dwie sekundy razy ćwierć miliona

Stare indeksery wysyłały do modelu osobne zapytanie dla każdego kawałka tekstu. Każde zapytanie otwierało nowe połączenie, a każde nowe połączenie zaczynało się od wizyty pod ::1. Pierwsza partia z tamtego wieczoru miała 82 kawałki, czyli same próby połączenia zjadały w niej blisko trzy minuty. Z pięciu, sześciu minut, jakie trwała partia razem z pauzami bezpiecznika, ponad połowa przypadała na czekanie, w którym nie liczyło się nic.

Policzyłem też wersję dla całości. Sześć dysków dało ostatecznie około 250 tysięcy kawałków. Przy dwóch sekundach na kawałek to 500 tysięcy sekund, czyli mniej więcej 139 godzin, prawie sześć dób samego otwierania połączeń. To mój rachunek, przy założeniu, że wszystko szłoby starą metodą, po jednym zapytaniu na kawałek. Szacunek 60 godzin z pierwszej godziny pracy był więc raczej optymistyczny, bo pierwsze pliki na dysku firmowym były krótkie.

Najbardziej boli mnie repozytorium. Jego indeks miesiącami odrabiał zaległości po kilkadziesiąt plików na przebieg i nigdy ich nie odrobił. Nie wiem dokładnie, ile z tych miesięcy przypada na adres, a ile na słaby procesor starego laptopa, bo we wrześniu niczego takiego nie zmierzyłem. Mierzyłem wtedy temperaturę i obciążenie procesora, czyli to, co widać w menedżerze zadań. Czasu, który program spędza na czekaniu, menedżer zadań nie pokazuje wcale, bo czekający proces nie zużywa ani procesora, ani karty.

Jedna zmiana w czterech programach

Sama poprawka sprowadziła się do zamiany jednego słowa na cztery liczby. Adres „localhost” siedział w czterech miejscach: w nowym indekserze dysków, w starym indekserze repozytorium, w indekserze archiwum z dysku sieciowego i w samej wyszukiwarce, z której korzystają agenci. Przed zmianą każdy z tych plików skopiowałem obok, żeby dało się wrócić do stanu sprzed. W każdym obok adresu został komentarz z datą i wyjaśnieniem, dlaczego tam nie ma słowa „localhost”, bo za pół roku ktoś, może ja, uzna liczby za nieeleganckie i „poprawi” je z powrotem.

Przy okazji zmieniłem sposób rozmowy z modelem. Nowszy punkt API Ollamy, opisany w dokumentacji jako /api/embed, przyjmuje w jednym zapytaniu całą listę tekstów, więc indekser wysyła teraz kawałki paczkami po 32 zamiast pojedynczo. Zanim to puściłem na wszystkie dyski, porównałem wektory z obu metod dla tych samych kawałków. Wyszły identyczne, więc nic, co było już w indeksie, nie wymagało przeliczenia.

Efekt był widoczny w pierwszej partii po zmianie. Trzydzieści plików zajmowało 35 - 45 sekund zamiast pięciu, sześciu minut. Jedno uruchomienie indeksera, które ma budżet czterech minut, przerabiało teraz kilka partii, około 180 plików na pięć minut. Procesor nie przekraczał 30%, temperatura 68°C. Progi 90%, które ustawiłem pół godziny wcześniej, przestały mieć jakiekolwiek znaczenie, bo obciążenie nawet się do nich nie zbliżało. O 23:50 dysk z dokumentami firmy miał 389 plików z 3993, 4952 kawałki w indeksie i zero błędów.

Drugi hamulec siedział w bezpieczniku

Kwadrans po północy zapytałem, czy da się to jeszcze podkręcić. Zamiast zgadywać, rozpisaliśmy czas jednej partii na etapy. Pomiar dla 40 plików: pobranie z dysku 0,13 sekundy, wyciągnięcie tekstu 1,33 sekundy, policzenie wektorów 3,41 sekundy, zapis 0,5 - 1,5 sekundy. Razem około sześciu sekund pracy. Partia trwała tymczasem 35 - 45 sekund.

Brakujące pół minuty znalazło się w moim własnym bezpieczniku. Przed każdym plikiem indekser sprawdzał obciążenie procesora, żeby w razie potrzeby się zatrzymać, a sam pomiar polegał na obserwowaniu procesora przez sekundę. Trzydzieści plików w partii dawało trzydzieści sekund patrzenia na procesor, który w tym czasie nic nie robił, bo czekał na wynik pomiaru. Mechanizm, który miał chronić laptopa przed przegrzaniem, był najwolniejszym elementem całego procesu.

Zmian było kilka i każdą dało się sprawdzić osobno. Pomiar obciążenia idzie teraz raz na partię i bez czekania. Pliki czyta sześć wątków naraz, wektory liczą się paczkami po 64, bo przy tylu kawałkach karta osiąga swój sufit, około 100 - 130 kawałków na sekundę. Zapis indeksu na dysk idzie co minutę, a nie po każdym pliku, a lista plików do przejrzenia jest pamiętana przez trzy godziny, zamiast pobierać ją od nowa przy każdym uruchomieniu. Doszła też blokada, która nie pozwala wystartować drugiej kopii indeksera, gdy pierwsza jeszcze pracuje.

Po tych zmianach jedna sesja przerobiła 1264 pliki w 167 sekund. Szczyt procesora 46%, pamięć 89%, temperatura 79 - 82°C. Te liczby są wyższe niż po pierwszej poprawce i tak ma być, bo sprzęt wreszcie pracował, zamiast czekać. O 00:41 cały dysk firmowy był w indeksie: 3993 pliki, 74 271 kawałków. Od pierwszej partii minęły niecałe trzy godziny, z czego zdecydowana większość pracy zmieściła się w ostatniej godzinie.

Trzy wywrotki po północy

Przyspieszenie nie poszło gładko i ta część jest na moje konto. Po włączeniu sześciu wątków czytających pliki indekser zaczął się wywracać. Między 00:26 a 00:38 trzy uruchomienia skończyły się zamknięciem procesu przez system, z kodami błędów, które niczego nie tłumaczyły. Przyczyną była biblioteka do czytania PDF-ów. Jej dokumentacja mówi wprost, że PyMuPDF nie obsługuje pracy w wielu wątkach i że próba może skończyć się awarią samego Pythona. Przeczytałbym to w dwie minuty, gdybym zajrzał do dokumentacji przed włączeniem wątków, a nie po trzeciej wywrotce.

Naprawa była prosta: PDF-y czyta jeden wątek naraz, pozostałe formaty dalej idą równolegle. Lekcja jest szersza niż ta jedna biblioteka. Programy, które w środku korzystają z kodu napisanego w C, jak czytniki PDF, biblioteki graficzne czy sterowniki baz danych, często nie znoszą wielu wątków, a Python niczego przed tym nie ostrzega. Albo czyta się je w jednym wątku, albo w osobnych procesach.

Tej samej nocy podjąłem jeszcze jedną decyzję, której nikt mi nie zlecał. Pełne arkusze kalkulacyjne dawały około 115 kawałków na plik, a większość z nich to były wiersze liczb, których wyszukiwarka i tak nie umie sensownie odnaleźć po znaczeniu. Arkusze i pliki CSV indeksuję teraz do 20 tysięcy znaków. Zapisałem to od razu jako osobną decyzję do sprawdzenia, bo za którymś razem ktoś zapyta o pozycję z setnego wiersza cennika i wtedy trzeba będzie wiedzieć, dlaczego jej nie ma.

Kolejność, w jakiej dziś szukam przyczyny

Z tamtego wieczoru została mi kolejność kroków, którą stosuję przy każdym automacie, o którym ktoś mówi „po prostu jest wolny”, zanim ktokolwiek zacznie rozmawiać o nowym serwerze.

1. Rozpisz czas na etapy

Jedna liczba dla całego procesu, „partia trwa pięć minut”, nic nie mówi. Pobranie, przetworzenie, wysłanie, zapis, czekanie na odpowiedź, każdy etap mierzony osobno. Gdy suma etapów nie zgadza się z czasem całości, brakująca część jest najciekawsza, bo tam zwykle siedzi czekanie, którego nikt nie zaplanował.

2. Zmierz jedno wywołanie w izolacji

Jedno zapytanie, bez reszty programu, najpierw pod adresem z nazwą, potem pod adresem z cyframi. W PowerShellu wystarczy `Measure-Command { Invoke-RestMethod http://localhost:11434/api/version }`, a potem ta sama linijka z `127.0.0.1`. Różnica rzędu dwóch sekund mówi wszystko. Różnica rzędu milisekund oznacza, że trzeba szukać gdzie indziej.

3. Sprawdź, kto słucha i pod jakim adresem

Polecenie `netstat -ano | findstr 11434` pokazuje, pod którym adresem usługa naprawdę nasłuchuje. Jeśli widzisz wyłącznie `127.0.0.1:11434`, każdy program, który woła „localhost” i próbuje najpierw IPv6, będzie czekał. Ten sam test działa dla lokalnej bazy danych, kontenera Dockera, narzędzia do automatyzacji czy serwera testowego aplikacji.

4. Pomnóż przez liczbę powtórzeń

Dwie sekundy na kliknięcie nikomu nie przeszkadzają. Dwie sekundy razy 250 tysięcy kawałków to prawie sześć dób. Każde opóźnienie trzeba przeliczyć przez to, ile razy proces je powtarza, zanim się uzna, że jest nieistotne.

5. Podejrzyj własne zabezpieczenia

Pauzy, limity, ponowienia, pomiary kontrolne. Każdy z tych mechanizmów ktoś wstawił w dobrej wierze i każdy kosztuje czas. U mnie bezpiecznik przed przegrzaniem zjadał trzy czwarte każdej partii. Warto zmierzyć, ile kosztuje zabezpieczenie, zanim się je wyłączy, bo zwykle wystarczy je uruchamiać rzadziej.

6. Dopiero teraz sprzęt

Jeśli po pięciu poprzednich krokach procesor albo karta pracują na pełnych obrotach i nadal jest za wolno, wtedy sprzęt rzeczywiście jest ograniczeniem i można liczyć, ile kosztuje mocniejszy.

Kiedy mocniejszy sprzęt naprawdę pomaga?

Nie chcę, żeby z tego tekstu wyszło, że sprzęt nigdy nie ma znaczenia. Wrześniowe przegrzewanie starego laptopa było prawdziwe: liczenie wektorów na procesorze zamiast na karcie graficznej wbijało go na 94% i nie było w tym żadnego ukrytego czekania. Tam mocniejsza maszyna była potrzebna i nowy laptop liczy wektory na karcie graficznej, której stary nie miał. O tym, kiedy własny model na własnym sprzęcie ma w ogóle sens dla małej firmy, pisałem już przy teście modelu na naszym serwerze, i tamte wnioski nadal obowiązują.

Ciekawsze jest to, co pokazała noc z poprawkami. Gdy znikło czekanie na połączenie i na bezpiecznik, kolejnym ograniczeniem okazała się sama karta, ze swoimi 100 - 130 kawałkami na sekundę. Ćwierć miliona kawałków przy takim tempie to około 40 minut czystego liczenia. Całość trwała jednak kilka dni, bo przy dysku z dokumentami klientów ograniczeniem stało się pobieranie plików z chmury. Tempo spadło tam do około 450 plików na pięć minut i zależało od tego, jak szybko Google oddawał kolejne dokumenty, a nie od tego, co mam w laptopie.

Gdybym w październiku kupił serwer z dwa razy mocniejszą kartą, czekanie na połączenie zostałoby takie samo, bo problem siedział w adresie. Pobieranie z chmury też by się nie skróciło, bo zależało od łącza i od Google. Szybciej szłaby tylko ta część, która i tak zajmowała najmniej czasu.

22 660 plików i jeden wyjazd

Rano po tej nocy musiałem wyjechać i zabrać laptopa ze sobą. O 7:59 indekser zakończył ostatni przebieg, zapisał stan i został wyłączony. Dysk firmowy był kompletny, dysk z dokumentami klientów miał 5005 plików z 13 614, a reszta czekała. Po powrocie wystarczyło go włączyć z powrotem, bo indekser sam ciągnie od miejsca, w którym skończył. Przy okazji wyjazdu doszedł limit 60 sekund na pobranie jednego pliku, bo pojedyncze dokumenty z chmury potrafiły zawiesić całą partię.

Stan z 10 października: wszystkie sześć dysków w indeksie, 22 660 plików i około 250 tysięcy kawałków. Do tego 425 plików, których nie dało się odczytać, i 530 w formatach, których indekser jeszcze nie obsługuje, głównie stare dokumenty Worda i pliki RTF. Szacunek z pierwszego wieczoru mówił o 60 godzinach ciągłej pracy laptopa. Rzeczywista praca, liczona bez przerwy na wyjazd i bez czekania na chmurę, zamknęła się w kilku godzinach, a następnym etapem stała się poczta.

W kodzie wszystkich czterech programów zostało 127.0.0.1 z komentarzem. Na liście lokalnych narzędzi, które otwieram w przeglądarce, „localhost” wciąż występuje kilka razy i tam może zostać, bo przeglądarka i tak próbuje obu adresów naraz. Zmieniam go tylko w programach, które pytają o coś tysiące razy.

Najczęstsze pytania

Dlaczego localhost działa wolniej niż 127.0.0.1 na Windows?

Windows domyślnie woli IPv6, więc „localhost” najpierw prowadzi pod adres ::1. Jeśli usługa nasłuchuje tylko pod 127.0.0.1, system dostaje odmowę, ale zamiast od razu przejść dalej, ponawia próbę kilka razy. Dopiero potem program łączy się przez IPv4. U mnie kosztowało to około dwóch sekund na każde nowe połączenie.

Czy wyłączyć IPv6, żeby przyspieszyć localhost?

Microsoft tego nie zaleca, bo część składników systemu korzysta z IPv6 wewnętrznie. Najprościej wpisać w programie adres 127.0.0.1 zamiast nazwy albo uruchomić usługę tak, żeby nasłuchiwała pod oboma adresami. Jeśli zmiana ma objąć cały komputer, dokumentacja Microsoftu opisuje ustawienie preferencji IPv4 zamiast wyłączania IPv6.

Jak sprawdzić, pod jakim adresem nasłuchuje Ollama?

W wierszu poleceń Windows wpisz `netstat -ano | findstr 11434`. Wynik `127.0.0.1:11434` oznacza, że Ollama słucha tylko przez IPv4, co jest jej ustawieniem domyślnym. Adres nasłuchu zmienia zmienna środowiskowa OLLAMA_HOST, opisana w dokumentacji Ollamy.

Czy do lokalnej wyszukiwarki wiedzy potrzebna jest karta graficzna?

Przy kilkuset dokumentach wystarczy zwykły procesor, liczenie potrwa dłużej, ale się zmieści w nocy. Przy dziesiątkach tysięcy plików karta graficzna skraca liczenie wektorów z dni do godzin. Zanim jednak kupisz sprzęt, zmierz, ile czasu proces naprawdę liczy, a ile czeka, bo u mnie czekanie przeważało.

Źródła

Słownik pojęć

  • localhost - nazwa oznaczająca „ten komputer”; system zamienia ją na adres pętli zwrotnej, w IPv4 127.0.0.1, w IPv6 ::1.
  • IPv4 i IPv6 - dwie wersje protokołu adresowania w sieci; IPv6 jest nowsza i Windows domyślnie próbuje jej najpierw.
  • Port - numer „drzwi”, pod którymi usługa na komputerze przyjmuje połączenia; Ollama domyślnie używa portu 11434.
  • Wektor (embedding) - ciąg liczb opisujący znaczenie fragmentu tekstu; wyszukiwarka porównuje wektory, żeby znaleźć fragmenty podobne do pytania.
  • Indeks - zbiór wektorów wszystkich kawałków dokumentów, przeszukiwany przy każdym pytaniu.
  • Ollama - darmowy program do uruchamiania modeli językowych na własnym komputerze.
  • Wątek - jedna z kilku równoległych ścieżek pracy w obrębie tego samego programu.
  • Happy Eyeballs - metoda, w której program próbuje połączeń przez IPv6 i IPv4 równolegle i bierze to, które zadziała pierwsze; stosują ją przeglądarki.

Pytanie, które warto zadać przy następnym „za wolno”

Który proces w twojej firmie od dawna uchodzi za „po prostu wolny” i czy ktoś kiedyś rozpisał jego czas na etapy, zanim padła propozycja nowego sprzętu? Odpowiedź możesz przysłać na [email protected]. Rozmowę o jednym takim procesie zacząłbym od tego samego rozpisania czasu, a to, jak wygląda dalsza praca przy automatyzacji, opisałem na stronie współpracy.

✓ Sprawdzone na
własnej firmie
cybulski.ai JC
You've successfully subscribed to cybulski.ai
Great! Next, complete checkout for full access to cybulski.ai
Welcome back! You've successfully signed in.
Unable to sign you in. Please try again.
Success! Your account is fully activated, you now have access to all content.
Error! Stripe checkout failed.
Success! Your billing info is updated.
Error! Billing info update failed.