Question: Is it good practice to declare variables to be used across a program in a Module then populate them in one form and use what you have populated to these variables in another form?

I plan on closing the population form after the data has been populated to the variables so I see this as the only method that would work. 

Am I right in thinking that passing parameters from the population form to the display form wouldn't be appropriate in this situation, if even possible?

Answer: 
...on the other hand, there is nothing whatsoever that a module can do that cannot also be done with a class. For a UserLogin example, leaving it in a module does not make it easier to access:

```
 Friend User As New UserLogin

 ' elsewhere:

 theName = User.Name
 thePass = User.Password

```

Meanwhile, a class can manage the info:

```
 Class UserLogIn

   Sub LoadData

   Sub SaveData

   Function GetLogIn      ' display form, validate ID etc

   Function ChangePassword

 Private gfrm as New LogInForm
 Friend Sub Display()

    With gfrm
        .IgnoreChange = True
        .cboName.Text = Name
        .cboName.Tag = Name
        .txtURL.Text = Location
        .txtUser.Text = UserName
        .txtPW.Text = DES.DecryptData(_pass)
        .txtHint.Text = PassHint
        .txtNote.Text = Comment
        .IgnoreChange = False
        .DataChanged = False

        .Show
    End With

   ' store PW hashed or encrypted until needed...
   ' No one can change the PW except this class
   Friend Property PassWord() As String
       Get
           Return DES.DecryptData(_pass)
       End Get
       Private Set(ByVal value As String)          ' private setter
          _pass = DES.EncryptData(value)
       End Set
   End Property

  End Sub

```

Modules are simply not any easier to use, maintain, store or access data. They are considerably less powerful.
No, and yes.
Define a class or perhaps more than one to hold the data, pass that about. If by module you mean one of those .bas things with a bunch of primitive types in it, then that would be considered bad practice unless there was no practical alternative.

It's not expected to change was what you said, but if you use a bunch of global variables, you can expect them to be changed and it to be very hard to track down, when and why.

They'll be changed because it was convenient, or in error and you end up with an intermittent major PIA bug. A class with getters and setters on it's properties, and it can manage changes to it's members, so if some "fool" of programmer makes a slight mistake..
The other consideration is unit testing which would be a nightmare if you go the way you are thinking.