There seems to be a trend towards immutable objects, and pure functional programming. While I recognize the benefits, I find it hard to apply these principles to GUI programming, for example. But I also find classical imperative languages with mutable objects lacking. I was wondering whether there is a language or system that embraces mutable state, and makes it especially easy to work with.Below are some features I would consider to be designed around mutability:The ability to hook up events and get a change notification for any variable. It would make it very easy to write GUIs and MVC applications. And you could just make a List<MyObject>, and stuff it into a list widget, and with a bit of configuration it would manage your list for you, no manual listview.insert() etc..A type system that considers state. For example, If I pass a Car into a function that requires a working one, the compiler should try to proove that car.broken == False. If it can't proove it, it won't compile, and I have to ensure it (by putting the code in an if block, or setting it manually to False).A take on concurrency that makes sense for mutable objects. For example an atomic statement, that guarantees that certain statements are run together, using transactions or locks. The goal is not performance, but ease of use and GUI responsiveness. I should be able to manipulate data and the GUI from any thread, using atomic {step1; step2} to ensure invariants.I'm not looking for a system with these exact features, but one written in a similar spirit. The closest I've seen to this is C#/.NET with its data binding features.Gtk+ has custom ListModels that keep a GtkTreeView in like with your data without manual inserts/updates. Android has ListAdapters which are similar. I haven't found a thread-safe GUI, but you can get pretty close with a liberal use of Invoke() in C#/WinForms, or gobject_idle_add in Gtk+. Are there any systems like what I describe? Or research material, references, etc.?
Language that embraces mutable state?
language design;immutability