Wat is grooming en hoe verschilt het van planning?
Golang
Welke positie overweeg je nu voor jezelf, wat zou interessant zijn?
Welk werkformaat overweegt u?
Hoe vergelijk je elementen in een kaart? Hoe controleer je of twee kaarten overeenkomen?
Wat zijn je financiële verwachtingen?
/* Er is een applicatie met een microservices-architectuur. Een microservice kan worden geabstraheerd met behulp van de Backend-interface. Om toegang te krijgen tot een exemplaar van de microservice, kan men het type BackendImpl gebruiken, dat al geïmplementeerd is. Voor elke microservice zijn er tientallen exemplaren in uitvoering, elk bereikbaar via zijn eigen adres addr. Echter, de individuele exemplaren van de microservice zijn niet betrouwbaar: ze kunnen crashen, niet beschikbaar zijn of overbelast zijn. Daarom moet je het type Balancer implementeren, dat ook de Backend-interface implementeert en load balancing aan de clientzijde uitvoert tussen de microservice-exemplaren, door telkens het **minimaal belaste** exemplaar te kiezen. */ type Request interface{} type Response interface{} type Backend interface { Invoke(ctx context.Context, req Request) (Response, error) } var _ Backend = &BackendImpl{} // addr bevat ip:poort van een specifiek exemplaar func NewBackend(addr string) *BackendImpl type Balancer struct { //TODO } var _ Backend = &Balancer{} // addrs bevatten de adressen van alle gebalanceerde exemplaren func NewBalancer(addrs []string) *Balancer { //TODO }
Wat is de beperking van een semafoor en een gebufferde kanaal als oplossingen om parallelle verzoeken te beperken?
Taak: er is een service met een beperking van 5 parallelle verzoeken naar LLM. Bij de 6e verzoek krijgt men een 429. Hoe los je dit probleem conceptueel op?
/* Er wordt een tekenreeks gegeven. Vind het aantal paren indices i en j (i <= j), tussen welke geen herhaalde tekens zijn. Voor de string "aba" is het antwoord 5: kunnen ASCII zijn [0, 0] ("a") [0, 1] ("ab") [1, 1] ("b") [1, 2] ("ba") [2, 2] ("a") */
Wat weet u over het MultiTrack-programma van Yandex?
type Response interface{} type Backend interface { Invoke(ctx context.Context, req Request) (Response, error) } var _ Backend = &BackendImpl{} // addr bevat ip:poort van een specifiek exemplaar func NewBackend(addr string) *BackendImpl type Balancer struct { // TODO backends []*BackendImpl index int mu sync.Mutex } var _ Backend = &Balancer{} func (b *Balancer) Invoke(ctx context.Context, req Request) (Response, error) { als len(b.backends) == 0 { return nil, fmt.Errorf("Aantal backends in slice is 0") } b.mu.Lock() index := b.index als b.index + 1 == len(b.backends) { b.index = 0 index = 0 } b.mu.Unlock() resp, err := b.backends[index].Invoke(ctx, req) return resp, err } // addrs bevat adressen van alle gebalanceerde exemplaren func NewBalancer(addrs []string) *Balancer { // TODO backends := make([]*BackendImpl, len(addrs))
Hoe verschijnt een functie en bereikt deze de verkoop: planning, ontwikkeling, tests, code review, uitrol, rollback?
Is er een deadline?
Hoe heb je de LLM geïntegreerd in een project met debiteuren? Vertel het in het algemeen.
/** :-))) :-(( "ab :-)" = "ab " "ab :-)))" = "ab " "ab :-)))(" = "ab (" "ab ):-)" = "ab )" ":-)" = "" **/ func deleteP(str string) string { }
/* Er wordt een tekenreeks gegeven. Vind het aantal paren indices i en j (i <= j), tussen welke geen herhaalde tekens zijn. Voor de string "aba" is het antwoord 5: [0, 0] ("a") [0, 1] ("ab") [1, 1] ("b") [1, 2] ("ba") [2, 2] ("a") */
type Balancer struct { // TODO backends []*BackendImpl index int mu sync.Mutex N int K time.Duration } var _ Backend = &Balancer{} func (b *Balancer) Invoke(ctx context.Context, req Request) (Response, error) { if len(b.backends) == 0 { return nil, fmt.Errorf("Aantal backends in slice 0") } b.mu.Lock() index := b.index for b.backends[index].banned { b.index = (b.index + 1) % len(b.backends) index = b.index } b.index = (b.index + 1) % len(b.backends) b.mu.Unlock() backend := b.backends[index] resp, err := backend.Backend.Invoke(ctx, req) if err != nil && backend.countErrors < b.N { backend.mu.Lock() backend.countErrors += 1 if backend.countErrors == b.N { backend.banned = true go func() { time.Sleep(b.K) backend.mu.Lock() defer backend.mu.Unlock() backend.banned = false backend.countErrors = 0 }() } backend.mu.Unlock() } return resp, err } // addrs bevatten de adressen van alle gebalanceerde instanties func NewBalancer(addrs []string) *Balancer { // TODO backends := make([]*BackendImplF, len(addrs)) for _, addr := range addrs { implF := BackendImplF{ Backend: NewBackend(addr), } backends = append(backends, &implF) } }
Heb je ervaring met het ondersteunen of ontwikkelen van gedistribueerde systemen?
Hoe snel zal een lineaire doorzoeking van alle backends werken bij hoge RPS (bijvoorbeeld 30.000 RPS en 10 backends)?
Hoe hebt u de tests en verificatie van de correctheid van de uitgevoerde verzoeken uitgevoerd?