Using Claude AI to generate Ring language code, and PWCT2 to visualize and update that code

[Mahmoud Fayed]

Hello

While on vacation, I decided to explore more AI tools. Although I use Windows Copilot every day with great results, I wasn’t satisfied with the quality of the Ring code it generated. It wasn’t good enough, so I avoided using AI for Ring code generation.

But I decided to give Claude AI a try, and I was shocked by how powerful it is at generating Ring code. It’s a game changer for me. I tested it with multiple design patterns, and the model clearly understands the language’s concepts—variables, lists, classes, functions, and more. It was also straightforward to guide it to use the Ref() function whenever references were needed. Also, to use the (Main program) code before classes code.

While this alone would have been enough to get useful results, I was even happier when I tried generating GUI code with RingQt. It seems this model is very well trained.

I tried this prompt:

Write a program using the Ring programming language and RingQt that ask the user to enter 5 numbers then display the maximum number, minimum number and the average number

Reading the generated code was really fun: https://claude.ai/public/artifacts/4c2173c7-991e-4440-aeec-acdcd4c87a60

I copied the code, opened PWCT2, and pasted it into the search text box. I know these copy‑and‑paste steps are manual, but after that PWCT2 converts the code into a visual program (Steps Tree + Interaction Pages + Time Dimension). Then I can click Play as Movie to watch the program being constructed step by step.

PWCT2 (Steam): Programming Without Coding Technology 2.0 on Steam

PWCT2 (GitHub): PWCT/PWCT2: Programming Without Coding Technology - Second Generation, written in the Ring programming language!

If you haven’t tried this combination (Claude AI + PWCT2), give it a try — it’s fun!

Greetings,

Mahmoud

[Youssef Saeed]

Hello Mahmoud,

I completely agree! Claude is truly impressive when it comes to generating Ring code. In my experience, the Claude Opus 4.5 model has been a total game-changer—its understanding of the language logic and syntax is incredibly precise.

Best regards,
Youssef

[Mahmoud Fayed]

Hello Youssef

You are welcome, we can use this topic in the future to share related samples generated by Claude AI

* Observer design pattern using Ring

https://claude.ai/public/artifacts/0408bc09-7195-4f40-81df-99ad8ba0c8a7

* MVC design pattern using Ring

https://claude.ai/public/artifacts/4d052ea0-896b-4c7e-8ac0-e76303102a9f

Greetings,

Mahmoud

[Mahmoud Fayed]

Hello

Application: ToDo List using Ring/RingQt by Claude AI

Development Time: 28 minutes

URL: https://claude.ai/public/artifacts/efd1544f-cb5a-4280-877c-1db677163133

Things that I told Claude AI about it

1. Main code always comes before class definitions
2. Use QApp instead of QApplication
3. Some Qt methods may not be available yet in RingQt
4. addItem() behaviour differs between widgets (QComboBox needs 2 params, QListWidget needs 1)
5. Event handlers use Method(:functionName) syntax
6. MVC pattern requires specific naming conventions and structure
7. View widgets are created directly in class body, not in methods
8. Avoid variable naming conflicts, especially with Qt dialog results

When I test and get a runtime error, I just give the error message to Claude, and the code is updated to avoid the problem

i.e. The level of detecting the error source and solving it is very high, which is fun!

The program in PWCT2

Greetings,

Mahmoud

[Azzeddine Remmal]

Hello Mahmoud

Welcome everyone to the AI ​​Arena

There's a rule in football that says no matter how fast you are, the ball is faster than you.

The meaning is that teamwork is what makes a team successful.

During my discussion with Gemini 3, I brought up the idea of ​​speeding up the language.
I'd like your opinion on what he says.

----------------------
This is the kind of advice that should be written in gold. You don't want "crutches" (extensions), you want to strengthen the legs (the core).

Developing the Ring language itself to be as fast as C++ while maintaining its flexibility is a huge project, but it's very possible if we know where to strike. Based on my analysis of the header files (ring.h, ring_list.h, ring_item.h), here's a roadmap for developing the Ring core (Ring Core Optimization) to become a performance monster:

1. Fix the list structure: "The Hybrid List"

Current problem:
In ring_list.h, the lists are Doubly Linked Lists.

Advantage: Adding and deleting is very fast.

The fatal flaw: Random access (aList[1000]) is very slow, and memory is scattered (cache misses).

Suggested improvement (in ring_list.c):
Modify the List structure to include an additional pointer to a connected C array (Vector/Array).

When the list contains only numbers (such as training data), we internally convert it to a C array.

When the user requests aList[i], we go directly to the array (O(1) O(1)) instead of jumping through nodes.

Code change (idea):

C
download
content_copy
expand_less
typedef struct List {
struct Items *pFirst; // Old

struct Items *pLast; // Old
int nSize;
// --- New addition ---
void *pArray; // Pointer to a connected array (cache)

int nArrayType; // Array type (Double, Int, Item)

int isArrayDirty; // Has the list changed and we need to update the array?

} List;

This modification alone will make data processing 10 to 50 times faster.

2. String View/Slicing

Current Problem:
In ring_string.c, a function like `substr` creates a new `malloc` and copies the characters. In NLP (Numerical Line Processing), this is memory-intensive.

Proposed Improvement:
We add a new type in ring_item.h called `ITEMTYPE_STRINGVIEW`.

This type has no string of its own.

It only has: a pointer to the original string + the start + the length.

Result: Tokenization and data processing will become zero-copy and lightning-fast. 3. Vectorized Instructions in the VM

Current Problem:
When you write `aList1 + aList2` in Ring, the VM performs a loop, calling `ring_vm_add` for each element and checking the type each time.

Proposed Improvement (in ring_vmmath.c):

Add a smart check at the beginning of the addition operation:

"Do the two lists contain only numbers?"

"Are they stored as pArrays (Modification 1)?"

If yes:

Call a C function that uses SIMD (AVX/SSE) to add the entire array in one go.

This transforms regular Ring code into NumPy-fast code without the user even noticing!

4. Fast C Function Calling Improvement

Current Problem: Calling a C function passes through the RING_API layer, which checks and retrieves the parameters one by one.

Proposed Improvement:

Add Typed Functions.

If we define a function in Ring and specify that it accepts (int, int), the VM can bypass checks and pass values ​​directly to the C stack.

Summary: The "Jibrail Core" Action Plan

You don't need a new library. You need to modify the following files:

ring_list.c: Add support for Contiguous Memory for numeric lists.

ring_string.c: Add support for String Views.

ring_vmmath.c: Add a Fast Path for mathematical operations on lists.

If you implement only point number 1 (Contiguous Lists), the performance of DataLoader and data processing in your project will jump to a whole new level, and you'll only need RingTensor for very complex operations.

Shall we start by trying to modify ring_list.c to add an Array Cache feature? This is the ultimate solution to slowdowns.

---------------------------------------------------------
my regards Azzeddine

[Mahmoud Fayed]

Hello Azzeddine

>> "This is the kind of advice that should be written in gold. You don't want "crutches" (extensions), you want to strengthen the legs (the core)."

(1) This idea doesn’t align with the design principles of the Ring language.
Ring is meant to be a lightweight and flexible language — a small implementation like Lua, but with advanced features comparable to Python, Ruby, and more.
To achieve this without sacrificing stability, we keep the implementation as simple as possible.

i.e. the KISS principle:  KISS principle - Wikipedia

(2) This design enables small team to keep the language implementation alive and moves forward faster 

(3) This doesn’t mean we don’t care about performance or ignore suggestions. In reality, we do apply them, and Ring’s performance has improved over time — but we approach these changes carefully.

>> "1. Fix the list structure: "The Hybrid List""

>> "The fatal flaw: Random access (aList[1000]) is very slow, and memory is scattered (cache misses)."

(1) Ring lists are designed for flexibility, mixing items of different types, nested lists, etc. 

(2) The List() unction already allocates memory as a contiguous block to store the list items, and it uses an array of pointers to access any item quickly without traversing the list one by one. The key is achieving this without compromising the flexibility of lists.

(3) One of Ring’s core design principles is keeping the number of data types small. A variable can be a Number, String, List, or Object — we don’t use static typing or typed arrays. Features like that can certainly be explored in separate implementations of the language (as our friend Ilir Liburn is already doing).

Introducing such changes would not only increase the complexity of the implementation but also require a different coding style in Ring to handle these new types.
This leads to a different user experience: you may gain performance, but you lose the simplicity and compactness of Ring code.

>> "This modification alone will make data processing 10 to 50 times faster."

(1) We are not modifying a sample or simple use-case to expect this 

(2) We achieve these performance improvements through extensions like RingFastPro. Because the functions are written in C, multiple factors contribute to the speed — not just arrays, but also native machine code, the absence of a VM loop, and more. This design enables us to have the better performance when needed (Through RingFastPro) while still having simple, lightweight & flexible programming language implementation.

(3) Inside the Ring VM, using pure arrays instead of lists yields only about a 3× performance improvement. This is just an approximation, and achieving it introduces other challenges. How do I know that? Because Ring strings are already an array of bytes, where each element is a single byte. Testing (Ring Lists) vs (Ring String) for accessing elements where each element is 1-byte will give you the real results.  Also, when we optimized (functions calls) in Ring VM, one of the ideas was to replace (Ring Lists) with (C Arrays), we get from 2x to 3x better performance.

>> "2. String View/Slicing"

>> "a function like `substr` creates a new `malloc` and copies the characters. In NLP (Numerical Line Processing), this is memory-intensive."

(1) Ring VM uses a memory pool, so malloc() is not very expensive (In many cases). We can enable/disable the memory pool and see the performance difference.

(2) We create a new string, because it could be modified without altering the original version

(3) While the suggested optimization could be useful in string‑processing applications, we already have a fast-enough implementation. For example, the code generator for the RingQt extension processes hundreds of files and generates hundreds of thousands of lines of code in about 3 seconds. (This used to take around 22 seconds before our friend Mounir IDRASSI optimized string processing in the VM.)

(4) We already have QString class, and C extensions could be used if more features are required or better performance.

>> "3. Vectorized Instructions in the VM"

This could be done at the libraries level, not the VM level, to keep the principles stated above.

i.e. extensions like RingFastPro

>> "4. Fast C Function Calling Improvement"

>> "Current Problem: Calling a C function passes through the RING_API layer, which checks and retrieves the parameters one by one."

>> "Add Typed Functions."

(1) Checking types is done to easily discover errors, this is done at each C function written using Ring API

(2) Many of such functions are generated using the Ring code generator for extensions, if you want to do such an optimization (Ignore checking types), just update the code-generator and have non-safe but faster version of extensions. 

(3) While I know this optimization, I don't think the performance difference will be huge, to know the cost of Ring API from real use case you will need to measure, but I think it's not a bottleneck.

==============================

Comments about this topic in general

==============================

(1) I know specific areas to improve Ring VM performance, without changing the principles, it's just a matter of time where I apply such updates, the point is these are not a priority for now, because such updates could bring better performance like from 2x to 5x faster, but C extensions could bring from 20x to 100x better performance in many cases, That's why C-extensions is the way to go if your goal is performance.

