How can Strong Type programming languages be more productive?

Consider this example on an iOS App Automation project using Appium:

In the line of code below, we have a type AttachmentType:

AddAttachmentiOS(AttachmentType attachmentType, PhotoType type) {

Working with Ruby and JavaScript, in this case, to know exactly what data to pass, I need to jog back to different methods. This is particularly relevant in larger projects that I haven't work before or in a long time.

Another way is, to run the program itself to know, which can take time especially if this method has to be isolated.

If you have unit tests though, you can know the value just by referring to one of the tests. Another huge advantage of using them is that they are self documenting.

Good but here in this context with the codes above, I can simply go to or peek the declaration and know exactly which type it is - here as an enum and the values that can be passed. Additionally, if I'm using Java or C#, the IDE itself will autocomplete the information once I start typing.

On Test Automation projects such as End To End (E2E) ones, you don't have Unit Tests. Therefore it's a good idea to consider a strong type language especially if there'll be plenty of features to automate and intrinsic logic flows.

The CONS

At the start of a project, it might be initially time consuming to define all types, especially if you don't know all the process flows. You can use some free good tools out there though such as QuickType.

When there is later more things to change, you need to also keep track and update the different types and their underlying values.

If you want to build a quick proof of concept, using a dynamic or scripting language such as Python, Ruby or JavaScript might actually be initially much faster.