ROS again...

My projects currently have a monolithic structure where different parts are tightly coupled. Development in this situation requires careful work within the app's context, considering all dependencies. As we've seen, AI struggles with context handling. So we need a different approach - app components need more isolation, something like a microservice architecture.

While discussing my Focusing utility with Claude 3.5 Sonnet, it started suggesting a new structure: core and support services, dataflow with various message types (commands, answers, data packets), event-based communication... As the conversation progressed, I suddenly realized something familiar in all this - of course, The Robot Operating System (ROS)!

I actually worked with this powerful system a couple years ago on my pet robot project. And you know what? It seems to have everything we need:
1. Built-in Features:
├── Message passing system
├── Topic pub/sub
├── Service calls
├── Action servers
├── Parameter system
└── Launch system

2. Tools Available:
├── rqt (GUI development)
├── rviz (visualization)
├── rosbag (data recording/playback)
├── ros2 doctor (diagnostics)
└── built-in logging

Perfect! So, ROS again. Let's dive into design!

The cause is DeepSeek, a Chinese AI model that costs drastically less to train compared to competitors:
• OpenAI: $6 billion
• Meta’s Llama: $60 million
• DeepSeek: $5.6 million

ROS2 - Understanding services

ROS is built around nodes - independent programs that each handle a specific task in your system (data network). For example, one node might control motors, while another processes camera data.

These nodes need to communicate with each other, and ROS provides several communication methods. One key method is services, which enable request-response communication between nodes. Think of services like function calls between nodes - one node (the client) requests something, and another node (the server) processes that request and sends back a response.

For example, a camera node might provide a "capture_image" service that other nodes can call when they need a new image. This is different from continuous data streaming (which uses topics) because services are specifically for on-demand, request-response interactions.

Key Benefits of ROS2 Services:
├── Request-Response Pattern
├── Services provide a synchronous request-response communication model
├── The client sends a request and waits for a response from the server
├── This is ideal for on-demand, one-to-one interactions between nodes
├── Guaranteed Delivery
├── Unlike topics which use publish/subscribe, services ensure the request reaches the server and gets a response
├── The client knows whether the service call succeeded or failed
├── Good for critical operations that need confirmation
├── Resource Efficiency
├── Services don't continuously stream data like topics
├── They only transmit when explicitly called
└── More efficient for occasional/periodic interactions

Perfect for Specific Use Cases:
├── One-time configurations
├── Computing results on demand
├── Robot control commands that need acknowledgment
└── System queries that expect a response

Better Error Handling
├── Services provide explicit success/failure feedback
├── The client can implement proper error handling
└── Helps build more robust systems

Synchronous Nature
├── Blocking calls ensure operations complete in sequence
├── Critical for tasks that must happen in order
└── Provides clear control flow in the application

The key is choosing between services and topics based on specific needs:
- Use services for request-response patterns
- Use topics for continuous data streams

Services are optimal when you need:
❕Guaranteed delivery
❕Operation confirmation
❕Explicit error handling
❕Sequential execution
❕One-time or periodic interactions

#ROS #knowledge

ROS2: Modular & Resilient Node Parameters

In ROS2, each node controls its own settings, creating a system that’s both modular and remarkably resilient. What’s more, ROS2 comes with a rich array of built-in methods for managing parameters, making your nodes even more flexible and robust:

• Decentralized Control:
Each node declares and manages its own parameters, creating a plug-and-play architecture that minimizes risk and enhances robustness.

• Dynamic Adjustments:
Built-in APIs let you update parameters on the fly—no need for restarts. Change callbacks ensure that live updates are smoothly integrated into your node performance.

• Extensive Built-In Methods:
ROS2 provides a variety of tools, from dynamic parameter handling to advanced introspection methods. This extensive toolkit offers everything needed—from automatic type checks to seamless integration of new configurations—making error handling and system adaptation straightforward.

• Intuitive Organization:
Use namespaced parameters, coupled with thorough inline documentation, to keep configurations neat and scalable. This clarity not only aids team collaboration but also simplifies long-term maintenance.

• Streamlined Configuration Management:
Centralized YAML or launch files allow you to manage settings consistently across development, testing, and production environments without fuss.

• Real-Time Monitoring:
Built-in introspection tools and logging capabilities keep you informed of parameter changes as they happen, ensuring that your system remains agile and well-monitored.

This node-centric approach, enhanced by an impressive suite of built-in methods, emphasizes modularity and resilience—empowering you to build dynamic, high-performance ROS2 applications with ease and confidence.

#ROS #knowledge

Working with Parameters in ROS2: A Quick Example

1️⃣ Defining Parameters:
Using ParameterDescriptor, we define parameters like focal_length with details such as:
- Type: PARAMETER_DOUBLE
- Description: "Focal length in mm"
- Range: 1.0 to 100.0, step 0.1

