it looks the same to me that scripts being executed using . script (source script) or /path/script.
but are there any differences between these two methods of executing scripts?
thanks!

well source is like an include in c - take this file and insert it's contents here - , whereas ./ just defines execution of a file in the current directory - run this file. these things are conceptually extremely different but certainly could be used to a similar end.

Just one example of where a character can have different meanings depending on context.

The "." (source) is a command, whereas--in a different context-- ".", "./", "..", and various other forms are ways of designating directories.

"foo" means run the command "foo", which is found in of the directories listed in $PATH. "./foo" means run the "foo" found in the current directory (regardless of what is in $PATH.)

The `.' builtin is equivalent to `source'.
Using either, the commands are executed in the same shell instead of launching the program in a new shell.

For security reasons, the current directory `.' isn't in the PATH variable. So to run a script in the current path, you need to explicitly indicate it's location, either relative to the current path `./' or by using the full pathname.
The command is run in it's own process. After that process exits your program continues.

If you run ./program.sh and that program changes a variable, the change will not be retained when program.sh quits. If you run `source ./program.sh' the statements in program.sh will run in the same shell so they will be retained. Commonly in Linux, a configuration file will contain a number of 'name = value' statements. To set the variables in the config file, simply source it.
Here is an example line from /etc/profile:

You can see the difference by following this example:
(I assume the shell used is bash, if you use <insert you favorite shell here>, you can surely transfer this...)

create a file test-inc.sh with the following contents:
make the file executable by you: chmod u+x test-inc.sh

now execute the following in a terminal (bash# used to denote the prompt):
so what happened?
First, we set a variable TESTVAR in the current shell to "hello world". The variable is not passed to subcommands (you had to use export TESTVAR to do this).
On the next line, we printed the variable (the bash expanded its value and passed the value to the echo command, so technically, echo "hello world" is executed).
After that, we use the dot command to source our script file, that means the bash behaves as if the contents of the file was typed at that place where the dot command is written. So, technically a comment, an empty line and the third line (echo "The test variable is --$TESTVAR--") is executed. Of course, only the echo line is doing something and, as in the typed echo command before, the variable is expanded on the fly, so echo "The test variable is --hello world--" is executed.
In the next command, we execute the command test-inc.sh, that means:

1. open the file
2. interpret the shebang in the first line to find the program that should execute the script (here: /bin/bash)
3. call the given program with the remaining contents as input:
   1. create a new bash shell with default variables etc. (see man bash for more)
   2. execute echo "The test variable is --$TESTVAR--". The variable is again substituted, but this time, the variable TESTVAR is not set (remember the missing export command above!). So now, the executed line will look like this: echo "The test variable is ----"
4. the program (here: the "second" bash) ends and the next prompt for our first shell is shown again.

Hope to make it clear, If you think this is useful, feel free to copy this to a tutorial, but give me the url.