(Poll) What features do you wish you had in AutoIt?

[argumentum]

1 hour ago, jchd said:

Ability to create arrays from a text statement using Execute (like https://www.autoitscript.com/trac/autoit/ticket/3702)

I don't see C, or C see. I don't know C. But when the chatter is not getting anywhere I wanna see code. Once I see the code, I have something that I can look at.
So I'd propose to share the C code that does what one would like included, if the person can read/write C, share that for evaluation of a yey/nay integration into the product.
Otherwise we would have to hope that what we wish, can be easily implemented by the god like master*

*to me those that can see C, are almighty and there is nothing that can escape their infinite experience coding my dreams.

[jchd]

I don't see the relationship with C, but wait I can answer.

Long ago I coded a function able to sort a given array of any dimension (up to the maximum of 24) using a user-provided function. The user knows the array structure and will have no problem providing a function for comparing two rows and deciding which is greater. It can be a complex compare of a complex filed or a non-trivial multi-column sort.

To do this in plain C you use a function named qsort which does the job very efficiently (using introsort, heapsort and insertion sort). To do the same in AutoIt you'll have to build a 1D array of indices for storing the initial indices of the unsorted array, invoke the compare function and change the 1D array in new indices being sorted. When the sort is complete, copy the unsorted elements in sorted order.

Unfortunately (or fortunately) we don't have pointers in AutoIt so we have to copy array rows element by element, dimension by dimension. Also since we can have to handle arrays of any dimension, we can't build a text statement and execute it, so we have to code things like that:

expandcollapse popup

Switch UBound($aStruct)
        Case 1
            Redim $aRet[$aStruct[0]]
        Case 2
            Redim $aRet[$aStruct[0]][$aStruct[1]]
        Case 3
            Redim $aRet[$aStruct[0]][$aStruct[1]][$aStruct[2]]
        Case 4
            Redim $aRet[$aStruct[0]][$aStruct[1]][$aStruct[2]][$aStruct[3]]
        Case 5
            Redim $aRet[$aStruct[0]][$aStruct[1]][$aStruct[2]][$aStruct[3]][$aStruct[4]]
        Case 6
            Redim $aRet[$aStruct[0]][$aStruct[1]][$aStruct[2]][$aStruct[3]][$aStruct[4]][$aStruct[5]]
        Case 7
            Redim $aRet[$aStruct[0]][$aStruct[1]][$aStruct[2]][$aStruct[3]][$aStruct[4]][$aStruct[5]][$aStruct[6]]
        Case 8
            Redim $aRet[$aStruct[0]][$aStruct[1]][$aStruct[2]][$aStruct[3]][$aStruct[4]][$aStruct[5]][$aStruct[6]][$aStruct[7]]
        Case 9
            Redim $aRet[$aStruct[0]][$aStruct[1]][$aStruct[2]][$aStruct[3]][$aStruct[4]][$aStruct[5]][$aStruct[6]][$aStruct[7]][$aStruct[8]]
        Case 10
            Redim $aRet[$aStruct[0]][$aStruct[1]][$aStruct[2]][$aStruct[3]][$aStruct[4]][$aStruct[5]][$aStruct[6]][$aStruct[7]][$aStruct[8]][$aStruct[9]]
        Case 11
            Redim $aRet[$aStruct[0]][$aStruct[1]][$aStruct[2]][$aStruct[3]][$aStruct[4]][$aStruct[5]][$aStruct[6]][$aStruct[7]][$aStruct[8]][$aStruct[9]][$aStruct[10]]
        Case 12
            Redim $aRet[$aStruct[0]][$aStruct[1]][$aStruct[2]][$aStruct[3]][$aStruct[4]][$aStruct[5]][$aStruct[6]][$aStruct[7]][$aStruct[8]][$aStruct[9]][$aStruct[10]][$aStruct[11]]
        Case 13
            Redim $aRet[$aStruct[0]][$aStruct[1]][$aStruct[2]][$aStruct[3]][$aStruct[4]][$aStruct[5]][$aStruct[6]][$aStruct[7]][$aStruct[8]][$aStruct[9]][$aStruct[10]][$aStruct[11]][$aStruct[12]]
        Case 14
            Redim $aRet[$aStruct[0]][$aStruct[1]][$aStruct[2]][$aStruct[3]][$aStruct[4]][$aStruct[5]][$aStruct[6]][$aStruct[7]][$aStruct[8]][$aStruct[9]][$aStruct[10]][$aStruct[11]][$aStruct[12]][$aStruct[13]]
        Case 15
            Redim $aRet[$aStruct[0]][$aStruct[1]][$aStruct[2]][$aStruct[3]][$aStruct[4]][$aStruct[5]][$aStruct[6]][$aStruct[7]][$aStruct[8]][$aStruct[9]][$aStruct[10]][$aStruct[11]][$aStruct[12]][$aStruct[13]][$aStruct[14]]
        Case 16
            Redim $aRet[$aStruct[0]][$aStruct[1]][$aStruct[2]][$aStruct[3]][$aStruct[4]][$aStruct[5]][$aStruct[6]][$aStruct[7]][$aStruct[8]][$aStruct[9]][$aStruct[10]][$aStruct[11]][$aStruct[12]][$aStruct[13]][$aStruct[14]][$aStruct[15]]
        Case 17
            Redim $aRet[$aStruct[0]][$aStruct[1]][$aStruct[2]][$aStruct[3]][$aStruct[4]][$aStruct[5]][$aStruct[6]][$aStruct[7]][$aStruct[8]][$aStruct[9]][$aStruct[10]][$aStruct[11]][$aStruct[12]][$aStruct[13]][$aStruct[14]][$aStruct[15]][$aStruct[16]]
        Case 18
            Redim $aRet[$aStruct[0]][$aStruct[1]][$aStruct[2]][$aStruct[3]][$aStruct[4]][$aStruct[5]][$aStruct[6]][$aStruct[7]][$aStruct[8]][$aStruct[9]][$aStruct[10]][$aStruct[11]][$aStruct[12]][$aStruct[13]][$aStruct[14]][$aStruct[15]][$aStruct[16]][$aStruct[17]]
        Case 19
            Redim $aRet[$aStruct[0]][$aStruct[1]][$aStruct[2]][$aStruct[3]][$aStruct[4]][$aStruct[5]][$aStruct[6]][$aStruct[7]][$aStruct[8]][$aStruct[9]][$aStruct[10]][$aStruct[11]][$aStruct[12]][$aStruct[13]][$aStruct[14]][$aStruct[15]][$aStruct[16]][$aStruct[17]][$aStruct[18]]
        Case 20
            Redim $aRet[$aStruct[0]][$aStruct[1]][$aStruct[2]][$aStruct[3]][$aStruct[4]][$aStruct[5]][$aStruct[6]][$aStruct[7]][$aStruct[8]][$aStruct[9]][$aStruct[10]][$aStruct[11]][$aStruct[12]][$aStruct[13]][$aStruct[14]][$aStruct[15]][$aStruct[16]][$aStruct[17]][$aStruct[18]][$aStruct[19]]
        Case 21
            Redim $aRet[$aStruct[0]][$aStruct[1]][$aStruct[2]][$aStruct[3]][$aStruct[4]][$aStruct[5]][$aStruct[6]][$aStruct[7]][$aStruct[8]][$aStruct[9]][$aStruct[10]][$aStruct[11]][$aStruct[12]][$aStruct[13]][$aStruct[14]][$aStruct[15]][$aStruct[16]][$aStruct[17]][$aStruct[18]][$aStruct[19]][$aStruct[20]]
        Case 22
            Redim $aRet[$aStruct[0]][$aStruct[1]][$aStruct[2]][$aStruct[3]][$aStruct[4]][$aStruct[5]][$aStruct[6]][$aStruct[7]][$aStruct[8]][$aStruct[9]][$aStruct[10]][$aStruct[11]][$aStruct[12]][$aStruct[13]][$aStruct[14]][$aStruct[15]][$aStruct[16]][$aStruct[17]][$aStruct[18]][$aStruct[19]][$aStruct[20]][$aStruct[21]]
        Case 23
            Redim $aRet[$aStruct[0]][$aStruct[1]][$aStruct[2]][$aStruct[3]][$aStruct[4]][$aStruct[5]][$aStruct[6]][$aStruct[7]][$aStruct[8]][$aStruct[9]][$aStruct[10]][$aStruct[11]][$aStruct[12]][$aStruct[13]][$aStruct[14]][$aStruct[15]][$aStruct[16]][$aStruct[17]][$aStruct[18]][$aStruct[19]][$aStruct[20]][$aStruct[21]][$aStruct[22]]
        Case 24
            Redim $aRet[$aStruct[0]][$aStruct[1]][$aStruct[2]][$aStruct[3]][$aStruct[4]][$aStruct[5]][$aStruct[6]][$aStruct[7]][$aStruct[8]][$aStruct[9]][$aStruct[10]][$aStruct[11]][$aStruct[12]][$aStruct[13]][$aStruct[14]][$aStruct[15]][$aStruct[16]][$aStruct[17]][$aStruct[18]][$aStruct[19]][$aStruct[20]][$aStruct[21]][$aStruct[22]][$aStruct[23]]
        Case Else
            Return SetError(1, 0, 0)
    EndSwitch

or worse:

expandcollapse popup

; copy entries of $aTmp to $aArray in order of $oIndices
    ; AutoIt being unable to address/access subarrays and Execute row-wise assignments makes the code ridiculously painful and slow
    Switch $iDims
        Case 1
            For $a = $iStart To $iEnd
                If $__aIndices[$a] <> $a Then $aArray[$a] = $aTmp[$__aIndices[$a]]
            Next
        Case 2
            For $a = $iStart To $iEnd
                If $__aIndices[$a] <> $a Then
                    For $b = 0 To $aUBounds[1]
                        $aArray[$a][$b] = $aTmp[$__aIndices[$a]][$b]
                    Next
                EndIf
            Next
        Case 3
            For $a = $iStart To $iEnd
                If $__aIndices[$a] <> $a Then
                    For $b = 0 To $aUBounds[1]
                        For $c = 0 To $aUBounds[2]
                            $aArray[$a][$b][$c] = $aTmp[$__aIndices[$a]][$b][$c]
                        Next
                    Next
                EndIf
            Next
        Case 4
            For $a = $iStart To $iEnd
                If $__aIndices[$a] <> $a Then
                    For $b = 0 To $aUBounds[1]
                        For $c = 0 To $aUBounds[2]
                            For $d = 0 To $aUBounds[3]
                                $aArray[$a][$b][$c][$d] = $aTmp[$__aIndices[$a]][$b][$c][$d]
                            Next
                        Next
                    Next
                EndIf
            Next
            Case 5
                For $a = $iStart To $iEnd
                    If .Item($a) <> $a Then
                        For $b = 0 To $aUBounds[1]
                            For $c = 0 To $aUBounds[2]
                                For $d = 0 To $aUBounds[3]
                                    For $e = 0 To $aUBounds[4]
                                        $aArray[$a][$b][$c][$d][$e] = $aTmp[.Item($a)][$b][$c][$d][$e]
                                    Next
                                Next
                            Next
                        Next
                    EndIf
                Next
......... up to dimension 24

This is ridiculous.

Points 2, 3 & 6 in my previous post would make that possible and valuable, else things are too slow to be of real use.

See how difficult it is to sort a simple 2D array on several columns or with a custom compare function. Every case needs a specially tailored function!

[JockoDundee]

8 hours ago, jchd said:

Ability to read/write any subarray: say we have $a[3][2][4], then $a[1][0] would evaluate to the 1D array formed by $a[1][0][0..3]. $a[1] would eval to the 2D subarray $a[1][0..1][0..3]

Also nice would be the ability to write nested arrays instead of just read them with ([])[] syntax, (or better).

[argumentum]

2 hours ago, jchd said:

To do this in plain C you use a function named qsort which does the job very efficiently (using introsort, heapsort and insertion sort)

That is what I meant. Maybe, if the function to get it done is provided, is a no brainer, hopefully, and it'd be just added, if it don't go against:
1) the spirit of the product and
2) previous code limitation
Is just a thought. Maybe in your experience ( as MVP ) what I'm saying is "opinions of those inexperienced" / "clueless", and that, I couldn't negate.

