I haven't used Lua, and only met Python in passing. C++ on the other hand, I know. Not a guru, but proficient. So what does that mean? I wouldn't be afraid of C++, and certainly feel I could learn Python or Lua. I would lean towards the more 'C-like' choice for obvious biased reasons. From arguments given above I'd choose Python.

(I think I will stop talking about Python and Lua now and focus on what I consider better options)

Since it was brought up, AngelScript's support for multi-threading is left to the application making use of it. You can have one instance per thread as in Lua. You can have one real thread manage multipe 'script threads' with custom cooperative or pre-emptive multithreading (an add-on is provided with the VM source code to help with thist). Finally, you can have one real thread per 'script thread'.

In terms of memory management, AngelScript is kind of like Python though from what I recall of the API for including Python scripts it gave the application less control. AngelScript allows the host application to tell it what functions to call to allocate and free memory (it defaults to the C Library's malloc and free). Objects are ref counted and it has garbage collection for detecting and dealing with circular references (which is very important, as you would otherwise have memory leaks; and the reason for using a scripting langauge is to avoid that). The collection process and be done incrementally (doing all a bit at a time), destroying all know circular referenced objects, and full cycle (for idle time only as it takes awhile). This allows the application stay reponsive and only stop to collect garbage when the time is right.

As I understand it, the garbage collecting is not thread safe even when AngelScript was configured at compile time to deal with multi-threading. That is why mentioning the threading stuff was important. With one script engine instance per thread, it is not a problem as GC is done on a per engine basis. With the other threading models you control threading and GC therefore you can decide how to deal with this.

AngelScript is made to be embedded in an application and interfaces well with C/C++ modules. All the work is done on the application / native module side, which is more likely to be done by people with better programming skills. This is mainly registering functions, objects, and classes with some work being needed for calling scripts (scripts call native functions the same way you would another function in the script). The types used are the same the application/module uses so there is no conversion needed.

Calling scripts requires more work for native code, but that is generally the case when passing arbitrary data to a function wherever it comes from. As far as I can tell, the application can call the functions registered with the script engine the same way it could functions from scripts [Edit: You can call functions registered with AngelScript the same way as you do the scripts]. This would save the trouble of devising a way to pass arbitrary data to the functions (which is a must when what data is being passed is decided at run-time).

You can see a list of features at: http://www.angelcode.com/angelscript/features.asp

The system I would most like to see is the inclusion of two asian computer science majors for every registered serial number pre-FE. That way, I won't have to learn (yet) another coding language.

I have coded in C++, Lua and Python.

First of all, while being able to code a little in C++ would be useful in the long course, when very complicated mod will happens, it should never be the main way to do so, as it is much harder to learn than the alternatives.

I would tend toward Lua over Python, even though the class syntax is not very pretty, I believe that most mods will mostly rely on functional programming than object-oriented programming, so a little ugliness in the later can be excused.

But one of the main advantage of Lua, is that it is very powerful for data representation. So you could replace all the XML data by Lua data, which will allow more flexibility, such as data fields that could be filled by either values or functions. Some example:

Obviously having all these fields which can be either values or functions would require some overhead before using them (checking which they are), but the added functionality is huge.

(Yes, Python can do the same, but the whitespaces are even more of an issue when the goal is simply to represent data.)

As one who had to deal with Fortran 77: awesome! The more people to share the pain, the better!

That's exactly what I was thinking

Once you have learned one langauge, learning the others is not that hard.

And learning a langauge is the easy part if you are going to do more than simple data manipulation.

What proper indenting is a subject of debate in langauges where it is merely cosmetic as some find certain ways of doing it more readable. And forgetting a tab should not be able to cause issues.

I am not one to argue for sloppiness so much as robustness.  While many of the obviously professional developers are making a strong case for the power of Python, I do not think that was ever in question.

It sounds like Lua would be the more forgiving / robust language for people without formal CS training / dev experience and those weekend coders who understand it, but do not live it. ( THATS ME ) 

Better multi-threading is great, but I am never going to try and implement that, and I do not think the majority of modders want to (just too complex for a hobby project).  Given that this will be used primarily by people engaged in hobby projects versus full on development efforts, would you still argue as strongly for Python on the scripting side? )

However better multithreading will make it easier for the application to keep the scripts from messing up because of it. The threading will likely be the application calling scripts from multiple thread rather than the scripts actually doing multi-threaded work on their own.

Meh, I only noticed because last night I skimmed through the documentation of the library I mentioned. They are almost the same thing, just functional takes it to an extreme.

You are correct that simple procedures is most of what scripting will be for, so my samples on the first page give a good comparison of them. And dynamic typing vs. static typing is the only major diffrence (static being AngelScript and C++).

I know, I have fairly proficient knowledge of Java. But as a number of classes at my school use Python, and none use Lua, I'd rather put effort into learning a language I would use outside of Elemental. Of course, I wouldn't expect Stardock to make a choice just from what would be better for me...

 Then you should promote AngelScript; the most major thing to learn transitioning to it from Java is that 'static' varaible and funtions can be placed outside of classes and have static left off.