These are things where, in retrospect, I think I made the wrong choices designing Suneido.
The challenge with changing any of these is not breaking existing code, or at least doing it in such a way that the broken code is obvious.
One approach is to support both the old and the new behavior during a "transition" period. The old way would be "deprecated", ideally in a way that can be automatically detected. Even if it can't be automatically detected, the programmer can still gradually switch code to the new way and then run tests to hopefully detect any problems.
Objects and Records Should Not Be Separate
I've talked about this before.
One of the reasons they're separate is that I didn't want the overhead of rules on every object. But the overhead is very small and this was likely premature optimization.
One problem with combining them is the record default value (see below).
Another problem is the global attachment of rules (see below). This could potentially "break" existing code.
Class Instances and Objects Should Not Be Combined
I think I did this mostly for ease of implementation. I may have also thought it reduced the number of concepts in the language.
However, class instances still have different behavior from regular objects so it didn't really simplify the language.
This means that class instances have all the same functionality as objects, like for-each and Map! and Sort!. But most of these don't or at least shouldn't be applied to class instances. If anything, this tempts programmers to "take advantage" of this, leading to unclear code.
On top of this, certain object methods are "basic" and can't be redefined/overridden. This was done both for performance (probably minor) and so that people reading the code would know the meaning of the basic methods without having to determine if they had been redefined.
One resulting drawback, is that a class can't define a method with the same name as a basic method. e.g. a Stack class can't define a Size method. You can use a different name e.g. Tally, but that means less consistent method names. It also means someone can mistakenly call e.g. Size instead of Tally and not realize the mistake since they won't get an error.
Objects also support vector/array data, which isn't needed for classes.
Internally, class instances could still be objects, but it probably makes more sense to separate them since you wouldn't end up using much of the object code.
Changing class instances to not have all the same functionality as objects shouldn't break too much existing code.
Records Should Not Have a Default Value
record.foobar will have a value of "" even if foobar is not a member of the record, similar to an object where you had Set_default("")
One of the reasons for this is that database records may be physically "missing" fields. One way this can happen is if you create new fields on a table. Existing records are not updated, they are just missing these fields. Having a default value handles this.
It is also a small memory gain when you have many empty ("") fields because they don't need to be stored in the object.
The downside is that if you use the wrong field name or make a mistake in the field name, you don't get an error and the mistake can go unnoticed.
One way to keep the advantages and fix the downside would be to have records "know" their valid fields. For these fields, they would still return "", but invalid fields could throw an exception (like objects throw "member not found").
This would break existing code that depends on this default value.
Rules Should Not be Global
When you create a rule, e.g. Rule_foobar, it will be used anywhere that you reference record.foobar
Like anything "global" this means that changes in one place, e.g. adding a rule, could break code in another place.
It also means that the only way to have a different rule applied, or to apply a rule only some of the time, is to use different field names. Which can be confusing, and can lead to extra complexity in other rules that have to deal with different field names at different times.
You should be able to attach/detach rules on a record.
For rules you want "all the time" you could attach them in the table schema so whenever you read a record from that table it would have the rule attached.
This would break existing code that creates a record (not from the database) and expects rules to apply.