What features could be added to a new programming language to make it more "intuitive"? When it comes to websites and desktops, we favor high usability, almost intuitive usability. It is becoming increasingly expected that your application should "just work". For a certain class of applications the idea that one has to RTFM, is a mark against the effectiveness of the application. People tend to expect the application to just work the way they "think" it should work. One could argue that this is a worthy standard that designers should strive for.
Can the same usability rigor apply to programming languages and developer environments? I realize there are tools like IntelliSense that provide hints, and a good IDE provides a lot of assist. But what about the core language itself? What could be added (or removed) that makes certain programming techniques or algorithms more obvious to implement? How does one make regular expressions or recursion more intiutive? Or is this just folly?
Take a more concrete example: liquid layouts in HTML, CSS, or Flex and MXML. In HTML and CSS, the box model is anything but intuitive given the different implementations of Internet Explorer and the other browsers. And unless someone reads the documentation or studies the concept of the box model it would be difficult to "just get it" when designing a layout on one's first stab at CSS. I would argue this is why tables thrived in the early days. The box model was implicit in the concept of a table cell. With the help of tools like Dreamweaver one could get their mind around percentage widths and layout within the constraints of table cells. Then CSS came into maturity and a whole set of valid reasons emerged for why tables are not for layout. But to achieve the same effects designers had to really study the CSS implementations and the box model, and inject a new layer of abstraction into their thinking.
In another example, I find when programming lots of things in ActionScript and MXML, the whole concept of fluid layouts and percentage based widths of elements not very obvious and doesn't always follow intuition. I understand the basic problem in that the Adobe Flash player and the layout need to understand things in absolute pixel terms. When it comes to the potential width of a component, I understand why percentages are not immediately obvious to implement at the core level of the code. Theoretically speaking the Flash Player needs to know (or calculate) the exact width of a component so that it can provide the proper geometry to the video card when doing a draw on the screen. But when you introduce some concept of percentages then you introduce the theoretical possibility of an infinite width. And to find "infinity - 1" pixels is not something a computer can directly do without some layer of abstraction and calculation. The viewport must be referenced. The program must know its boundaries. So absolute widths are the norm, although humans might prefer to design in terms of percentages.
When it comes to programming languages can there be expressions and features that assist intuition when thinking about a programming task. Or are we better off "thinking like a computer" and just RTFM'ing the manual when we need to understand how to implement some feature or layout in code?
If you could change the syntax or semantics of your programming language of choice what would you add, change, or remove to improve the "intuitiveness" of it?
Addendum, the reason for asking this question is inspired by seeing example of what "novices" were able to achieve in Smalltalk in Alan Kay's lecture: Doing with Images Makes Symbols.