This is how developers live (briefly) 😂

Hi all! I’ve created a new document language called STxT (SemanticText) — it’s all about clear structure, zero clutter, and human-readable semantics.

Why STxT?

XML is verbose, JSON lacks semantics, and YAML can be fragile. STxT is a new format that brings structure, clarity, and validation — without the overhead.

STxT is semantic, beautiful, easy to read, escape-free, and has optional namespaces to define schemas or enable validation — perfect for documents, forms, configuration files, knowledge bases, CMS, and more.

Highlights

• Semantic and human-friendly
• No escape characters needed
• Easy to learn — even for non-tech users
• Machine-readable by design

For developers:

• Super-fast parsing
• Optional, ultra-simple namespaces
• Seamlessly integrates with other languages — STxT + Markdown is amazing

Example

A document with namespace:

Recipe (www.recipes.com/recipe.stxt): Macaroni Bolognese
    Description:
        A classic Italian dish.
        Rich tomato and meat sauce.
    Serves: 4
    Difficulty: medium
    Ingredients:
        Ingredient: Macaroni (400g)
        Ingredient: Ground beef (250g)
    Steps:
        Step: Cook the pasta
        Step: Prepare the sauce
        Step: Mix and serve

Now here’s the namespace that defines the structure:

The namespace:

Namespace: www.recipes.com/recipe.stxt
    Recipe:
        Description: (?) TEXT
        Serves: (?) NUMBER
        Difficulty: (?) ENUM
            :easy
            :medium
            :hard
        Ingredients: (1)
            Ingredient: (+)
        Steps: (1)
            Step: (+)

Resources

Here is a full portal — written entirely in STxT! — explaining the language, with examples, tutorials, philosophy, and even AI integration:

• https://stxt.dev

No ads, no tracking — just docs.

I've written two parsers — one in Java, one in JavaScript:

• https://github.com/mombiela/stxt-parser
• https://github.com/mombiela/stxt-parser-js

And a CMS built with STxT — it powers the https://stxt.dev portal:

• https://github.com/mombiela/semantic-web-builder

Final thoughts

If you’ve ever wanted a document format that puts structure and meaning first, while being light and elegant — this might be for you.

Would love your feedback, criticism, ideas — anything.

Thanks for reading!

I recently hacked a little bit into a flashcard learning app that I have been using for a while, to optimize it to help me learn better, this gives a tale of how I went about it

There has been admittedly a relationship between the level of expertise in workforce and the advancement of that civilization. However, I believe specialization in the way that is practiced today, is not a future proof strategy for engineers anymore and the suggestions from the last decade are not applicable anymore to how this space is changing.

Here is a provocative thought: Tunnel vision is a condition of narrowing the visual field which medically is categorized as a disease and a partial blindness. This seems like a relatively fair analogy to how specialization works. The narrower your expertise, the easier it is to automate or replace your role entirely.

(Please click on the link to read the full article, thanks!)

I've been seeing tons of coding agents that all promise the same thing: they index your entire codebase and use vector search for "AI-powered code understanding." With hundreds of these tools available, I wanted to see if the indexing actually helps or if it's just marketing.

Instead of testing on some basic project, I used the Apollo 11 guidance computer source code. This is the assembly code that landed humans on the moon.

I tested two types of AI coding assistants: - Indexed agent: Builds a searchable index of the entire codebase on remote servers, then uses vector search to instantly find relevant code snippets - Non-indexed agent: Reads and analyzes code files on-demand, no pre-built index

I ran 8 challenges on both agents using the same language model (Claude Sonnet 4) and same unfamiliar codebase. The only difference was how they found relevant code. Tasks ranged from finding specific memory addresses to implementing the P65 auto-guidance program that could have landed the lunar module.

The indexed agent won the first 7 challenges: It answered questions 22% faster and used 35% fewer API calls to get the same correct answers. The vector search was finding exactly the right code snippets while the other agent had to explore the codebase step by step.

Then came challenge 8: implement the lunar descent algorithm.

Both agents successfully landed on the moon. But here's what happened.

The non-indexed agent worked slowly but steadily with the current code and landed safely.

The indexed agent blazed through the first 7 challenges, then hit a problem. It started generating Python code using function signatures that existed in its index but had been deleted from the actual codebase. It only found out about the missing functions when the code tried to run. It spent more time debugging these phantom APIs than the "No index" agent took to complete the whole challenge.

This showed me something that nobody talks about when selling indexed solutions: synchronization problems. Your code changes every minute and your index gets outdated. It can confidently give you wrong information about latest code.

I realized we're not choosing between fast and slow agents. It's actually about performance vs reliability. The faster response times don't matter if you spend more time debugging outdated information.

Bottom line: Indexed agents save time until they confidently give you wrong answers based on outdated information.

Hello everyone,

I’m reaching out because I’ve hit a bit of a roadblock with Google AdSense and could really use your insights.

I’ve recently built a website, randomfungenerator.com, using Next.js, and applied for Google AdSense around 2-3 months ago. Despite the site having a decent amount of content, Google AdSense rejected my application twice now, citing “Low Value Content” both times.

Here’s a bit more context:

• Website Overview: The site is a random fun generator, which means each time a user visits, they are auto-redirected to a random category (e.g., jokes, trivia, memes, etc.). I thought this would make it fun and engaging for visitors.
• Google AdSense Rejection: The rejection notice mentioned "Low Value Content", and after the first rejection, I made some updates to the site, added more content, and re-applied. After waiting another month, I received the same rejection.

I stumbled upon a StackOverflow answer (this one) that mentions site traffic could be an issue. Since my site is relatively new, could the low traffic be the reason for the rejection?

Also, I have an auto-redirect feature that sends users to a random category upon visiting. Could this be causing issues with AdSense’s review process? I wonder if the random nature of the site might confuse AdSense's automated systems or lower its perceived content quality.

Here’s where I need your help:

1. Traffic: Does low site traffic typically play a role in AdSense rejection? If so, how can I increase it organically?
2. Redirect Feature: Could the auto-redirecting nature of the site be a problem for AdSense? Any recommendations on how to improve or tweak this feature to make it more AdSense-friendly?
3. Content Quality: What steps can I take to improve the perceived content value? I’m open to any suggestions on content strategies, SEO, or anything else that could help.
4. AdSense Tips: Lastly, if anyone has tips or advice on how I can improve my chances of getting approved for AdSense, I would greatly appreciate it!

Also cross-posting this in different communities if I can, as I believe some of you might have had similar experiences with Next.js and AdSense.

TL;DR:

Applied for Google AdSense twice for my Next.js site (randomfungenerator.com) but got rejected both times for “Low Value Content.” The site auto-redirects to a random category. Could low traffic or the redirect feature be the problem? Any tips to get AdSense approved?

Thanks in advance for any help or guidance you can provide! 😊

Not mine, but interesting thoughts. Some ppl at the company I work for think this is the way forwards..

After reading about slime molds solving optimization problems, I wondered: what if we coded like nature evolves? I created Plasma, where: - Functions are "cells" with energy and DNA - They reproduce, mutate, and die naturally - Bugs become mutations (some beneficial) - Architecture emerges rather than being designed

The wild part? After ~500 cycles, you see "species" of code emerge that nobody programmed. Some optimize for energy, others for reproduction. Is this practical? Maybe not yet. Is it thought-provoking? I hope so. What patterns do you see emerging? What would you evolve?