Code Reviews — Find the Bug¶

 // chunk splits data into windows of size n for batch upload.
 func chunk(data []byte, n int) [][]byte {
     var out [][]byte
-    for i := 0; i < len(data); i += n {
-        end := i + n
-        if end > len(data) {
-            end = len(data)
-        }
-        out = append(out, data[i:end])
-    }
+    for i := 0; i <= len(data); i += n {
+        end := i + n
+        if end > len(data) {
+            end = len(data)
+        }
+        out = append(out, data[i:end])
+    }
     return out
 }

-def retry(fn, attempts=3, raise_on_exhaust=False):
+def retry(fn, attempts=3, raise_on_exhaust=True):
     last_exc = None
     for _ in range(attempts):
         try:
             return fn()
         except Exception as exc:
             last_exc = exc
     if raise_on_exhaust:
         raise last_exc
     return None


 # caller shown in the diff (looks fine — it handles the exception):
 def fetch_config():
     return retry(lambda: http_get("/config"), attempts=5)

 func loadSettings(path string) (*Settings, error) {
-    raw, err := os.ReadFile(path)
-    if err != nil {
-        return nil, fmt.Errorf("read config: %w", err)
-    }
-    var s Settings
-    if err := json.Unmarshal(raw, &s); err != nil {
-        return nil, fmt.Errorf("parse config: %w", err)
-    }
-    return &s, nil
+    raw, _ := os.ReadFile(path)
+    var s Settings
+    json.Unmarshal(raw, &s)
+    return &s, nil
 }

 public class AccessControl {
-    public boolean canAccess(User user, Resource resource) {
-        if (resource.getOwnerId().equals(user.getId())) return true;
-        return acl.isGranted(resource.getId(), user.getId());
-    }
+    public boolean canAccess(User user, Resource resource) {
+        if (resource.getOwnerId().equals(user.getId())) return true;
+        return checkAcl(user, resource);
+    }
+
+    private boolean checkAcl(User user, Resource resource) {
+        // acl.isGranted(resourceId, userId)
+        return acl.isGranted(user.getId(), resource.getId());
+    }
 }

--- a/discount.py
+++ b/discount.py
 def apply_discount(price, pct):
-    if not (0 <= pct <= 100):
-        raise ValueError("pct must be between 0 and 100")
-    return round(price * (1 - pct / 100), 2)
+    return round(price * (1 - pct / 100), 2)

--- a/test_discount.py
+++ b/test_discount.py
 def test_apply_discount_basic():
     assert apply_discount(100, 20) == 80.0

-def test_apply_discount_rejects_out_of_range():
-    with pytest.raises(ValueError):
-        apply_discount(100, 150)
+def test_apply_discount_handles_large_pct():
+    # 150% off → negative, that's acceptable for now
+    assert apply_discount(100, 150) == -50.0

 func (c *Counter) IncrementAndSnapshot() map[string]int {
     c.mu.Lock()
-    c.counts[c.key]++
-    snapshot := make(map[string]int, len(c.counts))
-    for k, v := range c.counts {
-        snapshot[k] = v
-    }
-    c.mu.Unlock()
+    c.counts[c.key]++
+    c.mu.Unlock()
+    snapshot := make(map[string]int, len(c.counts))
+    for k, v := range c.counts {
+        snapshot[k] = v
+    }
     return snapshot
 }

 public void notifyAll(List<User> users, String message) {
     for (User user : users) {
-        notifier.send(user, message);
+        try {
+            notifier.send(user, message);
+        } catch (Exception e) {
+            // continue with the rest
+        }
     }
 }

+def render_results_header(query: str, count: int) -> str:
+    return (
+        '<div class="results-header">'
+        f'<h2>Results for "{query}"</h2>'
+        f'<span class="count">{count} matches</span>'
+        '</div>'
+    )

+    raw_query = request.args.get("q", "")
+    results = search_index(raw_query)
+    header_html = render_results_header(raw_query, len(results))
+    return render_template_string(PAGE_TEMPLATE, header=Markup(header_html), body=...)

 func activeUserIDs(db *sql.DB) ([]int, error) {
-    rows, err := db.Query("SELECT id FROM users WHERE active = true")
-    if err != nil {
-        return nil, err
-    }
-    defer rows.Close()
-    var ids []int
-    for rows.Next() {
-        var id int
-        if err := rows.Scan(&id); err != nil {
-            return nil, err
-        }
-        ids = append(ids, id)
-    }
-    return ids, rows.Err()
+    rows, err := db.Query("SELECT id FROM users WHERE active = true")
+    if err != nil {
+        return nil, err
+    }
+    return scanIDs(rows)
 }
+
+func scanIDs(rows *sql.Rows) ([]int, error) {
+    var ids []int
+    for rows.Next() {
+        var id int
+        if err := rows.Scan(&id); err != nil {
+            return nil, err
+        }
+        ids = append(ids, id)
+    }
+    return ids, rows.Err()
+}

 public void processPayment(Payment payment) {
-    if (!payment.isAuthorized()) {
-        throw new IllegalStateException("payment not authorized");
-    }
-    gateway.capture(payment);
+    boolean unauthorized = payment.isAuthorized();
+    if (unauthorized) {
+        throw new IllegalStateException("payment not authorized");
+    }
+    gateway.capture(payment);
 }

-def reindex(documents, index):
-    index.clear()
-    for doc in documents:
-        index.add(doc.id, doc.tokens())
+def reindex(documents, index, since):
+    for doc in documents:
+        if doc.updated_at > since:
+            index.add(doc.id, doc.tokens())

 func applyCredit(account *Account, credit Money) error {
-    if account != nil {
-        if account.Status == Active {
-            account.Balance = account.Balance.Add(credit)
-            account.LastCreditAt = time.Now()
-        }
-    }
-    return audit.Record(account, credit)
+    if account == nil || account.Status != Active {
+        return nil
+    }
+    account.Balance = account.Balance.Add(credit)
+    account.LastCreditAt = time.Now()
+    return audit.Record(account, credit)
}