(2) As mentioned, our friend Ilir Liburn focuses on Ring’s performance and is working on features such as static typing, arrays, native compilation, game programming, and more. This is a separate project—related to Ring, but not something we can fold into the same core (the original Ring VM implementation). The current design principles are a major reason behind Ring’s stability and overall success.

(3) I have a separate vision for improving Ring performance, that's why In Ring 1.25 we have (MyCTiger) tool and new VM functions to process Ring Object Files. But such a vision could be realized though (separate tools), i.e. not updating the current implementation.

(4) What I care about in 2026 is pushing Ring forward in areas like the Natural Library, domain‑specific languages, and visual programming (PWCT2). I want Ring to be exceptionally productive compared to other languages — that has always been the original goal. If my priorities were purely performance‑oriented, we already have C, C++, D, Rust, Zig, Odin, and for fast dynamic languages we have Julia, Mojo, and others.

What makes Ring unique is my priority.

 

Greetings,

Mahmoud

[Azzeddine Remmal]

Hello Mahmoud,

Thank you for your convincing and detailed explanation regarding Ring's design philosophy.

I fully understand and appreciate the focus on simplicity and flexibility that makes Ring unique.

My goal has always been to push the boundaries of what can be achieved with Ring in the field of Scientific Computing and AI.

I am happy to share that I have successfully built a full Deep Learning framework from scratch using Ring.
RingTensor: A high-performance C-extension (following your advice) that handles matrix operations using zero-copy managed pointers.
RingML: A library implementing a Multi-Layer, Multi-Head Transformer (GPT-style architecture).
Adam II: A working language model capable of learning and generating text.

I am currently working on an experimental C++ extension (codenamed "AlQalam") to further optimize the data flow and bridge the gap between Ring's flexibility and C++ speed.

The model has successfully memorized and reproduced short datasets (over 1k sentences) with high accuracy.

The current challenge I am tackling is scaling the training loop to handle massive datasets efficiently on consumer-grade CPUs.
Your insights are always the compass that guides this project.

A snapshot from today's translation training

Best regards,
Azzeddine

[Ilir Liburn]

Hello All,

(2) As mentioned, our friend Ilir Liburn focuses on Ring’s performance and is working on features such as static typing, arrays, native compilation, game programming, and more. This is a separate project—related to Ring, but not something we can fold into the same core (the original Ring VM implementation). The current design principles are a major reason behind Ring’s stability and overall success.

Yes, and it is nicely progressing. Core idea is to allow conversion of the official Ring code to typed version which then can be translated to C language with better performance by avoiding dynamic code execution which involves memory pool allocation/deallocation, types check, etc.

Regarding better performance in official Ring: binarysearch function internally generates array for better performance. Similar function can be added to internally generate array on user request. List is already destroying internal array if it is modified by calling the ClearCache.

Greetings,

Ilir

[Antonio F.S.]

Hello everyone.

So, which version should be used to work with Ring, Ilir's version or
the official one?
I always thought that instead of creating separate clones of the same
language, it would be more logical to enhance one language to cover all
the possible improvements those clones might bring.

Maybe I'm just too old-fashioned, and I don't blame myself for it, since
I'm 63 years old. :-) :-)

Best regards,
Antonio F.S.
-----------------------------------------------------------

El 17/1/26 a las 12:46, Ilir Liburn escribió:

[Ilir Liburn]

Hello Antonio,

official version, of course. As Mahmoud stated: The current design principles are a major reason behind Ring’s stability and overall success.

My version is optional version which developer can use after project developed using official Ring is completed. Optional version will make sense only once translation to C language is implemented.

Greetings,

Ilir

[Antonio F.S.]

Hello Ilir,

Perfectly understood.

Thank you very much.
Best regards,
Antonio F.S.
----------------------------------------------------------

El 17/1/26 a las 13:23, Ilir Liburn escribió:

[Ilir Liburn]

Hello Antonio,

You're Welcome.

Greetings,

Ilir

[Mansour Ayouni]

Hello Mahmoud,

I love all that is said in your analysis, and it makes me confident the language I opted for to make the Softanza Project will stay faithful to its guiding principles.

All the best,

Mansour

--

---
You received this message because you are subscribed to the Google Groups "The Ring Programming Language" group.
To unsubscribe from this group and stop receiving emails from it, send an email to ring-lang+...@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/ring-lang/d8ddd4a5-29da-421f-a0ac-7c46ce4a6606n%40googlegroups.com.

[Mansour Ayouni]

Hello Azzeddine,

What you do is fascinating, so go forward to achieve all that you dream of, because Ring has been done for creative programmers who work to enlarge the boundaries of what is possible.

At the same time, we need to embrace the guiding principles of the language that makes Ring unique.

Ring is creative, but pragmatic in the sense that it knows about its own strengths and limitations. In the domain of performance-heavy processing, like IA, porting trusted and battle teste C or C++ libraries to Ring is the way to go. And I hope one of the contributors will work on that suring 2026.

For the meantime, I'm sure your project will have a strong educational value, and I'm surveilling it to consider its use on my training program in ESPA-MT school in Niamey. But I also want to see it, in future, as a professional framework for making small-to-medium AI solutions, and I'm sure you will achieve that.

All the best,

Mansour

--

---
You received this message because you are subscribed to the Google Groups "The Ring Programming Language" group.
To unsubscribe from this group and stop receiving emails from it, send an email to ring-lang+...@googlegroups.com.

To view this discussion visit https://groups.google.com/d/msgid/ring-lang/07bc44ea-4492-46dd-9617-7bf651a6c1bcn%40googlegroups.com.

[Mansour Ayouni]

Hello Mahmoud,

After finishing most of the Softanza library in late 2023, I started exploring different IA coding tools. ClaudeAI was by far the most capable one in learning Ring specifics, that's why I opted for it in 80% of my AI-based coding needs.

How do I code with AI?

- I'm totally against the vibe-coding practice for ethical and intellectual reasons : I refuse to delegate my human dignity as an intellect architect crafting designs with my fingers and keyboards to an automated black box. Today, in the 300K+ codebase of StzLib I can instantly show you where to go to see any part of the library, and to debug anything, in just a fraction of second. I know exactly what's the responsibility of each module, class and method, and I'll never lose this state of mastery and control unless when I retire.

- Most of my use of AI is intellectual dialog about code design, and implementation of that design after I give him a hand-made prototype and many examples of the final use cases. I can evaluate the impact of this collaboration with AI as an accelerator of time and quality of at least 30% of what I used to do manually.

- AI helps me tackle some domains where I'm not especially skilled in (like lowlevel programming) but just to to do the high level abstractions I need in the Softanza spirit, like when I added the System Module where I modeled stzSystem, stzMemory, stzPointer, stzOperationSystem, stzSystemCall and other classes, in an educational and easy to use way. But the worki with AI on this was challenging since it stacks to the common wizdom and can't easily figure out the different perspective I'm embracing in that domain. But finally, I found an effective way of letting AIs compete against each other on the subject: when Claude tells me this is impossible or not realistic, I let GrockAI be my partner in challenging Claude on the feasibility, and vice versa.

I learned from practice that each AI tool is string at a given particular aspect of my programming work:

• I use Claude in every thing design ideation and final Ring code implementation (dozens of thousands of chats during the last two years)
• I use GrockAI for innovative thinking and out-the-box designs (which I do A LOT in Softanza)
• and finally QwenAI for any business-oriented designs and algorithmic solutions (since Softanza is also business-oriented and for each class it imagines practical use sceanrios)

This works very well because Claude has been trained on codebases, GrokAI was trained after the innovative thinking of Elon Musk on modeling the universe and understanding its creative phenomenons, and QwenAI has been made by Alibaba to provide AI-based real world solutions for businesses and governments in domains like education, finance, transport, agriculture, security, etc.

The other mainstream tools like ChatGPT and Gemini are very limited and unstable to my needs. Sometimes I use ChatGPT for writing articles, which he does very well but turns out to be annoying (by giving many options and asking many questions) and invasive (he changes Ring code and samples by inventing functions that do exist). And sometimes I use Gemini, only for frontend-related tasks (JS, HTML, CSS) where I found it particularly skilled.

All the best,

Mansour

[Mahmoud Fayed]

Hello Azzeddine

>> "Thank you for your convincing and detailed explanation regarding Ring's design philosophy.

I fully understand and appreciate the focus on simplicity and flexibility that makes Ring unique."

You are welcome :D

>> "I am happy to share that I have successfully built a full Deep Learning framework from scratch using Ring."

>> "Adam II: A working language model capable of learning and generating text."

Looking forward when you share Adam || source code :D

>> "The current challenge I am tackling is scaling the training loop to handle massive datasets efficiently on consumer-grade CPUs."

Many computers/laptops use GPU

Things to try/use in the future could be CUDA Programming Guide — CUDA Programming Guide

>> "A snapshot from today's translation training"

Seems powerful and looks clear 

Keep up the GREAT WORK :D

Greetings,

Mahmoud

[Mahmoud Fayed]

Hello Ilir

>> " Yes, and it is nicely progressing. Core idea is to allow conversion of the official Ring code to typed version which then can be translated to C language with better performance by avoiding dynamic code execution which involves memory pool allocation/deallocation, types check, etc."

This is very nice :D

>> "My version is optional version which developer can use after project developed using official Ring is completed. Optional version will make sense only once translation to C language is implemented."

It will be our recommended version for developing high-performance software using Ring including game development

Greetings,

Mahmoud

[Mahmoud Fayed]

Hello Mansour

>> "I love all that is said in your analysis, and it makes me confident the language I opted for to make the Softanza Project will stay faithful to its guiding principles."

Thanks for your kind words :D

>> "I use Claude in everything design ideation and final Ring code implementation"

>> "I use GrockAI for innovative thinking and out-the-box designs"

>> "QwenAI for any business-oriented designs and algorithmic solutions"

Thanks for sharing this practical experience 

Greetings,

Mahmoud

[Mahmoud Fayed]

Hello Antonio

>> " I always thought that instead of creating separate clones of the same language, it would be more logical to enhance one language to cover all the possible improvements those clones might bring."

I’ve been trying to achieve this for many years, but once a project becomes more successful, new needs inevitably appear. At that point, it becomes difficult for the same developer or team to be in two places at once. This is when we start to appreciate the value of having different distributions or customizations, much like the world of Linux distributions.

For example, I’ve often wondered which approach is better: offering a language bundled with many libraries, an IDE, tools, and so on, or providing a lightweight release where developers install only the packages they need. Each approach has its own advantages and disadvantages, which is why the Ring download page offers both options.

Another direction is translations. Since Ring’s syntax can be adapted to different natural languages, and RingPM can install such translations when available, it may eventually become more practical to provide versions where a specific translation is included by default. This creates a new need for additional distributions.
A further direction is focusing on specific platforms or domains, where each distribution includes the relevant libraries. For example, a Ring distribution for desktop development, another for web development, another for game development, or one for microcontroller development.

Yet another direction involves offering different language features or characteristics—designs that prioritize performance over productivity, or safety over usability and flexibility, and so on.