[TheDcoder]

@Earthshine Good to know that you'd use EasyCodeIt if those features were implemented.

12 hours ago, TheSaint said:

If I read you right, you are saying that AutoIt3.exe itself includes unwanted elements?

Yes, but I was not referring to AutoIt itself in my message, I was talking about ECI. As you can see from the amount of suggested features in this thread, some of those would take a couple of good megabytes

No reason to have any of that around if your code isn't using those bits. Also this would make the job of AVs easier as they can actually check if the code needs networking or crypto to determine if it is a virus, win-win for everyone.

9 hours ago, jchd said:

1. Some form of file scope for variables (and functions?) or namespaces. E.g. in a source file, Restrict $a = 12345 would declare a variable $a for this file only.

We have discussed namespaces already, I plan to introduce them as they could be used to maintain backward compatible version of functions etc. while also providing improved versions of the same functions.

Perhaps it could also be useful to get rid of very long prefixes to variable and function names in UDFs.

Quote

Ability to read/write any subarray: say we have $a[3][2][4], then $a[1][0] would evaluate to the 1D array formed by $a[1][0][0..3]. $a[1] would eval to the 2D subarray $a[1][0..1][0..3]

You have bought up a good point, I am not sure if I will implement multi-dimensional arrays, instead I am thinking about implementing first-class support for sub-arrays, meaning you can assign an array like a normal value to any other variable, including arrays.

