DEV Community: Valacor

Rust: A JSON parser

Valacor — Sat, 27 Sep 2025 19:52:57 +0000

It's bin a while since I wrote my last Rust code so I thought why not writting a little JSON parser. So I fired up my vscode.

Json consists of the same types that JavaScript has (well Javascript Object Notation).

Json types

boolean
number
string
array
object

Rust representation

So how can I represent these types in Rust? Well enums have a very cool feature where every entry can wrap one or more types.
Here we go:

#[derive(Debug, PartialEq)]
pub enum JsonType {
    Object(HashMap<String, JsonType>),
    Array(Vec<JsonType>),
    String(String),
    Number(i64),
    Decimal(f64),
    Boolean(bool)
}

The properties of an object are stored in a HashMap where JsonType can be any of the other representations inside the enum. For arrays I use a Vector. This is a growable array type which also holds our JsonType. I required two entries for numbers because there are different types for floating-point and integer numbers and String/Boolean are represented by the according build-in types.

There could be parsing errors due to unexpected/missing tokens or a feature is not supported (e.g nested arrays). I represent them by the ParserError type:

#[derive(Debug, PartialEq)]
pub enum ParserError {
    UnexpectedToken(String),
    InvalidSyntax(String),
    MissingToken(String),
    EmptyInput,
    NotSupported(String)
}

Parsing logic

pub fn parse_json(mut input: &str) -> Result<JsonType, ParserError>  {
    if input.trim().is_empty() {
        return Err(ParserError::EmptyInput);
    }

    input = &input.trim_start();

    match input.chars().nth(0).unwrap() {
        '{' => {
            // Parse JSON object
            match parse_object(&input) {
                Ok(obj) => Ok(JsonType::Object(obj.0)),
                Err(e) => Err(e)
            }
        },  
        '[' => {
            // Parse JSON array
            match parse_array(&input) {
                Ok(arr) => Ok(JsonType::Array(arr.0)),
                Err(e) => Err(e)
            }
        },
        _ => return Err(ParserError::UnexpectedToken(format!("Unexpected token: {}", input.chars().nth(0).unwrap())))
    }
}

What do we have here? This method is our starting point which takes a string slice as a parameter and returns a Result<JsonType, ParserError>. Results represent either OK or Err.

JSON's top-level type is either an array or an object. So we take a look at the first character and depending on the sign we parse an array/object or we return a ParserError.

Now the code for the implementation of the object parsing function (If you want to see the complete code visit the link included above):

fn parse_object(mut input: &str) -> Result<(HashMap<String, JsonType>, &str), ParserError> {
    let mut result = HashMap::new();

    if input.chars().nth(0).unwrap() != '{' {
        return Err(ParserError::InvalidSyntax("Object must start with '{'".to_string()));
    }

    input = &input[1..].trim_start();

    loop {
        // Parse each key-value pair
        if (input.chars().nth(0).unwrap()) == '}' {
            return Ok((result, &input[1..])); // Empty object
        }

        match parse_string(&input) {
            Ok(key) => {
                // Expect a colon
                input = key.1;

                if input.chars().nth(0).unwrap() != ':' {
                    return Err(ParserError::MissingToken("Expected ':' after key".to_string()));
                }

                input = &input[1..].trim_start();

                let value = if input.chars().nth(0).unwrap() == '{' {
                    match parse_object(&input) {
                        Ok(obj) => {
                            input = obj.1;
                            JsonType::Object(obj.0)
                        },
                        Err(e) => return Err(e)
                    }
                } else if input.chars().nth(0).unwrap() == '[' {
                    match parse_array(&input) {
                        Ok(arr) => {
                            input = arr.1;
                            JsonType::Array(arr.0)
                        },
                        Err(e) => return Err(e)
                    }
                } else if input.chars().nth(0).unwrap() == '"' {
                    match parse_string(input) {
                        Ok(s) => {
                            input = s.1;
                            JsonType::String(s.0)
                        },
                        Err(e) => return Err(e)
                    }
                } else if input.chars().nth(0).unwrap() == 't' || input.chars().nth(0).unwrap() == 'f' {
                    match parse_boolean(input) {
                        Ok(b) => {
                            input = b.1;
                            JsonType::Boolean(b.0)
                        },
                        Err(e) => return Err(e)
                    }
                } else if input.chars().nth(0).unwrap().is_digit(10) || input.chars().nth(0).unwrap() == '-' {
                    match parse_number(input) {
                        Ok(n) => {
                            input = n.1;
                            n.0
                        },
                        Err(e) => return Err(e)
                    }
                } else {
                    return Err(ParserError::UnexpectedToken(format!("Unexpected token in object value: {}", input.chars().nth(0).unwrap())));
                };

                result.insert(key.0, value);
                input = input.trim_start();

                // Check for comma or end of object
                if input.chars().nth(0).unwrap() == ',' {
                    // Move past the comma
                    input = &input[1..].trim_start();
                } else if input.chars().nth(0).unwrap() == '}' {
                    input = &input[1..].trim_start();
                    break; // End of object
                } else {
                    return Err(ParserError::UnexpectedToken(format!("Expected ',' or '}}' in object, found: {}", input.chars().nth(0).unwrap())));
                }
            },
            Err(e) => return Err(e)
        }
    }

    Ok((result, &input))
}