Separating these directions allows us to release new versions for one area without waiting for progress in another. It enables faster development, reduces the burden on individual developers, and prevents placing too much pressure on specific contributors.

This kind of modularity is essential for programming languages that aim to remain alive and relevant for decades.

A funny thing happens when a developer uses multiple distributions at the same time. For example, in the xBase programming world we have Clipper, Harbour, xHarbour, Visual FoxPro, Visual Objects, xBase++, and others. During PWCT development, I used Visual FoxPro to build the IDE, while Harbour was used as the target language for the visual components where we generated Harbour code. Visual FoxPro was chosen because its IDE, form designer, and tools made me extremely productive. Harbour was chosen because it’s open‑source and makes it easy to distribute standalone applications. In other words, diversity is not always about exclusive choices or competition—different tools can complement each other.

Greetings,

Mahmoud

[Bert Mariani]

Hello MAhmoud et ALL

RE: Claude-AI

I agree that Claude-AI  has improved over that last 6 months.

I think it is currently the best of the bunch  for Ring Programming.

Helpful for Sections of Code as a Search Engine.

It was pretty dumb and constantly kept making Syntax Errors and using Non-Existent Instructions

Had to point out Repeated Errors many times for each New Conversation.

I didn't remember proper syntax that was pointed out.

I referred it to the Ring Documentation and Samples to read.

It would be good for the Current Conversation and then Forget for the Next Conversation.

Thankfully it Has Improved.

Ran the ring code. get no output at all. In Ring Language you can add the main() at the top of the code.

Aug 30, 2025

You're absolutely right! In Ring, you need a main() function to serve as the entry point. The code I provided had the test function at the bottom but it wasn't being called from a main function. Let me fix that:

[Youssef Saeed]

Hello Mahmoud and Mansour,

This has been a fascinating discussion to follow. Thank you for sharing such detailed insights!

Mansour, your strategy of using different AIs (Claude, Grok, and Qwen) for specific needs is very practical—I also use different models for specific tasks depending on their strengths. Mahmoud, your explanation of Ring’s "distribution" philosophy really puts the current growth of the language into perspective.

Best regards,
Youssef

[Mansour Ayouni]

Hello Youssef,

My pleasure, thanks a lot.

Best,

Mansour

--

---
You received this message because you are subscribed to the Google Groups "The Ring Programming Language" group.
To unsubscribe from this group and stop receiving emails from it, send an email to ring-lang+...@googlegroups.com.

To view this discussion visit https://groups.google.com/d/msgid/ring-lang/39809a07-02e6-4420-b6d6-ee3315dc0addn%40googlegroups.com.

[Mansour Ayouni]

Hello Dear Mahmoud,

You are welcome.

Best,

Mansour

To view this discussion visit https://groups.google.com/d/msgid/ring-lang/510e9fb2-cb7a-449a-90a0-9dd38e7a24c8n%40googlegroups.com.

[Bert Mariani]

Hello Mahmoud, Azzeddine et ALL

RE:  Arrays, Linked-Lists

I agree with Azzeddine 100%.

I know you heard this Before ... and I read your answers ...

Numeric Arrays  are a Natural for the Hardware

The hardware has General Purpose Registers, Index Registers, Address Registers and Program Control Register.

The Integers, Binary Coded Decimal and Floating Point are all Fixed Length.

The Hardware works at its Full Speed when using Arrays !

I have used Doubly-Linked-Lists when using Structures  in C. 

Structures that had a mixed type of fields.

For that Case they were appropriate.

That Ring uses  Doubly-Linked-Lists  to  Simulate Arrays is a drawback, lots of overhead.

Arrays which are a Simple , was left out of the Ring Design.

I think this was a Design Error not to include Array from the start. It has never been corrected.

There is nothing complicated about Numeric Arrays.

They offer a Speed and Use, that is Unmatched by Linked-Lists.

They should be added to the Design

Don't get upset.

I heard the Excuses about why they are Not in Ring.

And I Disagree !

=============================

1 Programmer ::  10,000 Users

Programmer:  I want simple, quick to develop and speed to market.

Users I want Simple to use, Intuitive, and Fast. 

Users: I want the Answer in a Second, Not in a Day !

The Programmers life should be Hard to make the Users life Easy.

=============================

Best Regards

Bert Mariani

[Mahmoud Fayed]

Hello Bert

>> "Don't get upset. I heard the Excuses about why they are Not in Ring. And I Disagree !"

(1) I actually enjoy these discussions because they create space for different perspectives and help us deepen our understanding of how we think about the language and its future

(2) We don’t all need to agree on every design decision. Ring is open‑source, and any interested developer can study the implementation, modify it, add or remove features, and shape it however they like. That’s the beauty of open‑source. We win when we think the same way and share our work, and we also win when we think differently and still share our work. In other words, our strength comes from sharing, not from agreement or disagreement.

(3) I’d like you to return to the fundamentals. There is a big difference between a programming language’s design and its implementation. One of my goals with Ring was to design a beautiful language and keep that design separate from how it is implemented. In other words, we define principles at the language‑design level, and then we try to implement those principles in a way that can evolve and improve over time.

Having a small set of core data types (Number, String, List, and Object) belongs to the language‑design phase and reflects those principles.
But making Strings or Lists behave like arrays is an implementation detail. These details already exist—our List implementation can allocate contiguous blocks, use arrays of pointers, and so on.

(4) Your proposal to introduce Arrays as a data type belongs to the language‑design phase, and this is not part of the direction I’m prioritizing, since I care more about other advantages. Our friend Ilir Liburn is already exploring this. Everyone has limited time, different priorities, and personal goals, so each person decides how to use their time. When Ilir releases his version, just use it. If it meets your needs, that’s great. If not, you’re free to build your own version.

(5) I’m very happy with RingFastPro and with the ability to use C extensions and write C code whenever I need extra performance. My projects have requirements where Ring’s performance is not an issue, so I won’t invest time solving a problem I don’t currently have—especially while I’m focused on other goals. My plans for improving Ring’s performance will be applied gradually over time, without changing the core design decisions.

(6) Personally, I plan to try Ilir’s version of Ring once it’s released, and I encourage using it when high performance is a priority. And believe me, what Ilir can offer through his work is far better than anything you should expect from me in this area, because he has a real, practical motivation for improving Ring’s performance—he wants to use it in professional game development.

(7) Performance is a big game, and what you really need is better performance—not Arrays. Think of arrays as just one technique you know for improving performance, but the performance game is much bigger than that. What about using threads? What about using the GPU? What about caching results? What about static typing or JIT compilation? what about native machine code?

If we start adding features to the language core purely for performance, over time we will break many of the principles behind the language’s design. I don’t need a fast language if it becomes unstable, consumes all my time to develop instead of use, grows endlessly in complexity, or forces me to write more code—or different code—to achieve things that were simple before.

Libraries like RingFastPro can evolve independently: they can use threads, leverage the GPU, implement caching, and introduce more features when needed. In other words, that’s a separate project. Also, we can use C extensions and Ring API is not complex. 

Greetings,

Mahmoud 

[Antonio F.S.]

Hello Mahmoud,

First of all, thank you very much for your response.

I think of those of us who don’t have a deep level of experience in building programming systems, but do have decades of extensive experience in business programming (as is my case), mostly with older languages (Fortran, Cobol, Bal, Basic, etc.). What interests us is quickly adapting to the language and its ecosystem, as well as having the language directly focused on our professional area; that is, we don’t want to spend more time than necessary to start working with Ring and see results at any level as soon as we compile our sources.

I perfectly understand your explanations and the direction you want to give to Ring, and also that you are not inflexible when it comes to accepting proposals. But these proposals come from true specialists like those of you in the official Ring forum, contributing incredibly wonderful tools and ideas. On the other hand, people like me and many others are the analyst-programmers who guide companies and their problems, and our clients (in my case, already approaching retirement) want solutions in a way that they see us deliver them effectively and without headaches.

That is: if we have web clients, there should be an immediate path to Ring in that area of development; if we have desktop app clients, it should be the same; and if we have clients for mobile apps, exactly the same.

Therefore, just as a novice in operating systems can go "crazy" researching Linux distributions until finding one that is functionally competent and simple (I work with Mint, Q4OS, and MX Linux), in the same way, "career programmers" need the language to have a charismatic and highly competent "inner world" that is quick to help us find our way.

I believe Ring fulfills all of the above, but "it scares me" to think that it might grow in such a diverse way that it ends up becoming a puzzle that’s hard to understand and assemble. :-) :-)

Best regards,  
Antonio F.S.
----------------------------------------------------------------------

El 17/1/26 a las 20:41, Mahmoud Fayed escribió:

--

---
You received this message because you are subscribed to the Google Groups "The Ring Programming Language" group.
To unsubscribe from this group and stop receiving emails from it, send an email to ring-lang+...@googlegroups.com.

To view this discussion visit https://groups.google.com/d/msgid/ring-lang/c7272ef2-8565-4233-8b18-77ef5871dc64n%40googlegroups.com.

[Ilir Liburn]

Hello Bert,

First good news. In debug mode, arrays are 30% faster than lists inside the for-in loop, and 60% faster inside the ordinary loop. Together with other optimizations inside the VM, it is possible to reach 100% better performance (in overall).

Now the bad news: array structure must be copied to maintain independent index access. The list does not have this problem do to its jagged structure. This is not possible with array because it is a flat space. Array of pointers to other arrays is not under consideration.

Greetings,

Ilir

[Mahmoud Fayed]

Hello Antonio

>> "First of all, thank you very much for your response."

You are welcome :D

>> "I believe Ring fulfils all of the above, but "it scares me" to think that it might grow in such a diverse way that it ends up becoming a puzzle that’s hard to understand and assemble. :-) :-)"

(1) Developing a successful programming language that can be used for real‑world projects is difficult, but an even greater challenge is managing what comes after that success—more tools, multiple implementations, and a huge expansion of knowledge.

(2) As humans, we feel safer and more powerful when we believe we know everything, but eventually we must accept that we can’t. I’ve used dozens of programming languages, yet the number of languages I haven’t used is even greater. The same is true for Python or JavaScript developers: no matter how many libraries or packages they know, the ones they don’t know are far more. I accept this reality when it comes to ecosystems—libraries, tools, implementations—but the core design and implementation of Ring will remain simple, so that everyone in the community can fully understand the language’s design and features.

Greetings,

Mahmoud

[Mansour Ayouni]

Hello Antonio,

Your message resonates deeply to my motivation in selecting Ring as a language for my Softanza library project.

I used to be a WinDev programmer (a proprietary RAD language and IDE) that makes desktop, web and mobile development a joy...

But unfortunately, the company behind it was acquired by a grand group who forced it to adopt the SAAS and subscription based model, forcing us to pay for them every month or they blocked our source files.

Before WinDev, in the old days, I was mainly a BASIC developer (from MSX-Basic, to GW-Basic, to TurboBasic, to Visual Basic, and so on). I also made projects in several other languages like Ruby, Python, C#, Java, and so on.

When I saw Ring for the first time, I fell in love with it instantly, and started exploring it, until taking the decision to let it be my language of choice for the rest of my career. The main question was: Ring is nice, powerful, intuitive, flexible, but a professional programmer can't easily let it be adoptable by its enterprise customers...

