Analyzed URL
https://www.jeronimo.dev/
AI-Ready Score
76
/ B
Good
out of 100
Token Savings
HTML tokens
3880
Markdown tokens
892
Savings
77%
Score Breakdown
Semantic HTML
91/100
Content Efficiency
86/100
AI Discoverability
50/100
Structured Data
67/100
Accessibility
93/100
Your site doesn't have an llms.txt file. This is the emerging standard for helping AI agents understand your site structure.
How to implement
Create an /llms.txt file following the llmstxt.org specification. Include a site description and links to your key pages.
Your site doesn't support Markdown for Agents. This Cloudflare standard lets AI agents request content in markdown format, reducing token usage by ~80%.
How to implement
Implement one or more: (1) Respond to Accept: text/markdown with markdown content. (2) Serve .md URLs (e.g., /page.md). (3) Add <link rel="alternate" type="text/markdown"> tags. (4) Add Link HTTP headers for markdown discovery.
No Content-Signal directives found. These tell AI agents how they may use your content (search indexing, AI input, training data). The recommended location is robots.txt.
How to implement
Add Content-Signal to your robots.txt: User-agent: *\nContent-Signal: search=yes, ai-input=yes, ai-train=no. You can also add it as an HTTP header on markdown responses.
Your heading structure has issues (skipped levels or multiple h1 tags). A clean hierarchy helps AI agents understand content organization.
How to implement
Ensure you have exactly one <h1> per page, and headings follow sequential order: h1 > h2 > h3. Don't skip levels (e.g., h1 directly to h3).
Missing or incomplete Open Graph tags. OG tags help AI agents (and social platforms) understand your page title, description, and image.
How to implement
Add og:title, og:description, and og:image meta tags to your page's <head>.
%5D(https%3A%2F%2Fwww.jeronimo.dev%2F%20%22Spartan%20Blog%20-%20Jer%C3%B3nimo%22)%23%20%5BSpartan%20Blog%20-%20Jer%C3%B3nimo%5D(https%3A%2F%2Fwww.jeronimo.dev%2F)%0A%0AJerolba's%20blog.%20Tech%2C%20JVM%20and%20random%20stuff.%0A%0A%23%23%23%20%5BIntegrating%20Spring%20Batch%20with%20Parquet%5D(https%3A%2F%2Fwww.jeronimo.dev%2Fintegrating-spring-batch-with-parquet%2F)%0A%0ASpring%20Batch%20is%20one%20of%20the%20few%20existing%20tools%20in%20the%20Java%20Enterprise%20ecosystem%20for%20building%20batch%20processes%20or%20data%20pipelines.%20However%2C%20its%20components%20(ItemReader%2FItemWriter)%20are%20primarily%20oriented%20toward%20relational%20databases%2C%20CSV%2C%20XML%2C%20or%20JSON.%0A%0AIn%20a%20world%20where%20Data%20Lakes%20and%20columnar%20formats%20are%20increasingly%20important%2C%20integrating%20Parquet%20with%20Spring%20Batch%20opens%20new%20possibilities%20for%20building%20data%20pipelines%20from%20the%20Java%20world%2C%20without%20depending%20on%20complex%20solutions%20or%20different%20technology%20stacks%20that%20often%20cause%20friction%20in%20the%20Enterprise%20world.%0A%0A%23%23%23%20%5BThe%20Carpet%20feature%20that%20nobody%20will%20use%5D(https%3A%2F%2Fwww.jeronimo.dev%2Fthe-carpet-feature-that-nobody-will-use%2F)%0A%0AThis%20week%20I%20released%20a%20new%20version%20of%20%5BCarpet%5D(https%3A%2F%2Fgithub.com%2Fjerolba%2Fparquet-carpet)%2C%20the%20Java%20library%20for%20working%20with%20Parquet%20files.%20In%20this%20version%2C%20I%E2%80%99ve%20added%20a%20feature%20that%20I%20believe%20nobody%20will%20ever%20use%3A%20**the%20ability%20to%20read%20and%20write%20BSON-type%20columns**.%0A%0A%23%23%23%20%5BThe%20two%20versions%20of%20Parquet%5D(https%3A%2F%2Fwww.jeronimo.dev%2Fthe-two-versions-of-parquet%2F)%0A%0AA%20few%20days%20ago%2C%20the%20creators%20of%20DuckDB%20wrote%20the%20article%3A%20%5BQuery%20Engines%3A%20Gatekeepers%20of%20the%20Parquet%20File%20Format%5D(https%3A%2F%2Fduckdb.org%2F2025%2F01%2F22%2Fparquet-encodings.html)%2C%20which%20explained%20how%20the%20engines%20that%20process%20Parquet%20files%20as%20SQL%20tables%20are%20blocking%20the%20evolution%20of%20the%20format.%20This%20is%20because%20those%20engines%20are%20not%20fully%20supporting%20the%20latest%20specification%2C%20and%20without%20this%20support%2C%20the%20rest%20of%20the%20ecosystem%20has%20no%20incentive%20to%20adopt%20it.%0A%0A%23%23%23%20%5BCompression%20algorithms%20in%20Parquet%5D(https%3A%2F%2Fwww.jeronimo.dev%2Fcompression-algorithms-parquet%2F)%0A%0AApache%20Parquet%20is%20a%20columnar%20storage%20format%20optimized%20for%20analytical%20workloads%2C%20though%20it%20can%20also%20be%20used%20to%20store%20any%20type%20of%20structured%20data%20solving%20multiple%20use%20cases.%0A%0AOne%20of%20its%20most%20notable%20features%20is%20the%20ability%20to%20efficiently%20compress%20data%20using%20different%20compression%20techniques%20at%20two%20stages%20of%20its%20process.%20This%20reduces%20storage%20costs%20and%20improves%20reading%20performance.%0A%0AThis%20article%20explains%20file%20compression%20in%20Parquet%20for%20Java%2C%20provides%20usage%20examples%2C%20and%20analyzes%20its%20performance.%0A%0A%23%23%23%20%5BWorking%20with%20Parquet%20files%20in%20Java%20using%20Parquet%20Carpet%5D(https%3A%2F%2Fwww.jeronimo.dev%2Fworking-with-parquet-files-in-java-using-carpet%2F)%0A%0AAfter%20some%20time%20working%20with%20Parquet%20files%20in%20Java%20using%20the%20Parquet%20Avro%20library%2C%20and%20studying%20how%20it%20worked%2C%20I%20concluded%20that%20despite%20**being%20very%20useful**%20in%20multiple%20use%20cases%20and%20having%20great%20potential%2C%20**the%20documentation%20and%20ecosystem%20needed%20for%20adoption%20in%20the%20Java%20world%20was%20very%20poor**.%0A%0AMany%20people%20are%20using%20suboptimal%20solutions%20(CSV%20or%20JSON%20files)%2C%20applying%20more%20complex%20solutions%20(Spark)%2C%20or%20using%20languages%20they%20are%20not%20familiar%20with%20(Python)%20because%20they%20don%E2%80%99t%20know%20how%20to%20work%20with%20Parquet%20files%20easily.%20That%E2%80%99s%20why%20I%20decided%20to%20**write%20this%20%5Bseries%20of%20articles%5D(https%3A%2F%2Fwww.jeronimo.dev%2Fworking-with-parquet-files-in-java%2F)**.%0A%0AOnce%20you%20understand%20it%20and%20have%20the%20examples%2C%20everything%20is%20easier.%20But%2C%20**can%20it%20be%20even%20easier%3F**%20Can%20we%20avoid%20the%20hassle%20of%20using%20*strange*%20libraries%20that%20serialize%20other%20formats%3F%20**Yes%2C%20it%20should%20be%20even%20easier.**%0A%0AThat%E2%80%99s%20why%20I%20decided%20to%20**implement%20an%20Open%20Source%20library**%20that%20makes%20working%20with%20Parquet%20from%20Java%20extremely%20simple%2C%20something%20that%20covers%20it%3A%20**Carpet**.%0A%0A%23%23%23%20%5BWorking%20with%20Parquet%20files%20in%20Java%20using%20Protocol%20Buffers%5D(https%3A%2F%2Fwww.jeronimo.dev%2Fworking-with-parquet-files-in-java-using-protocol-buffers%2F)%0A%0AThis%20post%20continues%20the%20series%20of%20articles%20about%20working%20with%20Parquet%20files%20in%20Java.%20This%20time%2C%20I%E2%80%99ll%20explain%20how%20to%20do%20it%20using%20the%20Protocol%20Buffers%20(PB)%20library.%0A%0AFinding%20examples%20and%20documentation%20on%20how%20to%20use%20Parquet%20with%20Avro%20is%20challenging%2C%20but%20with%20**Protocol%20Buffers%2C%20it%E2%80%99s%20even%20more%20complicated**.%0A%0A%23%23%23%20%5BWorking%20with%20Parquet%20files%20in%20Java%20using%20Avro%5D(https%3A%2F%2Fwww.jeronimo.dev%2Fworking-with-parquet-files-in-java-using-avro%2F)%0A%0AIn%20the%20previous%20article%2C%20I%20wrote%20an%20introduction%20to%20using%20Parquet%20files%20in%20Java%2C%20but%20I%20did%20not%20include%20any%20examples.%20In%20this%20article%2C%20I%20will%20explain%20how%20to%20do%20this%20using%20the%20Avro%20library.%0A%0AParquet%20with%20Avro%20**is%20one%20of%20the%20most%20popular%20ways%20to%20work%20with%20Parquet%20files%20in%20Java**%20due%20to%20its%20simplicity%2C%20flexibility%2C%20and%20because%20it%20is%20the%20library%20with%20the%20most%20examples.%0A%0A%23%23%23%20%5BWorking%20with%20Parquet%20files%20in%20Java%5D(https%3A%2F%2Fwww.jeronimo.dev%2Fworking-with-parquet-files-in-java%2F)%0A%0AParquet%20is%20a%20widely%20used%20format%20in%20the%20Data%20Engineering%20realm%20and%20holds%20significant%20potential%20for%20traditional%20Backend%20applications.%20This%20article%20serves%20as%20an%20**introduction%20to%20the%20format**%2C%20including%20some%20of%20the%20unique%20challenges%20I%E2%80%99ve%20faced%20while%20using%20it%2C%20to%20spare%20you%20from%20similar%20experiences.%0A%0A%23%23%23%20%5BJava%20Serialization%20with%20Apache%20Avro%5D(https%3A%2F%2Fwww.jeronimo.dev%2Fjava-serialization-with-avro%2F)%0A%0AIn%20previous%20posts%20I%E2%80%99ve%20analyzed%20%5BProtocol%20Buffers%5D(https%3A%2F%2Fwww.jeronimo.dev%2Fjava-serialization-with-protocol-buffers%2F)%20and%20%5BFlatBuffers%5D(https%3A%2F%2Fwww.jeronimo.dev%2Fjava-serialization-with-flatbuffers%2F)%2C%20using%20JSON%20as%20the%20baseline.%20In%20this%20post%2C%20I%20will%20analyze%20Apache%20Avro%20and%20compare%20it%20with%20the%20previously%20studied%20formats.%0A%0A%23%23%23%20%5BJava%20Serialization%20with%20Flatbuffers%5D(https%3A%2F%2Fwww.jeronimo.dev%2Fjava-serialization-with-flatbuffers%2F)%0A%0AIn%20the%20%5Bprevious%20post%5D(https%3A%2F%2Fwww.jeronimo.dev%2Fjava-serialization-with-protocol-buffers%2F)%20I%20analyzed%20Protocol%20Buffers%20format%2C%20using%20JSON%20as%20baseline.%20In%20this%20post%20I%E2%80%99m%20going%20to%20analyze%20FlatBuffers%20and%20compare%20it%20with%20previously%20studied%20formats.%0A){kind=link}
Spring Batch is one of the few existing tools in the Java Enterprise ecosystem for building batch processes or data pipelines. However, its components (ItemReader/ItemWriter) are primarily oriented toward relational databases, CSV, XML, or JSON. In a world where Data Lakes and columnar formats are increasingly important, integrating Parquet with Spring Batch opens new possibilities for building data pipelines from the Java world, without depending on complex solutions or different technology stacks that often cause friction in the Enterprise world. This week I released a new version of [Carpet](https://github.com/jerolba/parquet-carpet), the Java library for working with Parquet files. In this version, I’ve added a feature that I believe nobody will ever use: **the ability to read and write BSON-type columns**. A few days ago, the creators of DuckDB wrote the article: [Query Engines: Gatekeepers of the Parquet File Format](https://duckdb.org/2025/01/22/parquet-encodings.html), which explained how the engines that process Parquet files as SQL tables are blocking the evolution of the format. This is because those engines are not fully supporting the latest specification, and without this support, the rest of the ecosystem has no incentive to adopt it. Apache Parquet is a columnar storage format optimized for analytical workloads, though it can also be used to store any type of structured data solving multiple use cases. One of its most notable features is the ability to efficiently compress data using different compression techniques at two stages of its process. This reduces storage costs and improves reading performance. This article explains file compression in Parquet for Java, provides usage examples, and analyzes its performance. After some time working with Parquet files in Java using the Parquet Avro library, and studying how it worked, I concluded that despite **being very useful** in multiple use cases and having great potential, **the documentation and ecosystem needed for adoption in the Java world was very poor**. Many people are using suboptimal solutions (CSV or JSON files), applying more complex solutions (Spark), or using languages they are not familiar with (Python) because they don’t know how to work with Parquet files easily. That’s why I decided to **write this [series of articles](https://www.jeronimo.dev/working-with-parquet-files-in-java/)**. Once you understand it and have the examples, everything is easier. But, **can it be even easier?** Can we avoid the hassle of using *strange* libraries that serialize other formats? **Yes, it should be even easier.** That’s why I decided to **implement an Open Source library** that makes working with Parquet from Java extremely simple, something that covers it: **Carpet**. This post continues the series of articles about working with Parquet files in Java. This time, I’ll explain how to do it using the Protocol Buffers (PB) library. Finding examples and documentation on how to use Parquet with Avro is challenging, but with **Protocol Buffers, it’s even more complicated**. In the previous article, I wrote an introduction to using Parquet files in Java, but I did not include any examples. In this article, I will explain how to do this using the Avro library. Parquet with Avro **is one of the most popular ways to work with Parquet files in Java** due to its simplicity, flexibility, and because it is the library with the most examples. Parquet is a widely used format in the Data Engineering realm and holds significant potential for traditional Backend applications. This article serves as an **introduction to the format**, including some of the unique challenges I’ve faced while using it, to spare you from similar experiences. In previous posts I’ve analyzed [Protocol Buffers](https://www.jeronimo.dev/java-serialization-with-protocol-buffers/) and [FlatBuffers](https://www.jeronimo.dev/java-serialization-with-flatbuffers/), using JSON as the baseline. In this post, I will analyze Apache Avro and compare it with the previously studied formats. In the [previous post](https://www.jeronimo.dev/java-serialization-with-protocol-buffers/) I analyzed Protocol Buffers format, using JSON as baseline. In this post I’m going to analyze FlatBuffers and compare it with previously studied formats.
Spartan Blog - Jerónimo | Jerolba’s blog. Tech, JVM and random stuff. [](https://www.jeronimo.dev/ "Spartan Blog - Jerónimo")# [Spartan Blog - Jerónimo](https://www.jeronimo.dev/) Jerolba's blog. Tech, JVM and random stuff. ### [Integrating Spring Batch with Parquet](https://www.jeronimo.dev/integrating-spring-batch-with-parquet/) Spring Batch is one of the few existing tools in the Java Enterprise ecosystem for building batch processes or data pipelines. However, its components (ItemReader/ItemWriter) are primarily oriented toward relational databases, CSV, XML, or JSON. In a world where Data Lakes and columnar formats are increasingly important, integrating Parquet with Spring Batch opens new possibilities for building data pipelines from the Java world, without depending on complex solutions or different technology stacks that often cause friction in the Enterprise world. ### [The Carpet feature that nobody will use](https://www.jeronimo.dev/the-carpet-feature-that-nobody-will-use/) This week I released a new version of [Carpet](https://github.com/jerolba/parquet-carpet), the Java library for working with Parquet files. In this version, I’ve added a feature that I believe nobody will ever use: **the ability to read and write BSON-type columns**. ### [The two versions of Parquet](https://www.jeronimo.dev/the-two-versions-of-parquet/) A few days ago, the creators of DuckDB wrote the article: [Query Engines: Gatekeepers of the Parquet File Format](https://duckdb.org/2025/01/22/parquet-encodings.html), which explained how the engines that process Parquet files as SQL tables are blocking the evolution of the format. This is because those engines are not fully supporting the latest specification, and without this support, the rest of the ecosystem has no incentive to adopt it. ### [Compression algorithms in Parquet](https://www.jeronimo.dev/compression-algorithms-parquet/) Apache Parquet is a columnar storage format optimized for analytical workloads, though it can also be used to store any type of structured data solving multiple use cases. One of its most notable features is the ability to efficiently compress data using different compression techniques at two stages of its process. This reduces storage costs and improves reading performance. This article explains file compression in Parquet for Java, provides usage examples, and analyzes its performance. ### [Working with Parquet files in Java using Parquet Carpet](https://www.jeronimo.dev/working-with-parquet-files-in-java-using-carpet/) After some time working with Parquet files in Java using the Parquet Avro library, and studying how it worked, I concluded that despite **being very useful** in multiple use cases and having great potential, **the documentation and ecosystem needed for adoption in the Java world was very poor**. Many people are using suboptimal solutions (CSV or JSON files), applying more complex solutions (Spark), or using languages they are not familiar with (Python) because they don’t know how to work with Parquet files easily. That’s why I decided to **write this [series of articles](https://www.jeronimo.dev/working-with-parquet-files-in-java/)**. Once you understand it and have the examples, everything is easier. But, **can it be even easier?** Can we avoid the hassle of using *strange* libraries that serialize other formats? **Yes, it should be even easier.** That’s why I decided to **implement an Open Source library** that makes working with Parquet from Java extremely simple, something that covers it: **Carpet**. ### [Working with Parquet files in Java using Protocol Buffers](https://www.jeronimo.dev/working-with-parquet-files-in-java-using-protocol-buffers/) This post continues the series of articles about working with Parquet files in Java. This time, I’ll explain how to do it using the Protocol Buffers (PB) library. Finding examples and documentation on how to use Parquet with Avro is challenging, but with **Protocol Buffers, it’s even more complicated**. ### [Working with Parquet files in Java using Avro](https://www.jeronimo.dev/working-with-parquet-files-in-java-using-avro/) In the previous article, I wrote an introduction to using Parquet files in Java, but I did not include any examples. In this article, I will explain how to do this using the Avro library. Parquet with Avro **is one of the most popular ways to work with Parquet files in Java** due to its simplicity, flexibility, and because it is the library with the most examples. ### [Working with Parquet files in Java](https://www.jeronimo.dev/working-with-parquet-files-in-java/) Parquet is a widely used format in the Data Engineering realm and holds significant potential for traditional Backend applications. This article serves as an **introduction to the format**, including some of the unique challenges I’ve faced while using it, to spare you from similar experiences. ### [Java Serialization with Apache Avro](https://www.jeronimo.dev/java-serialization-with-avro/) In previous posts I’ve analyzed [Protocol Buffers](https://www.jeronimo.dev/java-serialization-with-protocol-buffers/) and [FlatBuffers](https://www.jeronimo.dev/java-serialization-with-flatbuffers/), using JSON as the baseline. In this post, I will analyze Apache Avro and compare it with the previously studied formats. ### [Java Serialization with Flatbuffers](https://www.jeronimo.dev/java-serialization-with-flatbuffers/) In the [previous post](https://www.jeronimo.dev/java-serialization-with-protocol-buffers/) I analyzed Protocol Buffers format, using JSON as baseline. In this post I’m going to analyze FlatBuffers and compare it with previously studied formats.
Upload this file as /index.md on your server so AI agents can access a clean version of your page. You can also configure Accept: text/markdown content negotiation to serve it automatically.
Generated llms.txt for this single page
# Spartan Blog - Jerónimo > Jerolba’s blog. Tech, JVM and random stuff. ## Main - [Spartan Blog - Jerónimo](https://www.jeronimo.dev/): Jerolba’s blog. Tech, JVM and random stuff. - [Integrating Spring Batch with Parquet](https://www.jeronimo.dev/integrating-spring-batch-with-parquet/) - [The Carpet feature that nobody will use](https://www.jeronimo.dev/the-carpet-feature-that-nobody-will-use/) - [The two versions of Parquet](https://www.jeronimo.dev/the-two-versions-of-parquet/) - [Compression algorithms in Parquet](https://www.jeronimo.dev/compression-algorithms-parquet/) - [Working with Parquet files in Java using Parquet Carpet](https://www.jeronimo.dev/working-with-parquet-files-in-java-using-carpet/) - [Working with Parquet files in Java using Protocol Buffers](https://www.jeronimo.dev/working-with-parquet-files-in-java-using-protocol-buffers/) - [Working with Parquet files in Java using Avro](https://www.jeronimo.dev/working-with-parquet-files-in-java-using-avro/) - [Working with Parquet files in Java](https://www.jeronimo.dev/working-with-parquet-files-in-java/)
Full llms.txt requires domain-wide analysis (coming soon)
Upload this file to https://www.jeronimo.dev/llms.txt at the root of your domain. AI agents like ChatGPT, Claude, and Perplexity check this file to understand your site structure.
Semantic HTML
Uses article or main element
(100/100)
Has both <article> and <main>
Proper heading hierarchy
(65/100)
2 <h1> elements (should be 1), 1 heading level skip(s)
Uses semantic HTML elements
(100/100)
46 semantic elements, 15 divs (ratio: 75%)
Meaningful image alt texts
(100/100)
1/1 images with meaningful alt text
Low div nesting depth
(100/100)
Avg div depth: 2.2, max: 3
Content Efficiency
Good token reduction ratio
(80/100)
77% token reduction (HTML→Markdown)
Good content-to-noise ratio
(80/100)
Content ratio: 29.2% (4359 content chars / 14947 HTML bytes)
Minimal inline styles
(100/100)
0/175 elements with inline styles (0.0%)
Reasonable page weight
(100/100)
HTML size: 15KB
AI Discoverability
Has llms.txt file
(0/100)
No llms.txt found
Has robots.txt file
(100/100)
robots.txt exists
Robots.txt allows AI bots
(100/100)
All major AI bots allowed
Has sitemap.xml
(100/100)
Sitemap found
Markdown for Agents support
(0/100)
No markdown content negotiation
Has Content-Signal (robots.txt or HTTP headers)
(0/100)
No Content-Signal header
Structured Data
Has Schema.org / JSON-LD
(50/100)
JSON-LD found but basic types: WebSite
Has Open Graph tags
(67/100)
2/3 OG tags present
Has meta description
(50/100)
Meta description too short: 43 chars
Has canonical URL
(100/100)
Canonical URL present
Has lang attribute
(100/100)
lang="en-US"
Accessibility
Content available without JavaScript
(100/100)
Content available without JavaScript
Reasonable page size
(100/100)
Page size: 15KB
Content appears early in HTML
(75/100)
Main content starts at 22% of HTML
{
"url": "https://www.jeronimo.dev/",
"timestamp": 1771156368416,
"fetch": {
"mode": "simple",
"timeMs": 136,
"htmlSizeBytes": 14947,
"supportsMarkdown": false,
"statusCode": 200
},
"extraction": {
"title": "Spartan Blog - Jerónimo",
"excerpt": "Jerolba’s blog. Tech, JVM and random stuff.",
"byline": "Jerónimo López",
"siteName": "Spartan Blog - Jerónimo",
"lang": "en-US",
"contentLength": 4359,
"metadata": {
"description": "Jerolba’s blog. Tech, JVM and random stuff.",
"ogTitle": "Spartan Blog - Jerónimo",
"ogDescription": "Jerolba’s blog. Tech, JVM and random stuff.",
"ogImage": null,
"ogType": "website",
"canonical": "https://www.jeronimo.dev/",
"lang": "en-US",
"schemas": [
{
"@context": "https://schema.org",
"@type": "WebSite",
"author": {
"@type": "Person",
"name": "Jerónimo López"
},
"description": "Jerolba’s blog. Tech, JVM and random stuff.",
"headline": "Spartan Blog - Jerónimo",
"name": "Spartan Blog - Jerónimo",
"publisher": {
"@type": "Organization",
"logo": {
"@type": "ImageObject",
"url": "https://www.jeronimo.dev/images/spartan-helmet.png"
},
"name": "Jerónimo López"
},
"url": "https://www.jeronimo.dev/"
}
],
"robotsMeta": null,
"author": "Jerónimo López",
"generator": "Jekyll v3.8.7"
}
},
"markdown": "Spring Batch is one of the few existing tools in the Java Enterprise ecosystem for building batch processes or data pipelines. However, its components (ItemReader/ItemWriter) are primarily oriented toward relational databases, CSV, XML, or JSON.\n\nIn a world where Data Lakes and columnar formats are increasingly important, integrating Parquet with Spring Batch opens new possibilities for building data pipelines from the Java world, without depending on complex solutions or different technology stacks that often cause friction in the Enterprise world.\n\nThis week I released a new version of [Carpet](https://github.com/jerolba/parquet-carpet), the Java library for working with Parquet files. In this version, I’ve added a feature that I believe nobody will ever use: **the ability to read and write BSON-type columns**.\n\nA few days ago, the creators of DuckDB wrote the article: [Query Engines: Gatekeepers of the Parquet File Format](https://duckdb.org/2025/01/22/parquet-encodings.html), which explained how the engines that process Parquet files as SQL tables are blocking the evolution of the format. This is because those engines are not fully supporting the latest specification, and without this support, the rest of the ecosystem has no incentive to adopt it.\n\nApache Parquet is a columnar storage format optimized for analytical workloads, though it can also be used to store any type of structured data solving multiple use cases.\n\nOne of its most notable features is the ability to efficiently compress data using different compression techniques at two stages of its process. This reduces storage costs and improves reading performance.\n\nThis article explains file compression in Parquet for Java, provides usage examples, and analyzes its performance.\n\nAfter some time working with Parquet files in Java using the Parquet Avro library, and studying how it worked, I concluded that despite **being very useful** in multiple use cases and having great potential, **the documentation and ecosystem needed for adoption in the Java world was very poor**.\n\nMany people are using suboptimal solutions (CSV or JSON files), applying more complex solutions (Spark), or using languages they are not familiar with (Python) because they don’t know how to work with Parquet files easily. That’s why I decided to **write this [series of articles](https://www.jeronimo.dev/working-with-parquet-files-in-java/)**.\n\nOnce you understand it and have the examples, everything is easier. But, **can it be even easier?** Can we avoid the hassle of using *strange* libraries that serialize other formats? **Yes, it should be even easier.**\n\nThat’s why I decided to **implement an Open Source library** that makes working with Parquet from Java extremely simple, something that covers it: **Carpet**.\n\nThis post continues the series of articles about working with Parquet files in Java. This time, I’ll explain how to do it using the Protocol Buffers (PB) library.\n\nFinding examples and documentation on how to use Parquet with Avro is challenging, but with **Protocol Buffers, it’s even more complicated**.\n\nIn the previous article, I wrote an introduction to using Parquet files in Java, but I did not include any examples. In this article, I will explain how to do this using the Avro library.\n\nParquet with Avro **is one of the most popular ways to work with Parquet files in Java** due to its simplicity, flexibility, and because it is the library with the most examples.\n\nParquet is a widely used format in the Data Engineering realm and holds significant potential for traditional Backend applications. This article serves as an **introduction to the format**, including some of the unique challenges I’ve faced while using it, to spare you from similar experiences.\n\nIn previous posts I’ve analyzed [Protocol Buffers](https://www.jeronimo.dev/java-serialization-with-protocol-buffers/) and [FlatBuffers](https://www.jeronimo.dev/java-serialization-with-flatbuffers/), using JSON as the baseline. In this post, I will analyze Apache Avro and compare it with the previously studied formats.\n\nIn the [previous post](https://www.jeronimo.dev/java-serialization-with-protocol-buffers/) I analyzed Protocol Buffers format, using JSON as baseline. In this post I’m going to analyze FlatBuffers and compare it with previously studied formats.\n",
"fullPageMarkdown": "Spartan Blog - Jerónimo | Jerolba’s blog. Tech, JVM and random stuff.\n\n[](https://www.jeronimo.dev/ \"Spartan Blog - Jerónimo\")# [Spartan Blog - Jerónimo](https://www.jeronimo.dev/)\n\nJerolba's blog. Tech, JVM and random stuff.\n\n### [Integrating Spring Batch with Parquet](https://www.jeronimo.dev/integrating-spring-batch-with-parquet/)\n\nSpring Batch is one of the few existing tools in the Java Enterprise ecosystem for building batch processes or data pipelines. However, its components (ItemReader/ItemWriter) are primarily oriented toward relational databases, CSV, XML, or JSON.\n\nIn a world where Data Lakes and columnar formats are increasingly important, integrating Parquet with Spring Batch opens new possibilities for building data pipelines from the Java world, without depending on complex solutions or different technology stacks that often cause friction in the Enterprise world.\n\n### [The Carpet feature that nobody will use](https://www.jeronimo.dev/the-carpet-feature-that-nobody-will-use/)\n\nThis week I released a new version of [Carpet](https://github.com/jerolba/parquet-carpet), the Java library for working with Parquet files. In this version, I’ve added a feature that I believe nobody will ever use: **the ability to read and write BSON-type columns**.\n\n### [The two versions of Parquet](https://www.jeronimo.dev/the-two-versions-of-parquet/)\n\nA few days ago, the creators of DuckDB wrote the article: [Query Engines: Gatekeepers of the Parquet File Format](https://duckdb.org/2025/01/22/parquet-encodings.html), which explained how the engines that process Parquet files as SQL tables are blocking the evolution of the format. This is because those engines are not fully supporting the latest specification, and without this support, the rest of the ecosystem has no incentive to adopt it.\n\n### [Compression algorithms in Parquet](https://www.jeronimo.dev/compression-algorithms-parquet/)\n\nApache Parquet is a columnar storage format optimized for analytical workloads, though it can also be used to store any type of structured data solving multiple use cases.\n\nOne of its most notable features is the ability to efficiently compress data using different compression techniques at two stages of its process. This reduces storage costs and improves reading performance.\n\nThis article explains file compression in Parquet for Java, provides usage examples, and analyzes its performance.\n\n### [Working with Parquet files in Java using Parquet Carpet](https://www.jeronimo.dev/working-with-parquet-files-in-java-using-carpet/)\n\nAfter some time working with Parquet files in Java using the Parquet Avro library, and studying how it worked, I concluded that despite **being very useful** in multiple use cases and having great potential, **the documentation and ecosystem needed for adoption in the Java world was very poor**.\n\nMany people are using suboptimal solutions (CSV or JSON files), applying more complex solutions (Spark), or using languages they are not familiar with (Python) because they don’t know how to work with Parquet files easily. That’s why I decided to **write this [series of articles](https://www.jeronimo.dev/working-with-parquet-files-in-java/)**.\n\nOnce you understand it and have the examples, everything is easier. But, **can it be even easier?** Can we avoid the hassle of using *strange* libraries that serialize other formats? **Yes, it should be even easier.**\n\nThat’s why I decided to **implement an Open Source library** that makes working with Parquet from Java extremely simple, something that covers it: **Carpet**.\n\n### [Working with Parquet files in Java using Protocol Buffers](https://www.jeronimo.dev/working-with-parquet-files-in-java-using-protocol-buffers/)\n\nThis post continues the series of articles about working with Parquet files in Java. This time, I’ll explain how to do it using the Protocol Buffers (PB) library.\n\nFinding examples and documentation on how to use Parquet with Avro is challenging, but with **Protocol Buffers, it’s even more complicated**.\n\n### [Working with Parquet files in Java using Avro](https://www.jeronimo.dev/working-with-parquet-files-in-java-using-avro/)\n\nIn the previous article, I wrote an introduction to using Parquet files in Java, but I did not include any examples. In this article, I will explain how to do this using the Avro library.\n\nParquet with Avro **is one of the most popular ways to work with Parquet files in Java** due to its simplicity, flexibility, and because it is the library with the most examples.\n\n### [Working with Parquet files in Java](https://www.jeronimo.dev/working-with-parquet-files-in-java/)\n\nParquet is a widely used format in the Data Engineering realm and holds significant potential for traditional Backend applications. This article serves as an **introduction to the format**, including some of the unique challenges I’ve faced while using it, to spare you from similar experiences.\n\n### [Java Serialization with Apache Avro](https://www.jeronimo.dev/java-serialization-with-avro/)\n\nIn previous posts I’ve analyzed [Protocol Buffers](https://www.jeronimo.dev/java-serialization-with-protocol-buffers/) and [FlatBuffers](https://www.jeronimo.dev/java-serialization-with-flatbuffers/), using JSON as the baseline. In this post, I will analyze Apache Avro and compare it with the previously studied formats.\n\n### [Java Serialization with Flatbuffers](https://www.jeronimo.dev/java-serialization-with-flatbuffers/)\n\nIn the [previous post](https://www.jeronimo.dev/java-serialization-with-protocol-buffers/) I analyzed Protocol Buffers format, using JSON as baseline. In this post I’m going to analyze FlatBuffers and compare it with previously studied formats.\n",
"markdownStats": {
"images": 0,
"links": 6,
"tables": 0,
"codeBlocks": 0,
"headings": 0
},
"tokens": {
"htmlTokens": 3880,
"markdownTokens": 892,
"reduction": 2988,
"reductionPercent": 77
},
"score": {
"score": 76,
"grade": "B",
"dimensions": {
"semanticHtml": {
"score": 91,
"weight": 20,
"grade": "A",
"checks": {
"uses_article_or_main": {
"score": 100,
"weight": 20,
"details": "Has both <article> and <main>"
},
"proper_heading_hierarchy": {
"score": 65,
"weight": 25,
"details": "2 <h1> elements (should be 1), 1 heading level skip(s)"
},
"semantic_elements": {
"score": 100,
"weight": 20,
"details": "46 semantic elements, 15 divs (ratio: 75%)"
},
"meaningful_alt_texts": {
"score": 100,
"weight": 15,
"details": "1/1 images with meaningful alt text"
},
"low_div_nesting": {
"score": 100,
"weight": 20,
"details": "Avg div depth: 2.2, max: 3"
}
}
},
"contentEfficiency": {
"score": 86,
"weight": 25,
"grade": "B",
"checks": {
"token_reduction_ratio": {
"score": 80,
"weight": 40,
"details": "77% token reduction (HTML→Markdown)"
},
"content_to_noise_ratio": {
"score": 80,
"weight": 30,
"details": "Content ratio: 29.2% (4359 content chars / 14947 HTML bytes)"
},
"minimal_inline_styles": {
"score": 100,
"weight": 15,
"details": "0/175 elements with inline styles (0.0%)"
},
"reasonable_page_weight": {
"score": 100,
"weight": 15,
"details": "HTML size: 15KB"
}
}
},
"aiDiscoverability": {
"score": 50,
"weight": 25,
"grade": "D",
"checks": {
"has_llms_txt": {
"score": 0,
"weight": 25,
"details": "No llms.txt found"
},
"has_robots_txt": {
"score": 100,
"weight": 15,
"details": "robots.txt exists"
},
"robots_allows_ai_bots": {
"score": 100,
"weight": 20,
"details": "All major AI bots allowed"
},
"has_sitemap": {
"score": 100,
"weight": 15,
"details": "Sitemap found"
},
"supports_markdown_negotiation": {
"score": 0,
"weight": 15,
"details": "No markdown content negotiation"
},
"has_content_signals": {
"score": 0,
"weight": 10,
"details": "No Content-Signal header"
}
}
},
"structuredData": {
"score": 67,
"weight": 15,
"grade": "C",
"checks": {
"has_schema_org": {
"score": 50,
"weight": 30,
"details": "JSON-LD found but basic types: WebSite"
},
"has_open_graph": {
"score": 67,
"weight": 25,
"details": "2/3 OG tags present"
},
"has_meta_description": {
"score": 50,
"weight": 20,
"details": "Meta description too short: 43 chars"
},
"has_canonical_url": {
"score": 100,
"weight": 15,
"details": "Canonical URL present"
},
"has_lang_attribute": {
"score": 100,
"weight": 10,
"details": "lang=\"en-US\""
}
}
},
"accessibility": {
"score": 93,
"weight": 15,
"grade": "A",
"checks": {
"content_without_js": {
"score": 100,
"weight": 40,
"details": "Content available without JavaScript"
},
"reasonable_page_size": {
"score": 100,
"weight": 30,
"details": "Page size: 15KB"
},
"fast_content_position": {
"score": 75,
"weight": 30,
"details": "Main content starts at 22% of HTML"
}
}
}
}
},
"recommendations": [
{
"id": "add_llms_txt",
"priority": "critical",
"category": "aiDiscoverability",
"titleKey": "rec.add_llms_txt.title",
"descriptionKey": "rec.add_llms_txt.description",
"howToKey": "rec.add_llms_txt.howto",
"effort": "quick-win",
"estimatedImpact": 10,
"checkScore": 0,
"checkDetails": "No llms.txt found"
},
{
"id": "add_markdown_negotiation",
"priority": "critical",
"category": "aiDiscoverability",
"titleKey": "rec.add_markdown_negotiation.title",
"descriptionKey": "rec.add_markdown_negotiation.description",
"howToKey": "rec.add_markdown_negotiation.howto",
"effort": "significant",
"estimatedImpact": 4,
"checkScore": 0,
"checkDetails": "No markdown content negotiation"
},
{
"id": "add_content_signals",
"priority": "critical",
"category": "aiDiscoverability",
"titleKey": "rec.add_content_signals.title",
"descriptionKey": "rec.add_content_signals.description",
"howToKey": "rec.add_content_signals.howto",
"effort": "moderate",
"estimatedImpact": 3,
"checkScore": 0,
"checkDetails": "No Content-Signal header"
},
{
"id": "fix_heading_hierarchy",
"priority": "medium",
"category": "semanticHtml",
"titleKey": "rec.fix_heading_hierarchy.title",
"descriptionKey": "rec.fix_heading_hierarchy.description",
"howToKey": "rec.fix_heading_hierarchy.howto",
"effort": "quick-win",
"estimatedImpact": 6,
"checkScore": 65,
"checkDetails": "2 <h1> elements (should be 1), 1 heading level skip(s)"
},
{
"id": "add_open_graph",
"priority": "medium",
"category": "structuredData",
"titleKey": "rec.add_open_graph.title",
"descriptionKey": "rec.add_open_graph.description",
"howToKey": "rec.add_open_graph.howto",
"effort": "quick-win",
"estimatedImpact": 4,
"checkScore": 67,
"checkDetails": "2/3 OG tags present"
}
],
"llmsTxtPreview": "# Spartan Blog - Jerónimo\n\n> Jerolba’s blog. Tech, JVM and random stuff.\n\n## Main\n- [Spartan Blog - Jerónimo](https://www.jeronimo.dev/): Jerolba’s blog. Tech, JVM and random stuff.\n- [Integrating Spring Batch with Parquet](https://www.jeronimo.dev/integrating-spring-batch-with-parquet/)\n- [The Carpet feature that nobody will use](https://www.jeronimo.dev/the-carpet-feature-that-nobody-will-use/)\n- [The two versions of Parquet](https://www.jeronimo.dev/the-two-versions-of-parquet/)\n- [Compression algorithms in Parquet](https://www.jeronimo.dev/compression-algorithms-parquet/)\n- [Working with Parquet files in Java using Parquet Carpet](https://www.jeronimo.dev/working-with-parquet-files-in-java-using-carpet/)\n- [Working with Parquet files in Java using Protocol Buffers](https://www.jeronimo.dev/working-with-parquet-files-in-java-using-protocol-buffers/)\n- [Working with Parquet files in Java using Avro](https://www.jeronimo.dev/working-with-parquet-files-in-java-using-avro/)\n- [Working with Parquet files in Java](https://www.jeronimo.dev/working-with-parquet-files-in-java/)\n\n",
"llmsTxtExisting": null,
"snippets": [
{
"id": "add_llms_txt",
"title": "Create /llms.txt",
"description": "Upload this file to your web root. It tells AI agents what your site is about and which pages matter.",
"language": "markdown",
"code": "# Spartan Blog - Jerónimo\n\n> Jerolba’s blog. Tech, JVM and random stuff.\n\n## Main\n- [Spartan Blog - Jerónimo](https://www.jeronimo.dev/): Jerolba’s blog. Tech, JVM and random stuff.\n- [Integrating Spring Batch with Parquet](https://www.jeronimo.dev/integrating-spring-batch-with-parquet/)\n- [The Carpet feature that nobody will use](https://www.jeronimo.dev/the-carpet-feature-that-nobody-will-use/)\n- [The two versions of Parquet](https://www.jeronimo.dev/the-two-versions-of-parquet/)\n- [Compression algorithms in Parquet](https://www.jeronimo.dev/compression-algorithms-parquet/)\n- [Working with Parquet files in Java using Parquet Carpet](https://www.jeronimo.dev/working-with-parquet-files-in-java-using-carpet/)\n- [Working with Parquet files in Java using Protocol Buffers](https://www.jeronimo.dev/working-with-parquet-files-in-java-using-protocol-buffers/)\n- [Working with Parquet files in Java using Avro](https://www.jeronimo.dev/working-with-parquet-files-in-java-using-avro/)\n- [Working with Parquet files in Java](https://www.jeronimo.dev/working-with-parquet-files-in-java/)\n\n",
"filename": "/llms.txt"
},
{
"id": "fix_heading_hierarchy",
"title": "Fix heading hierarchy",
"description": "Your page has 2 <h1> elements. Keep only one. Demote the rest to <h2>.",
"language": "html",
"code": "<!-- Keep only one <h1> per page -->\n<h1>Spartan Blog - Jerónimo</h1>",
"filename": "<main> or <article>"
},
{
"id": "add_open_graph",
"title": "Add missing Open Graph tags",
"description": "These tags control how your page looks when shared on social media and some AI platforms.",
"language": "html",
"code": "<meta property=\"og:image\" content=\"https://yoursite.com/og-image.jpg\">\n<meta property=\"og:url\" content=\"https://www.jeronimo.dev/\">\n<meta property=\"og:type\" content=\"website\">",
"filename": "<head>"
},
{
"id": "add_content_signals",
"title": "Add Content-Signal HTTP header",
"description": "The Content-Signal header tells AI agents about the nature of your content. Add it via your web server or CDN.",
"language": "nginx",
"code": "# Nginx — add to your server block:\nadd_header Content-Signal \"type=website; lang=en-US\" always;\n\n# Apache — add to .htaccess:\n# Header set Content-Signal \"type=website; lang=en-US\"",
"filename": "nginx.conf or .htaccess"
},
{
"id": "add_markdown_negotiation",
"title": "Support Accept: text/markdown",
"description": "When a client sends Accept: text/markdown, respond with a Markdown version of the page. This is the gold standard for AI-readiness.",
"language": "nginx",
"code": "# Nginx — serve .md files when client requests Markdown:\n# Option 1: Serve pre-generated .md files\nmap $http_accept $markdown_suffix {\n default \"\";\n \"~text/markdown\" \".md\";\n}\n\n# Then in your location block:\ntry_files $uri$markdown_suffix $uri =404;\n\n# Option 2: Use your app framework to check the Accept header\n# and return Markdown content with Content-Type: text/markdown",
"filename": "nginx.conf or application code"
}
]
}Use our API to get this programmatically (coming soon)
This JSON is for internal use — unlike the Markdown and llms.txt files, it's not meant to be uploaded to your site. Save it as a baseline to track your score over time, share it with your dev team, or integrate it into your CI/CD pipeline.
Embed your badge
Add this badge to your site. It updates automatically as your AI-readiness score changes.
Script Recommended
<script src="https://agentready.md/badge.js" data-id="e2a5c805-749c-45e5-953d-a16464f3ebcc" data-domain="www.jeronimo.dev"></script>
Markdown
[](https://agentready.md/r/e2a5c805-749c-45e5-953d-a16464f3ebcc)Coming soon: Full Domain Analysis
Crawl your entire domain, generate llms.txt, and monitor your AI-readiness score over time. Join the waitlist to be notified.
✓ You're on the list! We'll notify you when it launches.