2️⃣ Access & Modify Parameters:
- Use the CLI with commands like ros2 param get/set.
- Alternatively, use a GUI to adjust values in real time for better flexibility and usability.

3️⃣ Error Handling:
ROS2 comes with built-in methods to validate parameters based on their descriptors. For example, if you try setting focal_length to 40.44 (which doesn't match the step size of 0.1), you get a precise error:

"Setting parameter failed: The value is not close enough to a valid step."

❗️This means ROS2 ensures parameters strictly follow the defined constraints—like ranges, step increments, and types—without requiring custom validation logic in your code.

#ROS #knowledge #example

🤔 Why I'm not surprised:

Our analysis shows that the total server CapEx for DeepSeek is ~$1.6B, with a considerable cost of $944M associated with operating such clusters.

https://semianalysis.com/2025/01/31/deepseek-debates/

Salesforce: We don't need any more software engineers this year...

📢 Use Mistral's Latest Coding Model for Free in Your Work!

Recently, Mistral announced their newest code-specific LLM - Codestral 25.01. The best part? You can get an API key absolutely free and start using it right away in popular tools like VS Code through Continue - one of the most popular AI coding assistants!

Get instant code suggestions, explanations, and completions right in your editor. 🚀

#FreeTool

🤖 Playing with Codestral Model API via Postman 🛠

Now that we have access to the Codestral Model API, let's explore it using REST API requests to see how it responds to different parameters! For this purpose, I recommend using Postman - a free tool that provides convenient features for working with APIs 🔧

🚀 Getting Started:
- Create a workspace in Postman
- Create a collection inside it to store your requests

🔌 Available Endpoints:
- Fill-in-the-middle: https://codestral.mistral.ai/v1/fim/completions
- Chat: https://codestral.mistral.ai/v1/chat/completions

💻 Let's experiment with the chat endpoint using a POST request. We'll modify the parameters from the API docs to focus on a coding task: generating a function to calculate Fibonacci numbers.

🔑 Authorization: For authorization, you'll need a Codestral API key (see my previous post for instructions on obtaining one). Pro tip: store such sensitive data in variables!

⚙️ Testing: After sending the modified request, you can observe the model's response. All model parameters are customizable to fine-tune the output.

API documentation

#CodestralAPI #Tutorial

🤖 Why Learn Programming in the AI Era?

Yes, AI can write code as well as humans now. We can simply copy-paste its solutions and problem is done! But is this the way we want to go?

👋 Here's the smarter way:
• Programming itself is a creative journey that trains your brain and brings satisfaction.
• Understanding code lets you collaborate with AI effectively - you can discuss approaches, evaluate solutions, and guide the AI toward better results.

💪 With coding knowledge, you can:
• customize AI-generated solutions,
• spot potential issues,
• break down complex problems,
• make informed architectural decisions.

Think of AI as your smart coding buddy! It can help you level up from a regular developer to a tech architect - it's a unique opportunity that's only possible today. But to seize it, you need to be at your best and keep growing your skills!🚀

We should be the ones who direct AI, not the ones who blindly follow it. What do you think?

#Programming #AI #CodingLife #TechEducation

Microsoft Study Finds Relying on AI Kills Your Critical Thinking Skills

Read Full Article

#AI #CriticalThinking #Technology #MentalSkills #MicrosoftStudy

ROS2 Nodes Factory

I'm excited to share a project I've been working on recently: a ROS2 nodes factory! 🛠

After taking a short break from my regular posts, I've been focused on developing a framework that can automatically generate ROS2 components using AI. The project, called Codestral ROS2 Generator, is now available on my GitHub page.

⚠️ What makes this project special?

The framework follows a "test-driven coding" philosophy - you simply define your ROS2 interfaces and write tests for how your node should behave. Then the generator, powered here by Mistral's Codestral latest model, creates code that satisfies those requirements.

For example, I've included a working implementation of a service that calculates object height (remember my previous experiments with this). The generator was able to create a fully functional ROS2 service node that passes all 14 tests.

🚀 Getting started

📓Project's README and Example instruction explain how to setup and use the generator - you can try it in action.
📔 The documentation explains the system architecture and guides you through creating custom ROS2 nodes for your specific needs.

The project integrates with Mistral AI's powerful Codestral model to understand ROS2 concepts and generate appropriate code. While my previously described method for getting Codestral API keys is not supported yet, you can obtain a free experimental key from the API Keys section of La Plateforme, which works perfectly with this project (also it allows to try any other Mistral models).

🤝 Contributions welcome

I'd love to collaborate with anyone interested in improving this framework. Whether you want to add support for more ROS2 components, improve the code generation, or enhance the examples, contributions are very welcome!

Happy generating! Let me know if you try it out!

#ROS #Codestral #CodeGenerating