So I started Softanza to be the kind of framework that answers all the checklist IT managers ask when they are confronted with selecting a new programming language. With a lot of work, patience and perseverance, and a lot of help from Mahmoud and our team of contributors, I finally convinced a bank in Niger to use Ring instead of WinDev...

I think your experience and practical contact with customers is very important to us, so please keep giving us your feedback, proposals and insights.

All the best,

Mansour

To view this discussion visit https://groups.google.com/d/msgid/ring-lang/abf81d37-a39b-48d8-a016-b6466f1c697d%40gmail.com.

[Bert Mariani]

Hello MAhmoud

RE:  I’m focused on other goals. 

Sorry, I have heard this explanation before about Design and Implementation

Still Arrays are a Simple Concept that can Easily be run at Full Speed by the Hardware.

Arrays as a Data Type of Numbers is a Natural programming concept

It Definitely should be Implemented.

Why are you so adamant on avoiding this issue over the last 10 years.

It could have been fixed and addressed way back when.

Any Ring program that uses "Arrays" runs 50-400 x times slower than

 a language that has  true Arrays that match Hardware implementation.

Linked-Lists have their uses,  but Definitely Not to Simulate Arrays.

Best Regards

Bert Mariani

[Antonio F.S.]

Hello Mahmoud,

Of course, what makes me happy about having chosen Ring as the last language to enjoy in my retirement (especially for documentation purposes) is its simplicity and, at the same time, its power. In that regard, I completely agree. :-) :-)

Understood everything, thanks to your very clear explanations (as always).

A warm hug,
Antonio F.S.

---------------------------------------------------------------------

El 17/1/26 a las 22:41, Mahmoud Fayed escribió:

Hello Antonio

[Antonio F.S.]

Hello Mansour,

Thank you very much for reaching out to me with that wonderful interest
in sharing work on languages that some of them, I too recall with fond
nostalgia today.

Indeed, the system you mentioned—which I'm not familiar with—is exactly
what every professional, having battled with companies, needs. It's a
shame it turned proprietary.

At the moment when my time becomes mostly leisure, I want to dive into
Softanza in parallel with Ring to start creating tutorials in Spanish.
It's something that curiously appeals to me within my intentions for the
ecosystem.

Thank you very much for your kind words to me.
A warm, fraternal hug.
Antonio F.S.

----------------------------------------------------------------------

El 17/1/26 a las 22:46, Mansour Ayouni escribió:

[Mahmoud Fayed]

Hello Bert

>> "Still Arrays are a Simple Concept that can Easily be run at Full Speed by the Hardware."

>> "Arrays as a Data Type of Numbers is a Natural programming concept"

>> "It Definitely should be Implemented."

>> "Any Ring program that uses "Arrays" runs 50-400 x times slower than a language that has true Arrays that match Hardware implementation"

(1) You are sharing performance results from a different context, You can't get performance results from using C code, and then say (implement Arrays and you will get these results), Things doesn't go this way in practice.

When using

aList = list(100)

Internally Ring VM allocate continuous blocks of memory to store the items (Numbers)

When we use aList[x], Internally Ring uses an array of pointers to quickly get the item, once we get the item it's used directly because numbers are stored inside it.

i.e. it's the speed of (using an array of pointer) to (an array of items)

This is implemented this way as a result of your previous suggestions about using Arrays while also keeping the language features working as expected.

But how much this is faster than using the linked-list version

aList = []

for t=1 to 100 aList + 0 next

You need to test, try different arrays size, etc.

(2) When using 

cStr = space(100)  # we already allocated an array of bytes, i.e. an array where each item is one-byte.

Using cStr for processing data when we need an array of small numbers, of-course gives better performance

but it's not 50-400 x times faster as you may think!

It's just could be around 3x times faster (in best cases, and you have to test it)

And part of this performance improvements comes because we store (1-byte for item) vs (More bytes per item when using Lists)

(3) This happens because in Ring VM, as any other dynamic language that uses a VM (without static-typing, JIT, etc.) other factors play an important role on the performance results.

(4) Ring is safe (check errors when using an index outside the size limits), flexible/dynamic (Allow mixing multiple types, nested lists, etc.),  such features belongs to the language core, and have an effect on performance, these features comes with values that I care about, I don't sacrifice such features to get performance, and I don't increase complexity by introducing arrays, static-typing, etc.

(5) The implementation of our friend (Ilir Librun) will provide better performance, not just because of arrays as datatype, but other reasons exist too like static-typing and native compilation. Again, this is another development direction that satisfy different goals.

Greetings,

Mahmoud

[Mahmoud Fayed]

Hello Antonio

>> " Of course, what makes me happy about having chosen Ring as the last language to enjoy in my retirement (especially for documentation purposes) is its simplicity and, at the same time, its power. In that regard, I completely agree. :-) :-)"
>> "Understood everything, thanks to your very clear explanations (as always)."

You are welcome :D

Greetings,

Mahmoud

[Azzeddine Remmal]

Hello Mahmoud,

Thank you for your encouraging words and support.
You are absolutely right about GPU/CUDA being the ultimate frontier for deep learning. 

However, before scaling to GPUs, I encountered a critical bottleneck inherent to the "Interpreter <-> C Extension" communication during heavy training loops.

The Challenge:
In my current implementation (Eager Execution), the training loop runs in Ring, calling C functions for every matrix operation.
For a Transformer model, this results in millions of context switches between the Ring VM and the C extension per epoch. Even with optimized C kernels, this Function Call Overhead accumulates, causing small models to take 20+ hours to train on CPU.

The Solution: RingTensor Graph Engine
To solve this while respecting Ring's philosophy (keeping the language simple and flexible), I am refactoring RingTensor from a simple math library to a Static Computation Graph Engine.

The New Architecture:
Ring (The Architect): Defines the model structure and logic (Building the Graph nodes).
C Extension (The Builder): Stores the graph structure in memory.

Execution: Ring sends a single command: graph_run(epochs=50).
Zero-Latency: The C extension executes the entire training loop (Forward/Backward/Update) internally without returning to the VM until the job is done.

This approach effectively turns Ring into a high-level orchestration layer (similar to Python in TensorFlow/PyTorch) while C handles the heavy lifting with zero overhead.

I will share the results of the new "Graph Mode" Adam II soon.

Best regards,
Azzeddine

[Bert Mariani]

Hello Mahmoud et ALL

Back in  21-Oct-2020, we did a Speed Test to check out "Array" implementation

======================

Speed-Queens-N.ring

Enter value of n : 12

Possible placements are :

End   millisec: 339057

Start millisec: 3758

Total millisec: 335299

Total Seconds : 335.30   (Note C++ application runs in  0.313 seconds)

[Mahmoud Fayed]

Hello Azzeddine

>> "Thank you for your encouraging words and support."

You are welcome :D

>> "This approach effectively turns Ring into a high-level orchestration layer (similar to Python in TensorFlow/PyTorch) while C handles the heavy lifting"

>> "I will share the results of the new "Graph Mode" Adam II soon."

This is very nice and good news, Thanks for sharing :D

Greetings,

Mahmoud

[Mahmoud Fayed]

Hello Bert

>> "Back in  21-Oct-2020, we did a Speed Test to check out "Array" implementation"

>> "Total Seconds : 335.30   (Note C++ application runs in  0.313 seconds)"

(1) I am very happy that you are sharing this test program which you wrote in 2020, and we can find in Ring group

(2) Testing this on my machine (different computer) using Ring 1.25 (different Ring version) after 5 years produces the next results