I want to explain the concept these methods follow: So each method returns in the success case a tuple containing the parsed element as well as a string slice.
The slice is the remaining json after the parsing logic. This will be used in the calling parsing method as the point where it should continue.

For reading a JSON object we need a loop that continues reading properties until it encounters a }. Every property contains of a name:value pair. The name is always a string so we can reuse our string parsing method. If this was successful we read the : and then check the next character. Depending on this sign we go into the appropriate reading method. When this operation was successful we set the remaining slice and create the correct JsonType. The last step is adding the key-value-pair to our hashmap.

Feel free to send us suggestions, bug reports and improvement ideas🙂

🏆003. Brainstorming is key

Valacor — Fri, 26 Sep 2025 21:14:57 +0000

A few days ago I wrote about burnout and that I feel exhausted. Now I found a way to clear my mind completely so there is more disk space available for new ideas/thoughts.

The tool is called `brainstorming`

Every day one hour before I go to bed I take my tablet and start OneNote. Then I create a new page and just start to draw/write what currently comes into my mind.

The most important part is that I don't force myself what to think. I just note everything down that currently comes into my head.

This can be:

Ideas for apps/software systems
Innovative products/services
Complex social challenges
What is currently fucking me up
What I achieved this day/week

This has two advantages:

I process ideas by defining them through words
My head is cleared when I go to sleep giving me a better quality sleep

OneNote

For this task I think it's one of the best tools available. While pen and paper gives you more freedom what you can draw/write and how you represent it there is also a space limit. This makes it very difficult to create a big brainstorm page.

On the other hand digital tools like Notion or Mindmapping software has limits in the representation of the information or ways of creating that are not that intuitively.

OneNote resolves the different problems by providing an infinite creation space combined with the flexibility of drawing and writing by using a pen.

🏆002. HTTP-TO-MCP bridge

Valacor — Fri, 19 Sep 2025 20:26:10 +0000

This week my biggest win was the creation of a bridge between the .NET MCP SDK and a custom HTTP stack.

The relevant MCP SDK classes

For the implementation I required an interface to get the JSON RPC messages from the HTTP body to the MCP server. I didn't want to implement the complete MCP Server from the ground up so I use the server fromt the SDK.
The creation is handled by the static method McpServerFactory.Create().

The method accepts four parameters:

ITransport - Represents a channel that the MCP server uses to read and write JsonRpcMessages.
McpServerOptions - Configuration for the MCP server like available tools, prompts or the server name and version.
ILoggerFactory (optional) - Provides logging capabilities to MCP stack
IServiceProvider (optional) - Not important for this system

This method returns an instance of the McpServerclass which implements the IMcpServer interface. We can use the RunAsync() method to run the MCP stack which basically represents a long-running task which continuesly reads and process JsonRpcMessages and writes the response back to the transport.

We run two tasks on different ThreadPool-Threads. The HttpServer task to process http requests and the McpServer task to process JsonRPC requests.

Problem: How to get the JSON messages from the HTTP body to the MCP server?

Channels

A channel represents a tunnle from one thread to another allowing the sender thread to write data into it. The other thread can then read the data.

The channel is basically a queue using the FIFO principle which means the first message that was written to the channel is the first one consumed on the other thread.

For our problem we need two channels:

One sending from the HTTP thread to the MCP thread
Another sending the MCP response back to the HTTP thread

The 'ITransport' provides two entities that fit very good to this concept. A ChannelReader<JsonRpcMessage> which allows the MCP server to read the JSON RPC requests and the SendMessageAsync to write a RPC response.

So we just give the Reader from the HttpToMcp channel to our custom ITransport implementation and the Writer from the McpToHttp channel is used in the SendMessageAsync. The counterpart (HTTP thread) is reading the RPC messages from the body and enqueue them in the HttpToMcp channel. The reader from the other channel is used in the HTTP thread and then writes the JsonRpcMessages to the NetworkStream.

Conclusion

This project is not finished yet and is just a stateless implementation but I learned a lot:

How works the .NET MCP SDK
What is streamable HTTP
What is the streamable HTTP MCP transport
How works the custom HTTP-Stack
.NET Channels
A better understanding for Multi-Threading