C has the same implementation, you can't have multi-dimensional arrays but you can have arrays inside arrays.

Quote

Ability to create arrays from a text statement using Execute (like https://www.autoitscript.com/trac/autoit/ticket/3702)

This would not be needed if arrays are implemented in the method mentioned above. I will also be introducing array literals, this should give array objects first class support as opposed to the sort of exotic objects they are now in AU3.

Quote

Ability to pass blank arguments to functions (that or named arguments): fct($a, , "abcd", , 47) would mean fct($a, Default, "abcd", Default, 47)

Should be easy to implement, named arguments aren't bad either.

Quote

Extend the max number of cells (currently 2²⁴) in an array, possibly using a pragma

Again, array as a first-class object means you can have arbitrary amount of recursion or cells (only limited by memory and integer representation size).

Quote

Atomic exchange of 2 variables (including array elements or sub-arrays) without having to make 3 copies with intermediate variable: $a >< $b

Struggled with this issue myself, so will definitely implement an atomic swap operation for variables.

Quote

1. Lists + list functions

This was already suggested atleast once before, what's the difference between them and arrays? Perhaps you can link to relevant material (according to what you mean by "lists"?)

Quote

Ability to modify the actual element that the running variable $x represents in For .. In constructs: For $x in $aArray  ...  $x! &= "abc"  would apply to what $x currently "points to", while $x &= "abc" would only change $x locally and not the array element (as it currently does).

Another thing which I thought of before, will definitely look into implementing... perhaps the syntax can be For ByRef $x In $aArray so that $x will always reference the same object that is in the array.

--

Without quoting jchd's huge post about sorting, I think a good idea will be to implement native in-place sorting with the help of a custom function, similar to how qsort works.

[JockoDundee]

On 7/21/2021 at 7:37 AM, jchd said:

For $x in $aArray  ...  $x! &= "abc"  would apply to what $x currently "points to"

as well as the local $x, or would the local $x not change?

[seadoggie01]

I think the only thing I wish for in AutoIt is objects. If I had an object then I would never pick up Java. (I realize that there's a project for this, but I don't understand it well at all). I've been writing a browser extension in JavaScript lately and re-remembered how much I miss them

Edit: Well... objects and speed I should say. If I have slow objects I'd probably keep using Java. One can dream though, right?

Edited July 24, 2021 by seadoggie01

[Alecsis1]

Hello everyone!

• Cross-platform support imho is not too necessary. AutoIt was designed as a Windows-oriented tool from the very start… 
• Multithreading? Easy to say but may take a long time and too much efforts to implement.
• Other features:
  • Variables/constants must be pre-declared. Therefore no chances for a whole lot of nasty bugs caused by such undeclared ones. 
  • Basic set of preprocessor capabilities as #define/#undefine, #if/#elseif/#endif might be useful.
  • At this moment, Local and Global declarations in main module are equivalent. I suggest Local declarations to be not accessible within functions, for example

• Global $a
  Local $b
  ; some code ....
  Func Test()
      ConsoleWrite($a)    ; Ok
      ConsoleWrite($b)    ; should cause compile-time error
  EndFunc

  Introduce Scope/EndScope block for temporary local variables/constants, and declare own local ones like here

• Local $a, $b, $c
  ; some code ....
  Scope
      Local $a        ; not the same as $a declared above
      Local $x, $y    ; accessible within this block only
      ; some code .... 
  EndScope
  ConsoleWrite($x)    ; ERROR! $x is not declared at this point
  While(True)
      Local $x        ; same behavior as within scope/endsope block above
      ; some code .... 
  WEnd
  For $i = 1 to 10    ; if $i is not declared yet, it's declared and visible within For/Next only
      Local $k        ; same behavior as within scope/endsope block above
      ; some code .... 
  Next
  ; and so on

   

PS Sorry for my weak English

Edited July 24, 2021 by Alecsis1

[jchd]

7 hours ago, JockoDundee said:

as well as the local $x, or would the local $x not change?

Then $x!! &= "abc" could change both.

[JockoDundee]

7 hours ago, jchd said:

Then $x!! &= "abc" could change both.

Love the double factorial notation!

[TheDcoder]

@seadoggie01 I see the appeal as a JS programmer myself, but objects in JavaScript are very different from object in Java if I am correct.

According to my knowledge, Java is a statically typed language so you need to declare your objects and their type before you can use them, and the object inheritance is implemented using a class system.

JavaScript on the other hand lets you do whatever you want with objects and inheritance is "prototypial", where an object can inherit properties form a parent object, which is just a normal object like any other, no special types etc., so it is very dynamic and duck typing is king

So which kind of objects do you prefer?

@Alecsis1 Hi, thanks for posting, your English is a lot better than some people who are native speakers but suck at writing, more than suitable for communication

Quote

Cross-platform support imho is not too necessary. AutoIt was designed as a Windows-oriented tool from the very start… 

In the context of AutoIt it is agreeable, but personally my primary goal to make another language was so that I can use it anywhere. I switched to Linux a couple of years ago and I have been missing AutoIt ever since, I am still using it for work but all my personal projects have been effectively halted because I can't use it in Linux.

Quote

Multithreading? Easy to say but may take a long time and too much efforts to implement.

There is some truth, but it is a very nice feature which easily out-weighs any disadvantages. So it is better to add them at the beginning instead of doing it after you already have a single-threaded codebase.

I am sure many programmers would relate to the urge to start writing from scratch again instead of reworking a large part of some code... don't want to make that mistake with this project

The other features are noteworthy, thanks for posting them.

@jpm @JockoDundee That kind of syntax is the last thing I want to see in AutoIt!

[rcmaehl]

Modular Scripts. Is Execute REALLY needed? Can we really trust user input? Also the huge amount of DLL loading  probably doesn't help with AV false positives

[TheDcoder]

3 minutes ago, rcmaehl said:

Is Execute REALLY needed? Can we really trust user input? Also the huge amount of DLL loading  probably doesn't help with AV false positives

Absolutely agree with your points.

I was planning to axe Execute anyway because the parser is going to be decoupled from the interpreter. We need to keep the loaded dependencies to a minimum.

[jchd]

If Execute is smelling that bad, please offer an alternative to the sample AutoIt code I posted above.

[seadoggie01]

15 hours ago, TheDcoder said:

So which kind of objects do you prefer?

Java's objects, but only because I know them much more. I'm sure with a bit of time I won't mind JS's objects. And I probably would mind JS's objects less if the IDE found more errors, but that's another story. Edit: And your knowledge on Java vs JS objects seems to be correct... as far as my knowledge goes

@jchd Correct me if I'm wrong, but with the style of array TheDcoder has mentioned, an array element will contain another array. So you could recurse through each array's elements to sort them. Something like this:

Function _SortNDimensionArray($aArray, $vFunc)
    ; For each element
    For $i=0 To UBound($aArray) - 1
        ; If the element is an array
        If VarGetType($aArray[$i]) = "Array" Then
            ; Sort the inner array
            _SortNDimensionArray($aArray, $vFunc)
        EndIf
    Next
    ; Actually sort the array
    Call($vFunc, $aArray)
EndFunction

(P.S. Recurse is a word, right? Wiki has it listed, but Chrome says it's a typo)

Edited July 25, 2021 by seadoggie01

[Musashi]

28 minutes ago, seadoggie01 said:

(P.S. Recurse is a word, right? Wiki has it listed, but Chrome says it's a typo)

OT : https://www.lexico.com/definition/recurse

Quote

recurse

Pronunciation /rɪˈkəːs/

verb

• 1. Mathematics Computing
  To carry out a recursive procedure; to perform the same sequence of operations on successive results.

• 2. To perform (a mathematical or computational operation) again on the result of the previous operation; to repeat (an operation) recursively.

Origin

Mid 17th century (in an earlier sense). From classical Latin recursāre to keep running back, return again and again, to keep recurring to the mind (frequentative formation from recurrere); in later use after recursion and recursive.

[rcmaehl]

34 minutes ago, seadoggie01 said:

(P.S. Recurse is a word, right? Wiki has it listed, but Chrome says it's a typo)

Did you mean recurse?

Edited July 25, 2021 by rcmaehl

[seadoggie01]

9 minutes ago, rcmaehl said:

Did you mean recurse?

This looks the same to me. Someone please DM the difference. My poor dyslexic brain hurts now 

Edit: Oh, wait, this was a joke wasn't it, lol

Edited July 25, 2021 by seadoggie01

[RTFC]

Sorry for the delay in replying. On byte vs machine code:

On 7/21/2021 at 2:53 AM, TheDcoder said:

perhaps it can later be used by different compilers which could target different instruction sets

That's fair enough. Nowadays I run all my own codes on Intel-compatible architecture only (under Windows or linux VM); the trouble I keep running into when AutoIt is controlling the higher-level/interfacing stuff is that bytecode is just too slow for things like data conversion, for example reading in a large csv file and converting the contents to binary floats/doubles; it can literally take many hours. If I call a machine-code compiled equivalent in dll (works regardless of OS as long as the hardware is compatible), it takes only a few minutes at most. But I'm not clear what your hardware targets are. Do you really want to be able to run EasyCodeIt on refrigerators and doorbells? (Just discovered our new washing machine is IoT-WiFi enabled with a camera inside, so you can remotely monitor your/my spin cycles. Talk about privacy concerns... ) If you're sticking with x86 for now, I would consider offloading some of the very labour-intensive tasks to some prefab precompiled solutions. Of course even better would be if you could provide a compiler for turning your bytecode into a machine-coded version. Shouldn't be more than a few years work...

Re. boost, I don't think you're being fair.

On 7/21/2021 at 2:53 AM, TheDcoder said:

only a few actually provide useful "end-user features"

Don't think that's true; I think you'd be hard-pressed to find an equally broad and deep single library that is as well-designed, coherent, documented, and most importantly tested to the hilt as boost is. I think you're focussing far too much on the C++ side, not enough on the (OS-independent) design and concepts themselves. And as far as end-user features (several of which are not supported by AutoIt at all, I might add), maybe consider the sections on generic algorithms, bimaps ((NB not bitmaps, but bimaps, i.e.,both members can serve as key),  chrono (time funcs), circular buffers,  OpenCL GPU computing, date/time, dll integration,  endian support , filesysytem, geometry, graphs,  interprocess (shared memory, memory-mapped files, process-shared mutexes, condition variables, containers and allocators; extremely useful I'd say), JSON parser, lambda support (this would be super useful to have anyway), logging, maths, N-dimensional arrays, Python interface, random number generators, sorting algos,  swap, timers, tribooleans, tuples,  uBLAS (although of course my E4A is better), and on and on. Are you really saying these things are not useful end-user features?? I'm not trying to  promote C++ here, I was hoping you would find some of these programming features sufficiently useful to consider incorporating them in your  own fashion. I find it a bit too easy to disparage all of the above (plus everything I haven't mentioned) with:

On 7/21/2021 at 2:53 AM, TheDcoder said:

the benefit isn't that much... and there are better libraries

But it's your baby, of course. I just wanted to ensure you are aware of this huge open-source code base you can crib ideas (and code) from. I for one wouldn't have gotten very far without it. Moving right along...

On 7/21/2021 at 2:53 AM, TheDcoder said:

Objects are okay, but not a full-fledged inheritance system

I think this is very wise. structs are fine, objects (basic structs with de/constructor, not so sure about methods) are fine, but object inheritance is deep dark chasm, inviting poor design, nigh-untraceable bugs, and plain misuse; I fear you will be wailing in programmer-hell for all eternity (and your users too) if you were to pursue this.

Finally, on multi-threading,  some people that mention it annoyingly confuse it with multi-processing (the latter is fine in itself, but completely different), or are thinking of simple non-blocking functions (which I guess is also okay). But writing a solid multi-threading code (esp. for GPU) is very hard, the pitfalls numerous (locks, barriers, wait states, synchronised values anyone?) optimising the memory management is a total nightmare, and debugging race conditions while your OS is happily playing interrupt-bongo is no fun at all. I'd be very careful before implementing more than the most basic support for this (I saw you voted for this yourself).

EDIT: what I'm trying to say is, even on CPU only, multithreading will likely produce code failures for users that they will (unfairly) blame you for, even though you did everything at your end beforehand to prevent this.

Anyway, I wish you fortitude and perseverance.

Edited July 26, 2021 by RTFC

[seadoggie01]

I like RTFC's ideas on objects. I don't need inheritance (even if I like it) and I could deal with objects being a collection of properties... wait this is just a dictionary now, right? Well a dictionary with a constructor at least... hmm

Regarding multi-threading, would borrowing the Promise from JS be easier than a full implementation? I think my main reason for wanting it is to have GUIs display nicely while I'm running background code. I've only really ever wanted/used multi-threading in a handful of applications anyways

Edit: If objects are dictionaries, and functions are first-class citizens, then could objects have methods applied by adding the functions to the dictionary? And inheritance would be simply creating the super dictionary and adding extra stuff to it?

Edited July 25, 2021 by seadoggie01