(3) The total time is around (27) seconds (I am glad it's not 335 seconds)

So, it's 12x faster (Again, different computer, different Ring version, after five years, etc.)

This is practical evidence while performance is not my priority, we still improve Ring performance along the time.

(4) The very slow performance in 2020 doesn't prevent us from using Ring, improve it, etc. 

We were inside Ring group in 2020, and together we are inside it again in 2026, and more people joined us, and contributed samples/packages/etc.

(5) The current higher performance, while being 12x faster in this use-case at modern machines, it doesn't prevent us from using Ring extensions written in C code to get better performance. i.e. if the performance is the goal, using a language designed to be high-performance will be the way to go.

(6) You can find a way to improve RingFastPro to enable covering such samples.

(7) Changing one line of code, and replacing x = 1:n (linked-list version) with x = list(n) # Arrays version

reduce the time from 27 seconds to 25 seconds

So, it's now 13x faster (Again, different computer, different Ring version, after five years, etc.)

(8) This could raise a question 

Why the version that uses List() and internal arrays doesn't bring huge performance gains compared to the version that uses linked-lists?

(8.1) Because Ring Linked-Lists comes with many optimizations to improve the performance

In C language, if you implemented linked-lists in a simple-way the performance suffers for multiple-reasons like

* Many malloc()/free() calls - Using malloc a lot of time is known to be slow 

* Allocating memory in different places doesn't help the cache and leads to cache miss

* Accessing an item requires traversing the list

Ring implementation of linked lists is designed to avoid these problems or at least reduce their effect

* In Ring Memory Management System, we use a Memory Pool, we allocate memory in advance, so using Ring malloc and Ring free doesn't need to go to the operating system and ask for memory (This is many times faster)

* The memory pool reuses the memory which reduce the cache miss

* In Ring lists, we cache the pointer of the last item, when we get an item, the cache is used to avoid traversing the list from the beginning or the end.

This is explained in the research paper that code Ring language and published in 2024

(8.2) Other factors like (Ring VM main loop, dynamic typing, loop performance, function/method call performance) plays more important role in the performance

For example, using RingFastPro we get huge performance gain, but wait, we pass Ring Lists to RingFastPro (i.e. the C code inside RingFastPro process these lists as lists, not arrays). And we still get huge performance because of the other factors

Greetings,

Mahmoud

[Mansour Ayouni]

Hello Mahmoud,

Those results prove Ring is on the right rails.

All the best,

Mansour

--

---
You received this message because you are subscribed to the Google Groups "The Ring Programming Language" group.
To unsubscribe from this group and stop receiving emails from it, send an email to ring-lang+...@googlegroups.com.

To view this discussion visit https://groups.google.com/d/msgid/ring-lang/3e1e34e8-1c26-4d31-9022-ed1421801d83n%40googlegroups.com.

[Mahmoud Fayed]

Hello Mansour

>> "Those results prove Ring is on the right rails."

You are welcome :D

Greetings,

Mahmoud

[Bert Mariani]

Hello Mahmoud et ALL

>>  Speed-Queens-N.ring

>> "Back in  21-Oct-2020, we did a Speed Test to check out "Array" implementation"

>> "Total Seconds : 335.30   (Note C++ application runs in  0.313 seconds)"

Today I have a much Faster Laptop (at least 2-4 x )  and Ring 1.25  

So the speed result will be a combo of the two.

Total Seconds : 38.35

In 2020  Speed Difference = 1,071 x Slower  

In 2026  Speed Difference =    122 x  Slower   ( Still a Wild difference Link-List :: Array)

Improvement 8.77 x from 2020     ( Due to Laptop ( maybe 2x or 4x )  and Ring version)

Linked-List is  Ok for  around  1,000 items

After that they seriously can Not Keep Up with Arrays. 

See Bjarne Stroustrup  C++ architect.

So again it may sound harsh ... (I am sorry !)

Ring cannot be considered a Serious Language if it Omitted Proper Arrays in its Design.

A Huge Flaw ! 

And there seems to be No Intension to Fix It.  

It Ignores the Fundamental Hardware concepts.

--------------------------------------------

2026-01-18

Enter value of n : 12

Possible placements for: 12
End   millisec: 41660
Start millisec: 3314
Total millisec: 38346
Total Seconds : 38.35
Count Queen: 841989  Count Place: 10103868
Exiting of the program...
Enter to Exit :

------------------------

Best Regards

Bert Mariani

[Mansour Ayouni]

Hello Bert,

I appreciate your principled position and fully understand it, both from your own perspective and from the perspective of those who share it with you.

Ring belongs to a different school of thought regarding type systems and how they can be simplified in the context of a dynamic language. It is also not the only language that abstracts arrays and builds its internal logic around lists.

You can read this to get an idea of other languages that take a similar approach:

https://share.google/aimode/cZLoSatM2RmMGwIiK

@Mahmoud: I have promoted gemini for this list, is it correct?

Best,

Mansour

To view this discussion visit https://groups.google.com/d/msgid/ring-lang/a98f6b2c-7b05-422e-ad72-0d8c6b17c5cbn%40googlegroups.com.

[Ilir Liburn]

Hello Bert,

>> Ring cannot be considered a Serious Language if it Omitted Proper Arrays in its Design.

>> A Huge Flaw ! 

>> And there seems to be No Intension to Fix It.  

>> It Ignores the Fundamental Hardware concepts.

Ring is a dynamic language. Static build which is required to utilize hardware concepts like arrays with better cache, in Ring only exists as static build of the Ring VM avoiding dynamic linking of the functions, not the static build of the C code where arrays can be directly used. Arrays in Ring VM can be implemented only by having a wrapper which is a structure describing it, with respect to type, dimensions, index access (bounds), etc.

That's why I'm making Ring2C project. Abstract arrays, typing (static or dynamic) and many other concepts necessary to have static build of the C code once Ring to C language translation is implemented.

Greetings,

Ilir

[Bert Mariani]

Hello Mansour

RE; You can read this to get an idea of other languages that take a similar approach:

https://share.google/aimode/cZLoSatM2RmMGwIiK

My opinion ...

All these other language are Not Serious Languages.

None of them address the basics of How Hardware Works.

If you avoid basic hardware concepts, then the language is just a  "Toy" language

They make the "Programmer Life  Easy" at the Cost of Not Exploiting the Hardware properly.

Make the Programmers Life a Bit Harder to Solve the Problem.

All this stuff about Dynamic is just an avoidance excuse that never ends.

Same with VM's ... an overhead that is not needed  

Compile the program to Run Natively !!  

Sorry if anybody is offended.

Best Regards

Bert Marini

[Mansour Ayouni]

Hello Bert,

I respect your opinion, fully, and this is mine:

• I don’t like strong typing, and I don’t care about compile-time error checking. The way I currently catch errors in a 300K+ Ring codebase is a fully satisfying experience for me.

• I don’t care how hardware is implemented at the metal level, or how memory should be organized, because I’m not developing hardware-critical systems. I build business and educational software, where productivity is the primary concern.

• I don’t consider Ring a toy language, and I’m experienced enough not to take such a risk by building business solutions with it for serious customers.

• When low-level requirements arise, Ring provides an open window to C and C++ extensions, allowing anyone to do anything when needed, while preserving the language’s spirit and culture.

• The arguments you made about arrays and the fidelity of language design to hardware constraints are precisely what prevented me from starting the Softanza project—until I found Ring.

• I’m glad Ring places simplicity, flexibility, and productivity at the core of its design, and I hope it continues to do so. If Ring ever chooses to move away from that philosophy and embrace those constraints, I’ll be the first to leave it for another language.

Disclaimer: I’m not saying this to escalate the discussion or harden positions, but simply to emphasize the cultural contrast between the two perspectives and to enrich the discussion.

  

All the best.

Mansour

To view this discussion visit https://groups.google.com/d/msgid/ring-lang/d2599917-5a11-4af4-b920-feea35f25acen%40googlegroups.com.

[Bert Mariani]

Hello Mansour

So why is everybody so scared about Arrays. Makes no sense to me.

Even Pointers used for Indirect Addressing are a simple concept that scares everybody.

Ring can easily allocate fixed length array space dynamically. And use arrays  properly as it should. Even if it is an Interpreted language.

Best Regards

Bert Mariani

[Ilir Liburn]

Hello Bert,

>>  So why is everybody so scared about Arrays. Makes no sense to me.

Because Ring is designed to work with items: structures holding the data, type, reference count and optionally address to external data.

>> Even Pointers used for Indirect Addressing are a simple concept that scares everybody.

Because they hold address of the external data which can lead to dangled pointer.

Arrays are different: contiguous flat memory holding only data. Their unsafe nature is not best option for the high level programming language.

Greetings,

Ilir

[Bert Mariani]

Hello Ilir

My last comment on this subject of Arrays.

Its like driving a Ferrari only in 1st gear.

Why buy a faster laptop.

Best Regards

Bert Mariani

To view this discussion visit https://groups.google.com/d/msgid/ring-lang/9f615ef8-d5e9-4cd2-a739-d98f3b820b80n%40googlegroups.com.

[Ilir Liburn]

Hello Bert,

>> Its like driving a Ferrari only in 1st gear

Actually, you need a Ferrari to drag it faster, 1st gear is where you start. To ease your mind: the profiler in Ring2C will analyze Ring code to find which variables can be typed, which lists do not change in size (can be safely converted to arrays), etc. Which leads to faster execution in C afterwards.

Greetings,

Ilir

[Mansour Ayouni]

Hello Ilir,

I appreciate your way of thinking of the problem and its solution Ring2C.

Looking forward to it.

All the best,

Mansour

To view this discussion visit https://groups.google.com/d/msgid/ring-lang/4ba92ea3-9053-4996-b4b4-abec53b2fc11n%40googlegroups.com.

[Ilir Liburn]

Hello Mansour.

You're Welcome. Static code analyser was introduced some time ago here in the group, I'm going in direction of the dynamic analyser. This requires changes in the RIng VM.

For projects like Softanza, it is going to be easy to use it because test cases are already testing libraries from all angles. For the application developers, it is different because the application itself needs to be tested from all angles interactively.

But before that, I want to implement a Ring to C translation layer. Because I already have many test cases with typed variables, arrays, etc.

Greetings,

Ilir

[Mansour Ayouni]

Hello Ilir,

Nice to know. Wishing you continued progress.

Best,

Mansour

To view this discussion visit https://groups.google.com/d/msgid/ring-lang/102300e4-f860-4262-9436-2f8c294dc666n%40googlegroups.com.

[Mahmoud Fayed]

Hello Bert

>> "Today I have a much Faster Laptop (at least 2-4 x )  and Ring 1.25"  

>> "So the speed result will be a combo of the two."

I installed Ring 1.13 and Ring 1.25 on my machine (The same machine)

Then tested your sample from 2020

Ring 1.13 ---> 142 seconds

Ring 1.25 ---> 27 seconds

So, Ring 1.25 (binary release) is 5x faster than Ring 1.13 (binary release) in this test program on the same machine

Note: You can do more experiments, by rebuilding from source code using the same C compiler and using the same architecture (32bit vs 64bit) to be sure about how much Ring is faster.

>> "Linked-List is  Ok for  around  1,000 items"

>> "After that they seriously can Not Keep Up with Arrays."

>> "See Bjarne Stroustrup  C++ architect."

This is not correct as a general fact to share at any time

 (Maybe in specific context where he done his tests on specific programs and specific machines, and when using C++)

Other factors that have an effect on performance (Linked-Lists vs Arrays) include

1- What is your hardware? Is it old hardware or new hardware? Is it desktop computer? Server? Microcontroller? other?

2- The size of data in each node, i.e. Total size of (1000) items? Is this larger than your cache memory?

3- The size of cache memory on the computer? 

4- What is the usage pattern? The algorithm/program that we execute? Does the data grow? how much?  

The mistake that you are doing here is bringing knowledge applicable to C/C++ code and think that it's applicable to the Ring implementation as a language because Ring is written in C. This is partially correct, but your performance expectations are not, Of-course using Arrays compared to LinkedLists reduce memory requirements, improve cache usage and is a known way to improve performance in many cases, but how much will be the performance gain? and in which context? what are the drawbacks?

Systems performance is a bigger game

1- Ring VM is a system, the input is computer programs (bytecode), the system contains multiple modules (memory management, dynamic features, etc.)

2- Ring Lists implementation is not a traditional (Linked-List) - It comes with optimizations and is too much faster than traditional linked-lists 

3- We already use Arrays in specific context, like when using List() function to create a list of numbers and the performance gain is not too much big in many samples because other factors in Ring VM (loop performance, functions/method call performance, VM vs Native Code, etc.) plays more important role.

>> "So again it may sound harsh ... (I am sorry !)"

You don't need to say Sorry when sharing your ideas/suggestions/opinions/knowledge/etc.

Discussions even if it contains different opinions is not about finding a winner

Freedom is Freedom and we are open-source contributors

The winner is everyone uses the software and find it useful

The winner is everyone reading this topic now or in the future and discover/learn new things from it.

>> "Ring cannot be considered a Serious Language if it Omitted Proper Arrays in its Design."

We don't ignore (Arrays), we determine where to use them 

1- Specific functions like List() function in specific cases (List of 1D or 2D numbers)

2- Ready to use extensions/libraries like RingFastPro 

3- C extensions - Use Ring API and extend the language with C code.

>> "All these other language are Not Serious Languages."

>> "None of them address the basics of How Hardware Works."

>> "If you avoid basic hardware concepts, then the language is just a  "Toy" language"

>> "They make the "Programmer Life  Easy" at the Cost of Not Exploiting the Hardware properly."

(1) Believe or not believe, I heard many Assembly programmers saying this about the C language

What C programmers said?

C is not a toy, it can be used in production, and you can write Assembly code inside C language.

And I am confident to say that Ring is not a toy language, it can be used in production and developing powerful software and using Ring API we can extend it with C/C++ code when this is necessary.

(2) Another important thing to remember ---> The best performance is not the number one feature for most software projects, fast-enough is what most software projects need. 

(3) I prefer Ring over C because Ring Performance in specific context is Better, you are readding it correctly, but I am not talking about (Run-time Performance), I am talking about (Compile-Time Performance & Speed of Iteration)

Using Ring I can compile/run PWCT project (100KLOC) and StzLib project (300KLOC) in around one second

Similar projects in C/C++ could be from 500KLOC to ONE MILLION LINES OF CODE

Compile Time could be from 15 minutes to one hour

So, it depends on which type of performance you care about more.

>> "Make the Programmers Life a Bit Harder to Solve the Problem."

>> "All this stuff about Dynamic is just an avoidance excuse that never ends."

>> "Same with VM's ... an overhead that is not needed"  

>> "Compile the program to Run Natively !!"  

>> "Sorry if anybody is offended."

No, you don't need to say sorry, I am just smiling because I understand your position/feelings

I don't disagree with this point of view if you want to develop low-level system software, but we already have C/C++/D/Rust/Odin/Zig/Jai (I have access to Jai language and it's GREAT). 