Interaction between developers and other departments

Valacor — Sun, 14 Sep 2025 14:31:13 +0000

I'm working in a little company as a Software Engineer. In my daily work I encounter different problems between the development department and the members of the other once (Marketing, Sales, Product Management).

What the departments need

💹 Marketing

Needs to understand what the key benefits of a specific feature/product is. This is required to come up with a strategy on how to market the specific component. What messages will be the best to transport the benefits?
For this reason the marketing collegues need to understand the core working and what problem is solved.

📉 Sales

The sales collegues need similar information as the marketing team but with a little more inside knowledge. They do not need some general message they need for a campaign but enough knowledge to adapt to each customer situation and needs. Therefore they must be able to adapt to different use cases and transfer this to the best solution for the client.

📦 Product Management

Understands what problems the customers face and have a superficial
understanding of the technical side of our product. This department mostly needs the help from development and their technical knowledge to bring a product feature to life. It is important to show an understanding that they often lack the knowledge of technical insides.

👨‍💻 Development

We as software developers need well definied Requirements. How should the feature look like? What is the state that marks the feature as complete? Where in the architecture is the best place to fit in the feature?

🚩 The problem

Product management misses some clear requirement definition which is frustrating the developers because they have to get more information from other persons. The developers show this to product management by letting them know what is missing but the tone plays the music.
Also I observe from time to time that engineers love to show off there knowledge often makes the participants in the conversation feel uncomfortable. This created a big gap between engineers and the other departments

💡 Possible solutions

Knowledge transfer between software developers and product management. This will help the product management team to get a better knowledge about the software architecture and the components
Create a transfer position. Someone that has a very good technical understanding but is also able to transfer the complex technical details into easy-to-consume information for the other departments. Therefore someone is required with the skil to be able to explain technical details in a simple way
Training for developers on how to get into the view of collegues from the other departments and how to communicate with someone else in a respectful manner that do not have the same technical knowledge
Get representatives from every department on one table. There everybody has the chance to speak open about the problems with the other departments.

In general I think we lost our ability to talk to persons with other interests/views. We all insist on our mindset and concepts. But talking to each other and consider the ideas of others will bring us far more forward.

🏆001. Wins of my week🏆

Valacor — Sat, 13 Sep 2025 01:11:40 +0000

🎥 Project went into testing

On my 9-5 I had a very big research project. The goal was the development of a custom end-to-end test framework for one of our products. On Wednesday I was finally able to finish this task and it is now waiting for the review of our test engineer. Let's see how it goes...🙂

🧪 Experimenting with the .NET MCP SDK

I want to understand the SDK in more detail so I played around with the transport bridge between transport layer and MCP Stack. First I had a look into the different Implementations of the ITransport interface and played with the StreamServerTransport. The goal is to connect the MCP stack with a custom HTTP stack.

🔎 Deep work

I want to get into this very cool state of flow. Where the time just goes by and everything seems to fit together. When I have to write code I pretty easy get into this state but when I have to learn/read/think it's still a little bit difficult. So I dedicated some time slots where I practised that.

📝 Making my first post

This week on thursday I published my first post on dev.to. It feels great to share my ideas here. Let's see what I will learn from blogging.

🧠Too much on my mind🧠

Valacor — Thu, 11 Sep 2025 18:32:19 +0000

💡I have a lot of ideas in my mind:

Writing my own HTTP server
Coding some MCP servers to practice
Participate in hackathons
Develop my own social network

The list is endless and then there are the responsibilities in the real world. Working my 9-5, doing a work out and taking care of family/friends. I want to go deep for each topic but unfortunately the day has only 24 hours. Honestly i feel burned out.

❓The question: How can I manage all this stuff?❓

Recently I reduced my 40 hours week to a 32-hour-week

This gives me the time to restore my energy level and buys me more resources for other topics that are currently more important to me.

Learn to prioritise

Often it feels like everything should get the highest priority. I never really learned this important skill. I've heard about the Eisenhower Matrix but I actually have not yet got the concept behind it. Lets see where I will stand in a few months.

Concentrate on the current most important challenge

I'm not able to shut down my thoughts about the other tasks when im working on the current one. Even when I put them down on paper or into a notebook i can't stop thinking about them.

Ideas

Making some kind of challenge weeks where I go for one project after another and after a week the result I created is just fine. Well the way is more important, right?
Just fire up a note program and put everything in it what comes into my mind. It doesn't matter in what order the things come out. It's only important to get them out and maybe there are some cool results
Going for a walk leaving digital devices behind.
Maybe it's time for a mindset shift. It should not matter that the project is not completed the way it was designed but what new skills/knowledge i achieved

Do you have similar experience? What are you're strategies to solve those problems?