* If you didn't use FastAPI and used Starlette directly (or another tool, like Sanic, Flask, Responder, etc) you would have to implement all the data validation and serialization yourself. So, your final application would still have the same overhead as if it was built using FastAPI. And in many cases, this data validation and serialization...

            private static final long serialVersionUID = 1L;

            @Override
            public int getCrawlingThreadCount() {
                return 1; // Reduced from 2 to minimize thread overhead
            }

            @Override
            public String getIndexFieldConfigId() {
                return "config_id";
            }

            @Override

This is due to Java's use of reflection and the need to maintain a lot of metadata.

- **Size of Serialized Data:**
Java serialization tends to produce larger serialized objects because it includes class metadata and other overhead.

- **Flexibility and Control:**
Java serialization offers limited control over the serialization process, such as excluding certain fields, customizing naming conventions, and handling complex data structures more gracefully.

  /** Returns the original request that initiated this web socket. */
  fun request(): Request

  /**
   * Returns the size in bytes of all messages enqueued to be transmitted to the server. This
   * doesn't include framing overhead. If compression is enabled, uncompressed messages size
   * is used to calculate this value. It also doesn't include any bytes buffered by the operating

 * form}), the memory requirement is 8*N bytes for the copy of the dataset plus an overhead which is
 * independent of N (but depends on the quantiles being computed). When calling {@link
 * ScaleAndIndex#computeInPlace computeInPlace} (in {@linkplain ScaleAndIndexes#computeInPlace
 * either form}), only the overhead is required. The number of object allocations is independent of
 * N in both cases.
 *

        byte[] decompressed = searchHelper.gzipDecompress(compressed);

        assertEquals(testData, new String(decompressed));
        // For small strings, gzip overhead might make compressed data larger
        // So we just verify that compression/decompression works correctly
        assertNotNull(compressed);
        assertTrue(compressed.length > 0);
    }

    * Wenn Sie FastAPI nicht verwenden und stattdessen Starlette direkt (oder ein anderes Tool wie Sanic, Flask, Responder, usw.) verwenden würden, müssten Sie die gesamte Datenvalidierung und Serialisierung selbst implementieren. Ihre finale Anwendung hätte also immer noch den gleichen Overhead, als ob sie mit FastAPI erstellt worden wäre. Und in vielen Fällen...

   *       userspace buffer (byte[] or ByteBuffer), then copies them from that buffer into the
   *       destination channel.
   * </ol>
   *
   * This value is intended to be large enough to make the overhead of system calls negligible,
   * without being so large that it causes problems for systems with atypical memory management if
   * approaches 2 or 3 are used.
   */
  private static final int ZERO_COPY_CHUNK_SIZE = 512 * 1024;

            documents.add(doc);
        }

        final String result = client.testBuildContext(documents);
        assertTrue(result.length() <= 300); // some overhead from header text
    }

    // ========== P6: generateSummaryResponse size limit and HTML stripping tests ==========

    @Test
    public void test_generateSummaryResponse_stripsHtmlFromContent() {

// The threshold of 8 bytes balances initialization cost against per-byte
// search cost, performing well across all charset sizes.
//
// More complex heuristics (e.g., different thresholds per charset size)
// add branching overhead that eats away any theoretical improvements.
func shouldUseASCIISet(bufLen int) bool {
	return bufLen > 8
}

// containsRune is a simplified version of strings.ContainsRune