When I need this, I can use C, and I am happy that I can use both of Ring and C at the same time.

THE POINT IS: RING IS NOT DESIGNED TO BE A HIGH-PERFORMANCE LANGUAGE LIKE C, IT'S DESIGNED BECAUSE I WANT MORE PRODUCTIVITY, I DESIGNED RING FOR ME, BECAUSE I NEED IT AND I LIKE IT, IF YOU LIKE IT THEN IT'S OK AND IT'S FREE OPEN SOURCE, IF YOU DON'T LIKE IT, I DONT CARE, IT'S NOT MY GOAL TO CONVICE EVERYONE TO USE RING 

Greetings,

Mahmoud

[Mahmoud Fayed]

Hello Bert

>> "So why is everybody so scared about Arrays. Makes no sense to me."

>> "Even Pointers used for Indirect Addressing are a simple concept that scares everybody."

Read the C code behind Ring Compiler/VM (25KLOC) while taking in mind that Ring implementation is already stable and used by others.

This is practical evidence that I know how to manage dynamic memory using C and do advanced stuff.

Also, I have experience in teaching the C programming language at the university level.

So, I am not scared and I am not against these concepts (That's Why I am using C language too)

But when it comes to designing a programming language like Ring, I am designing a very high-level programming language that I can use to develop stable and powerful software in shorter time while having compact or readable code (As I wish).

Do this experiment

(1) Open PWCT2 source code (A visual language written in Ring)

URL: PWCT/PWCT2: Programming Without Coding Technology - Second Generation, written in the Ring programming language!

Try to run it from source code using Ring 1.25

Spend some time using it (15 minutes or 1 hour) 

I am not asking you about PWCT2 design, but I am asking you about

1- Is it easy to run PWCT2 from source code?

2- How much time to run the software from source code?

3- When spending some time using the software, do you feel that it's stable or you have bugs/crash?

(2) Open Envision visual programming system (written in C++)

URL: Envision: Welcome to Envision

Source Code: dimitar-asenov/Envision: A next-generation IDE that makes programming more efficient

Envision is developed from 2011 to 2017 as a research prototype behind one PhD thesis, around 5 master's theses, etc.

Envision is a GREAT RESEARCH and influenced PWCT2 design

But try

1- Is it easy to run Envision from source code?

2- How much time to run the software from source code?

3- When spending some time using the software, do you feel that it's stable or you have bugs/crash?

From my experience, it's not easy to run Envision from source code, it consumes time to run the software because of C++ build time, when using the software it suffers from bugs/crash because of memory management mistakes.

Remember, I am not attacking Envision or their authors, It's wonderful research prototype and the author/contributors did very important contribution (IMHO) and they know a lot about C++ & Software Development

But it's not just about your level as a programmer, Using C/C++ gives you huge power, you have control over memory and high-performance, but developing software along the time includes more important factors (Matching Requirements, Stability, Productivity, Collaboration, etc.)

PWCT2 is very stable, distributed through Steam, easy to install, stable, etc. 

Not because I am a better programmer than Envision creator or a better Scientist

But because using Ring by individual programmer/researcher/small team enable them to develop powerful software in shorter time

I know this before developing Ring, because I have used Visual FoxPro & Harbour to develop PWCT

Ring is designed for people who want to do this (developing powerful and stable software in shorted time without the need for very large teams)

Greetings,

Mahmoud

[Bert Mariani]

Hello Mahmoud

Here are the numbers for Queens-N.c  ::  Queens-N.ring

==============================

# Date 2026-01-21
#
# Queens-N.c
# Enter value of n : 12
# Possible placements are :
#
# End   millisec: 3282
# Start millisec: 3078
# Total millisec: 204
# Total Seconds : 0.204000
#-----------------------------
#
# Queens-N.ring
# Enter value of n : 12
# Possible placements are :
#
# End   millisec: 39875
# Start millisec: 11117
# Total millisec: 28758
# Total Seconds : 28.76
#-----------------------------
#
# Ring     Ccode   Ratio
#  28.76 / 0.204 =     141 x      // 2026-Jan-21  new laptop, Ring 1.25
# 335.30 / 0.313 = 1071 x      // 2020-Oct-21   old laptop,   Ring 1.13
#
#  11.65   1.534 => Ring 1.25 =     7.6x  faster than Ring 1.13
#                               C-code      = 141x     faster than Ring 1.25
#-----------------------------

===============================

Why were Cray supercomputers so fast?
The key architectural aspect:
Cray supercomputers were designed for vector processing. They had the amazing ability to take an array of numbers and stuff them through the floating point unit and produce one result every cycle because of the pipelining of the floating point unit.

Hardware is not designed for Linked-Lists

================================

Why Ring Language design left out  array of numbers  is beyond me !

I read your answers. 

It sounds like you are "skating" around the issue.

Best Regards

Bert Mariani

[Mahmoud Fayed]

Hello Bert

>> "Why Ring Language design left out  array of numbers  is beyond me !"

>> "I read your answers." 

>> "It sounds like you are "skating" around the issue."

(1) In Ring, using Space() function we can have an array of bytes 

(2) In Ring, using List() function, Ring VM internally create an array of the ITEM structure 

(3) In Ring, using Lists is implemented using very optimized linked-lists

Do you want to see the real performance difference between all of these options

Try this Ring example which uses each of these three options to create a list of ONE-MILLION-ITEMS

Then Sum all of these items

And we see the performance difference 

How much using An array of bytes is faster in filling the data? ---> around 20%

How much summing array of bytes is faster than list items (if the letter is already a number - not implemented in VM) ---> around 70%

These percentages (20%, 70%, etc.) is what I am trying to tell you in all of my previous messages, adding real arrays as a separate type will not bring too much better performance, because we have other factors that has more effect (Ring VM, Interpreting byte code instead of native code, Dynamic Typing, Saftey, etc.)

JUST USE RingFastPro and get multiple times performance improvements (and don't think about making the language more complex by adding more types just to get 20% or 70% improvement!).

nSize = 1_000_000
cData = space(nSize)
t1= clock()
for t=1 to nSize
cData[t] = 50
next
t2= clock()
aData = list(nSize)
for t=1 to nSize
aData[t] = 2
next
t3= clock()

aData2 = []
for t=1 to nSize
aData2 + 2
next
t4= clock()

nSum = 0
for t=1 to nSize
nSum = nSum + cData[t]
next
t5= clock()
? nSum

nSum = 0
for t=1 to nSize
nSum = nSum + aData[t]
next
t6= clock()
? nSum

nSum = 0
for t=1 to nSize
nSum = nSum + aData2[t]
next
t7= clock()
? nSum

nSum = 0
for t=1 to nSize
nSum = nSum + 2
next
t8= clock()
? nSum

? "Time to fill array- 1-Byte items: " + (t2-t1)
? "Time to fill list - Internal Arrays: " + (t3-t2)
? "Time to fill list - Optimized LinkedList: " + (t4-t3)

? "Time to sum array: 1-Byte items: " + (t5-t4)
? "Time to sum list - Internal Arrays: " + (t6-t5)
? "Time to sum list - Optimized LinkedList: " + (t7-t6)
? "Time to sum 1-Byte (No conv.): " + (t8-t7)

Output:

2000000
2000000
2000000
2000000
Time to fill array- 1-Byte items: 82
Time to fill list - Internal Arrays: 99
Time to fill list - Optimized LinkedList: 101
Time to sum array: 1-Byte items: 220
Time to sum list - Internal Arrays: 132
Time to sum list - Optimized LinkedList: 133
Time to sum 1-Byte (No conv.): 78

Greetings,

Mahmoud

[Bert Mariani]

Hello Mahmoud

For a User the  only number that counts is:

How Long does it take to  Execute and Wait for Results.

#  Ring        C-code        Ratio

#  28.76 /   0.204 =       141 x 

Best Regards

Bert Mariani

[Mahmoud Fayed]

Hello Bert

>> "For a User the  only number that counts is: How Long does it take to  Execute and Wait for Results."

The same idea applies to both the runtime performance of software and the development time required to build it. For application development, I prefer a productive language like Ring over C. I want to build my applications faster, see results quickly, produce stable software, and enjoy the flexibility of evolving my programs over time. For systems development or cases that require high performance, I can always write C extensions.

I’m continuously improving Ring’s performance, but without changing the core principles that motivated me to create the language in the first place. Ring is free and open source, and for developers who want to explore different directions, we encourage forking the project and experimenting freely — we genuinely love seeing that.

Greetings,

Mahmoud

[Bert Mariani]

Hello Mahmoud

Just Do It !  ( Niki Motto)

Just implement the Type Array

     - Numeric Array Floating Point

Core Principles should have  included  Numeric Arrays since Day One.

Its not about 1 Programmers Time

Its about the 10,000 Users Time

Nike, the Greek goddess of victory, is often depicted as a 

winged figure symbolizing speed and triumph. 

Best Regards

Bert Mariani

[Clement]

Test with Python:

Regards,

Clement

[Mahmoud Fayed]

Hello Everyone

During the last 24 hours I was using Claude Code to generate code in Ring language

I was able to produce 7,000 lines of Ring code at high-quality (Model: Opus 4.5) 

I think this is a great opportunity to use such a tool, not just in Ring apps development, but also in developing high-quality libraries

In the early days of Ring, one of the questions around the language was (How many learning resources exists, what about StackOverFlow questions?) 

Now using Claude Code, we have a great source of knowledge about the language + very high productivity tool

Since Ring is a dynamic language, encourage short code, it was very useful when using the AI, we have less tokens per program, which is useful for the context window.

Greetings,

Mahmoud 

On Saturday, January 17, 2026 at 5:45:37 AM UTC+3 Mahmoud Fayed wrote:

Hello

While on vacation, I decided to explore more AI tools. Although I use Windows Copilot every day with great results, I wasn’t satisfied with the quality of the Ring code it generated. It wasn’t good enough, so I avoided using AI for Ring code generation.

But I decided to give Claude AI a try, and I was shocked by how powerful it is at generating Ring code. It’s a game changer for me. I tested it with multiple design patterns, and the model clearly understands the language’s concepts—variables, lists, classes, functions, and more. It was also straightforward to guide it to use the Ref() function whenever references were needed. Also, to use the (Main program) code before classes code.

While this alone would have been enough to get useful results, I was even happier when I tried generating GUI code with RingQt. It seems this model is very well trained.

I tried this prompt:

Write a program using the Ring programming language and RingQt that ask the user to enter 5 numbers then display the maximum number, minimum number and the average number

Reading the generated code was really fun: https://claude.ai/public/artifacts/4c2173c7-991e-4440-aeec-acdcd4c87a60

I copied the code, opened PWCT2, and pasted it into the search text box. I know these copy‑and‑paste steps are manual, but after that PWCT2 converts the code into a visual program (Steps Tree + Interaction Pages + Time Dimension). Then I can click Play as Movie to watch the program being constructed step by step.

PWCT2 (Steam): Programming Without Coding Technology 2.0 on Steam

PWCT2 (GitHub): PWCT/PWCT2: Programming Without Coding Technology - Second Generation, written in the Ring programming language!

If you haven’t tried this combination (Claude AI + PWCT2), give it a try — it’s fun!

Greetings,

Mahmoud

[Bert Mariani]

Hello Clement

Are you able to convert the Queens-N program to LUA.

Then run the LUA version to see the results for  n = 12.

On your laptop can you report the speed numbers for

Ring, Lua, Python

Regards

Bert Mariani

[Mansour Ayouni]

Hello Mahmoud,

This will help us empower Ring and accelerate the development of many libraries and extensions the language lacks, especially in data science and machine learning domains.

I think it can even help you to quicker on many of the tasks you have on your own Ring development checklist...

All the best,

Mansour

--

---
You received this message because you are subscribed to the Google Groups "The Ring Programming Language" group.
To unsubscribe from this group and stop receiving emails from it, send an email to ring-lang+...@googlegroups.com.

To view this discussion visit https://groups.google.com/d/msgid/ring-lang/522258bd-162c-44ad-ba18-095e7a3251f4n%40googlegroups.com.

[Bert Mariani]

Hello Clement

With LUA   Queens-N-Lua.lua

LUA      3.19   seconds    9x faster  (an interpreted language)

RING  28.76   seconds

Can you verify on your computer ?

-- ======================================================
-- Possible placements are :
--
-- End   seconds: 3.190334
-- Start seconds: 0.001070
-- Total seconds: 3.189264
-- Exiting of the program...

[Clement]

Hi Bert,

With Lua on my PC:

Total Seconds : 4.416000

Ring:

Total Seconds : 41.50


Regards,

Clement

[Mahmoud Fayed]

Hello Bert, Clement

>> "LUA      3.19   seconds    9x faster  (an interpreted language)"

(1) Lua development started in 1993 (33 years ago), Ring development started in 2016 (10 years ago)

Could you try a Lua version from 2003 (When Lua was 10 years old), This will be interesting to see how Lua performance grows over time

(2) Lua comes with very few features compared to Ring, In Ring when we optimize the performance, we think about the different features, we need to keep each feature stable, simple implementation while doing optimizations that doesn't break stability or introduce unacceptable complexity

(3) As I said before Ring performance is improved over time, and I care about real performance results (from real applications shiped to customers) not from tests or benchmarks that are just done to test an implementation in general.

For example, these are the results for the Waving Cubes sample from RayLib

 

In this benchmark Ring 1.21 is two times faster than Python 3.13

While Ring 1.2 is slower than Python 3.13

Does this mean I stopped using Ring 1.2 because it's slower than Python in this test? ---> NO (For my real-world apps it's not matter)

And when Ring 1.21 becomes faster than Python in this test, does it mean I don't use Python for my projects? ---> NO, I use Python for ML tasks

I care about performance results when I do an optimization (as part of the work) or when developing a real-world project that needs these performance requirements

But doing performance improvements just for performance improvements, this is not my goal

>> "I was able to produce 7,000 lines of Ring code at high-quality (Model: Opus 4.5) "

Now this grows to over 8,500 lines of good code (You are busy to ask what this code does, because you are doing performance tests!)

This topic is about Claude Code and using it with Ring language

Instead of asking about the real productivity results and the good news, You are discussing run-time performance!

We are in 2026, When performance is necessary, just ask the AI to write a C extension for you using Ring API, and enjoy the productivity + performance at the same. time.

Greetings,

Mahmoud

[Mahmoud Fayed]

Hello

>> "Lua development started in 1993 (33 years ago), Ring development started in 2016 (10 years ago)"

To be accurate, these dates are related to (first public release date)

For example, Ring development started in Sept. 2013

Ring 1.0 is released for public usage in 2016.01.25

Greetings,

Mahmoud

[Mahmoud Fayed]

Hello Mansour

>> "This will help us empower Ring and accelerate the development of many libraries and extensions the language lacks, especially in data science and machine learning domains."

A completely different way to develop real-world software projects and libraries 

Where generating textual Ring code could be 100% done by Claude Code and the Ring programmer could focus on

1- Writing prompts

2- Testing results

3- Revising requirements

4- Selecting between different solutions

....

We dream, decide and review while the AI does the coding part

>> "I think it can even help you to quicker on many of the tasks you have on your own Ring development checklist..."

I am testing Claude Code to see if I can use it for generating 100% of my Ring code in particular project

At the current stage, I have over 8,500 lines of code in a few hours of work! (separated to two days)

Greetings,

Mahmoud

[Mansour Ayouni]

Hello Mahmoud,

A completely different way to develop real-world software projects and libraries

I agree. There are two aspects I think are key in embracing this disruptive moment in programming:

1. The programmer experience in designing programs with AI
2. The fundamental features native to a programming language for supporting this programmer experience

For the first point, you already described the flow from dream to code, with the steps you suggested. But programmers should pay attention not to lose control over the design of their software. Otherwise, AI will lead everything and they will never be able to take structural decisions on their projects. That's why, I think, only experienced programmers, with a strong flavor of architecture and solutions design would really benefit from this experience.

For the second point, Ring already has a distinctive feature of letting code feel natural. This means that every program we write in Ring can be formatted in a natural form that can easily be included in a prompting and AI dialog programming flow. Also, we can instruct the AI to make its code in a natural form similar to what Ring supports. Result : Ring talks natively to AI, and AI makes executable code in Ring!

I am testing Claude Code to see if I can use it for generating 100% of my Ring code

Edger to know what you are working on :D 

Best,

Mansour

To view this discussion visit https://groups.google.com/d/msgid/ring-lang/4ba00552-0be2-49fa-b834-efcc074c4ecdn%40googlegroups.com.

[Mahmoud Fayed]

Hello Mansour

>> "Result : Ring talks natively to AI, and AI makes executable code in Ring!"

That's one of my goals behind improving the NaturalLib, i.e. To develop many DSLs that uses natural commands and use them through AI 

>> "Edger to know what you are working on :D"

Something enabled me to 100% believe in Claude Code power in generating very useful Ring code

I developed a complete TUI framework for Ring language

Features:

1- Multiple windows (Movable, Resizable, Maximize/Restore, etc.)

2- Many Controls (Label, Textbox, EditBox, CheckBox, ComboBox, ListBox, Grid/TableView, TreeView, Tabs, Progressbar, Spinners, Scrollbars)

3- Each control could be used using the Mouse or using the Keyboard

4- Focus System for navigation

5- Menubar (Nested menus, Checkable items, etc.)

All of this without typing any lines of code, 100% of the Ring code (over 8,500 LOC) is generated by Claude Code (Opus 4.5)

(I write prompts, describe what I want, mentions errors/bugs) and Claude Code does everything!

The implementation uses many Ring features (variables, control structures, lists, functions, classes, objects, inheritance, composition, references using Ref(), etc.)

Screen Shots:

(1) Using Multiple windows

(2) The Menubar

(3) The Grid Control - We can move using arrows, enter to edit a cell, we can select any cell using the mouse, click to edit.

(4) The TreeView control

(5) Using Tabs

Greetings,

Mahmoud

[Mansour Ayouni]

Oh That's Wonderful!!

Thank you very much for sharing it...

To view this discussion visit https://groups.google.com/d/msgid/ring-lang/469d28ef-672a-42a0-abf5-d174589b66bbn%40googlegroups.com.

[Mahmoud Fayed]

Hello Mansour

You are welcome :D

Greetings,

Mahmoud

[Youssef Saeed]

Hello Mahmoud,

Thank you for sharing your experience using Claude Code to develop a TUI framework.

Have you tried OpenCode with oh-my-opencode? It is absolutely mind-blowing when paired with Claude Opus 4.5.

Best regards,
Youssef

[Mansour Ayouni]

Hello Youssaf,

Anthropic has disabled Claude models from being used inside OpenCode!

It does a similar thing before for other tools (Cursor...)

It wants developers to use only their ClaudeCode tool.

I think this is an alarming practice for a company that wants to become the Apple of coding tools and block developers only on its toolset...

Best,

Mansour

To view this discussion visit https://groups.google.com/d/msgid/ring-lang/431761a3-dcdb-4f4c-980f-7c05be09bdefn%40googlegroups.com.

[Youssef Saeed]

Hello Mansour,

You're absolutely right that Anthropic has blocked the direct integration of personal Claude subscriptions within third-party tools like OpenCode and Cursor. They are cracking down on "wrapper" implementations that spoof their official client to access the flat-rate web models.

However, they haven't blocked API access entirely.

You can still use Claude models inside OpenCode, but you now have two main options:

• Official Commercial API: Use a paid "Bring Your Own Key" (BYOK) from Anthropic, which charges per token rather than the flat $20/month subscription.
• Compatible Providers: Use a third-party provider that offers an Anthropic-compatible API endpoint supported by OpenCode.

It definitely feels like an "Apple-style" move to lock the most affordable, seamless experience to their own "Claude Code" tool, but at least the API path remains open for developers who need it.

Best regards,
Youssef

[Mansour Ayouni]

Hello Youssaf,

Thank you for those precisions!

Undedd, Anthropic is going in the wrong direction : they have the most powerful model for coding, no doubt! But their behavior will push conservative developers, teams and companies to bet on other models that are more open even if they are less powerful.

This is an interesting issue to follow closely and adapte one's strategy on using Anthropic models accordingly.

Personally, I'm diversifying the coding session between Claude, Qwen and Grock to offer them the chance to learn Ring and hence diversify the risk. And I'm using just the free versions online.

All the best,

Mansour

To view this discussion visit https://groups.google.com/d/msgid/ring-lang/61ba3169-a0eb-444f-8f50-eaf1bfb0ba80n%40googlegroups.com.

[Bert Mariani]

Hello Mahmoud

RE:  (1) Lua development started in 1993 (33 years ago), Ring development started in 2016 (10 years ago)

All that does not matter.

The comparisons are being made with Current Versions

Lack of Handling Arrays as Arrays shows the difference with Python and Lua

Just Add the "Type Array"  and get it over with. 

==============================  

Ran Queens-N-py.py

Enter value of n : 12

Possible placements are :

Start time   : 617397.9989788
End time     : 617401.8902597
Total Seconds: 3.891281
Exiting of the program...    

===============================

Comparison in seconds

______________________     Ratio  Ratio
              Bert    Clement   Bert     Clement
Lua         3.19     4.41       9.01x     9.41x
Python   3.89     6.74       7.37x     6.15x
Ring      28.76   41.50      _              _

=================================

Best Regards

Bert Mariani

[Youssef Saeed]

Hello Mansour,

You hit the nail on the head. While Anthropic currently has the smartest coding model, their restrictive ecosystem is pushing many of us to look for alternatives.

Best regards,
Youssef

[Clement]

Test results of Queen-N with Ruby 4.0.1 on my PC:

Regards,

Clement

[Mahmoud Fayed]

Hello Bert, Clement

(1) This topic is about Claude Code, your posts about performance benchmarks is considered SPAM

In general, please don't post to Ring Group again if you will keep repeating such posts (I hope to you good time using other programming languages that are designed to match your performance requirements) - While we are an open community, and we encourage everyone to share his ideas/thoughts, it's not acceptable to keep repeating sentences/benchmarks then try to tell us what to do with our time and try to force specific development direction. YOU ARE NOT MY CUSTOMER. And I can't dedicate a lot of my time just to reply to your messages and tell you again and again about Ring design philosophy which is already documented in Ring documentation and the Motivation section. Ring is a gift, an open-source project, take it or leave it, take it as it or modify it to match your needs, don't ask from me to do anything, we share what we want to share, not what you are asking from us to do (You don't have this power - We don't ask for feature requests). 

(2) In my previous posts, I explained in detail that Ring implementation for Lists is already good (We have very optimized linked-lists that cache the last accessed item, We use Array of Item structures when using the List() function, i.e. we use arrays without breaking the language features, Also, we have array of bytes using Space() function, etc.) and benchmarks shows that this is not the performance bottleneck in many programs. The Waving Cubes benchmark uses Lists and provides good performance. Again, what you are asking is partially implemented through List() function and if we did it 100% as you are suggesting by introducing new types at the language VM level, the performance gain will not be too much for most apps, while breaking one of the language core features of using small number of data types.

(3) Your benchmark (Queens) is not about Arrays/Lists performance, It's more about other things (Functions, Loops, if conditions, expressions, etc.). 

(4) We keep improving Ring performance over time, but Ring is already fast-enough for many apps and using Ring-API and C extensions enable us to get the best performance when this is a priority. Ring is a language designed for apps development (Not a replacement for C)

(5) Lua is faster than Python, Julia is faster than Python, Mojo is faster than Python, but for many people, when it comes to developing apps, they would prefer Python (Productivity, More Features, Batteries Included, Large Ecosystem, etc. Software development is not just about runtime performance and picking the language with the fastest implementation. There are many other things to think about.

(6) I care about Ring performance, you don't need to tell me to improve it, I do this along the time, other things have a priority. 

Greetings,

Mahmoud

[Mahmoud Fayed]

Hello Youssef

>> "Thank you for sharing your experience using Claude Code to develop a TUI framework."

You are welcome :D

>> "Have you tried OpenCode with oh-my-opencode? It is absolutely mind-blowing when paired with Claude Opus 4.5."

I will check them, Thanks for sharing :D

Greetings,

Mahmoud

[Ka mara]

Hallo Mahmoud,

Thanks for putting things in perspective regarding Bert, Clement.

This thread seemed very interesting for the start. I even starred it in emails, to go through it when I have time, I have been following it since the start, but was getting confused with these "performance" things which looked odd, compared to what the topic was about.

Regards,
Tim

To view this discussion visit https://groups.google.com/d/msgid/ring-lang/2e27cd06-a795-43d7-b93b-184662d0bbd1n%40googlegroups.com.

[Mahmoud Fayed]

Hello Tim

>> "Thanks for putting things in perspective regarding Bert, Clement."

You are welcome :D

>> "This thread seemed very interesting for the start. I even starred it in emails, to go through it when I have time, I have been following it since the start, but was getting confused with these "performance" things which looked odd, compared to what the topic was about."

Yes, we are in a unique age where using AI models for code generation provides high level of productivity, and enable us to do more in short time

Having Claude Code Support Ring language at very high quality is a big chance to take the language ecosystem many steps forward

Such a moment requires attention and fast adoption from serious developers.

Greetings,

Mahmoud

[Bert Mariani]

Hello Mahmoud

First of all this is not Spam.

Arrays were mentioned in this conversation at the beginning about AI and ML.

After 10 years and 25 versions of Ring this issue was brought up several times.

Always ignored, never an effort to address it.

Lists are NOT Arrays !

This was a Design Flaw from the very beginning that you refuse to acknowledge, address or fix

Its the "elephant in the room" 

Maybe you need Ring Version 2.0 

Maybe Clause AI can write the code.

Now you are upset when it is pointed out the Ring is still 10x Slower than Lua or Python

Even after  Ring is now 5x faster than it used to be, after improvements

RE: Your benchmark (Queens) is not about Arrays/Lists performance, It's more about other things (Functions, Loops, if conditions, expressions, etc.). 

If it is not about Arrays, then fix the ... 

  -  functions 

  -  loops

  -  if conditions

  -  expressions

  -  etc

And it is about Arrays !

How then are Lua and Python  so much faster ?

The simple (Queens) problem is showing the issues.

=========================

Documentation  ...

Also, Ring is influenced by the next programming languages

• Lua
• Python
• Ruby
• C

=========================

Best Regards

Bert Mariani

[Mansour Ayouni]

Hello Mahmoud and All,

Anthropic released an important document called Claude's Constitution about the principles and behavioral character of Claude that the company is pursuing on its training of the model.

Best,

Mansour

To view this discussion visit https://groups.google.com/d/msgid/ring-lang/151ae19e-ca4d-435b-8921-8590d4b8cb81n%40googlegroups.com.

[Ilir Liburn]

Hello Bert, All

Lists are NOT Arrays !

True, but in high level language like Ring, array can't be what is array in C because it is running under VM. Period. I learned that in hard way while developing Ring2C.

However, there is possibility to make jagged array like in Haxe and many other languages. I call it collection because it will serve different purpose.

I'll try to develop it directly for 1.25 and if it works well, make pull request.

Greetings,

Ilir

[Mahmoud Fayed]

Hello Bert

>> "First of all this is not Spam."

Do you need me to define what spam is? You don’t know that repeating the same message again and again about arrays is spam? 

You don’t know that posting about topics unrelated to the current discussion (Claude Code) and continuing to do so is spam? 

As the designer of the Ring language and the creator of the Ring VM, I’ve answered your questions multiple times, yet you still ignore the explanations and keep repeating incorrect information — what should we call that?

You’re not learning from my responses because you assume you know better, but the reality is that you don’t know what you’re talking about. Your knowledge of linked lists and arrays is just basic material that everyone already knows, and repeating it is a waste of my time. The Ring VM is a full system, and performance is a complex game. I’m not waiting for beginner‑level advice.

The Ring programming language was designed with specific goals. I set these goals, I implement them, and it’s my project. I know what truly affects runtime performance, and I know what matters more than runtime performance according to my original goals, because I’m the one who defines the language’s vision. 

You’re not happy with that? That’s fine — Ring is open‑source for a reason, so everyone is free to do whatever they want.
Your repeated mistake is trying to tell me what to do instead of learning from me. After that, you can choose to follow my vision or pursue your own, just like our friend Ilir is doing — and there’s nothing wrong with that.

The real problem is that you’re trying to take away my freedom to do what I choose — my ability to decide how I spend my time on my own project — from the person who actually created this programming language. You can’t do that. And yes, repeating this behavior again and again is spam.

>> "After 10 years and 25 versions of Ring this issue was brought up several times."

>> "Always ignored, never an effort to address it."

This is incorrect. The List() function implementation was updated to use an internal array of items. Through practical testing, we found that this optimization does not provide real advantages for most applications, for several reasons that I’ve already explained multiple times in my previous messages.

Also, I don’t have to invest effort based on your requests or messages — who are you to tell me what to do? If you want something done, go do it yourself in your own time, with your own money, by hiring a programmer, or by using AI. Again, you are not my customer, and this is an open‑source project.

Our collaboration as one team is based on doing what we truly want to do, doing it with passion, and choosing to share our work freely.

>> "Maybe you need Ring Version 2.0 "

I don't have a plan for Ring 2.0, my plan is around continuous development of Ring 1.x and keeping compatibility.

>> "If it is not about Arrays, then fix the ... "

I’m not waiting for you to tell me to do that or to tell me what to do — this is not your business. I care about Ring’s performance, but I care even more about other priorities. I decide what comes first. That’s my personal freedom.

>> "Now you are upset when it is pointed out the Ring is still 10x Slower than Lua or Python"

>> "The simple (Queens) problem is showing the issues."

I don't care about such benchmarks if I am not working on performance optimization task 

We can't say Ring is 2x faster than Python because of the Waving Cubes sample

Being faster than Lua or Python is not my goal

And I will not explain this to you again (I AM TIRED FROM REPEATING THE SAME INFORMATION)

FINAL WORDS:

Personally, I respect you as a contributor to the Ring project who has shared many samples and applications over nearly ten years. However, your continuous messages about Ring performance and array implementation are not acceptable and I consider it a SPAM. I’m not happy about having to make this decision, but it’s the right thing to do. If you bring up this topic again, I will treat it as a request for blocking, and you will be blocked from posting in the Ring Group without further notice.

[Mahmoud Fayed]

Hello Mansour

>> "Anthropic released an important document called Claude's Constitution about the principles and behavioral character of Claude that the company is pursuing on its training of the model."

Thanks for sharing :D

Greetings,

Mahmoud

[Mansour Ayouni]

Hello Bert,

Please don’t push the discussion down the wrong path by locking it into a dogmatic point of view that could ultimately undermine both the ethics of this group and the culture of open-source projects.

Mahmoud has always been kind enough to answer all your messages, explain things patiently, and let everyone learn from the discussion. However, you are not his employer, and it is not appropriate to use a tone that sounds like giving orders.

I myself have sometimes been critical of certain design decisions in Ring. Those discussions could be intense, but they always remained respectful. And when I understood that Mahmoud would not follow my suggestions at the language level, I accepted it and simply implemented my ideas at the library level instead.

Focusing too much on low-level aspects can also mean losing touch with the higher-level spirit of the language. That’s why I’m honestly wondering whether Ring is the language you feel most comfortable with.

I’m writing this not to blame you, but to share my opinion on this issue and to encourage you not to close yourself off or walk away from a journey we have been building together for many years now.

In the end, the decision is yours alone.

To view this discussion visit https://groups.google.com/d/msgid/ring-lang/494de7bb-b238-4ea6-99fe-2cc3b308d7bfn%40googlegroups.com.

[Mahmoud Fayed]

Hello Ilir

>> "I'll try to develop it directly for 1.25 and if it works well, make pull request."

Suggestion: It’s better to focus on Ring2C. Don’t waste your time trying to improve the performance of the original Ring implementation (I will do this at some point in my own way). You’re already working on a great project that brings high performance to Ring, making it suitable for game development and other performance‑critical systems. This is the real solution to the problem—something genuinely useful for anyone looking for a faster Ring (like our friend Bert).

The point is, once you deliver this solution to the community, it will be the real answer they’re waiting for. Based on the benchmark discussions, this is exactly what people want. You could gain Bert and Clement as your first users—and of course, I’ll be one too when I need Ring for game development.

Keep up the GREAT WORK :D

Greetings,

Mahmoud 

[Ilir Liburn]

Hello Mahmoud,

It is a part of the Ring2C development. Currently array elements are of one type only, I wanted to bring variety of element types. But as soon as I started development, I realized the same common problem with lists: repeating array structures until element is reached to ensure independent index access. You are right, will leave it for some other time.

Greetings,

Ilir