Thread: esbo's data sharing example

Originally Posted by robwhit

Why are you yelling at me? Well... hmm. Actually, no. That seems really odd. You would think that they would have proof somewhere.Thanks esbo!

I couldn't find any with no big words though...

Here are some that are some of the reasons given to me:

http://en.wikipedia.org/wiki/Global_variable
http://www.infis.univ.trieste.it/C/N...tion3_6_3.htmlhmm... maybe. I don't think I've thought about it quite that way before. I'm not really that good at math.

And come to think of it, I'm always having problems with extensibility in my programs. If it's not one thing, it's another. If it's not that, it's code in spot C. There's so many things that manage to go wrong. Isn't there an easier way?

I think you may be on to something.

http://en.wikipedia.org/wiki/Global_variable
"The use of global variables makes software harder to read and understand. Since any code anywhere in the program can change the value of the variable at any time, understanding the use of the variable may entail understanding a large portion of the program"

OK lets take this 'gem'.

It is perfectly easy to see where the variable is used in the program, you just do a search on it. The beauty of global variables is that they can be modified anywhere, it is not a failing it is a strength. Only takes a few clicks of the mouse to see where the variable is used.


Futhermore to say that local variables are easier to understand is wrong, local variables
can change other variables in the program via return values. Not only that it could change
any variable of the same type throughout the program.
Now if you want to find out how that local variable affects the rest of the program you have to look at all the calls to that function and various different variables affected by that call,
so now you have to do multiple searches on different variable names!! Futhermore those variables will also be passed
into other functions affecting other variables. You effectively could have a chain reaction.
A nuclear explosion of complexity taking place in the program!!!

Most of the 'bad practice' I see is people trying to make global variables local!!!!
You see some horrendous things, great wadges of data beinig passed around, the names constantly changing, making it almost impossible to keep track of what is going on.

I have seen stuff being passed down through 4 or 5 levels of functions, the name changing each time. In making their program 'less complex' and easy to follow they create the biggest labyrinth of complexity ever seen.

If you want to make you program imcomprehensible avoid using global variables.
Mind you when you come back to it in a few months you won't be able to undestand it either

Originally Posted by anon

Do you consider statistics as valid math?

How many lines of code would you have to change to introduce another array and save it to a different file?

How many lines of code would you generally have to change to reuse parts of the code of a fairly large progject in another project if all or most of your functions depend on each other via global variables and everything is hard-coded for a particular scenario?

How many bugs would changes or attempts at reuse introduce if all your functions work by having curious side-effects? Etc.

It would be trivial to introduce another array and save it to a different file.
I could do it in less than a minute, so it's not something I would lose sleep over.

Originally Posted by anon

--------
Globals generally seem easier to novice programmers, as well as most other bad practices (spaghetti code, magic values), because they let one write small programs without much thought to structure. A thought occurs and you write the code.
With experience however, you should be able to recognize solutions concerning better structure etc more easily. (Unless, of course, you are satisfied with what you know and decide you can stop developing.) Although I am a hobbyist, it does not require me any effort to determine what would reasonably be the arguments and return value of a function that saves an array to a file, and I'm pretty sure most programmers feel the same.
So, you use globals effortlessly and can't reuse functions in different projects or even in the same program with different data (at least not without a tedious copy'n'paste job). I wouldn't use global data, would write the same functionality just as effortlessly with parameters and return value, and be able to reuse the code (within reason).

Both functions are only used once so it is pointless making them multipurpose.
I may never use the function again, I cross bridges when i get to them not before.

What happens is a novice programmer discovers how to use local variables and then
use then excessively because he now an 'experienced programmer'.
Chance are you will never use the function again so you are just creating work for yourself
and making your program unnecessarilly complicated. Every variable you pass is an oppertunity to make an error. get the types wrong and you will have some nice exotic bugs
which could lay dormant for some time.

Originally Posted by anon

As an example of your bad structure, you are mixing completely different jobs in your functions. datasave() cannot possibly know whether it is called in a context where exiting is a valid error response.

Yes it can, it is only called in one context.

Originally Posted by anon

Or the straight function, that instead of returning a result prints the result. That is, the function makes an unjustified decision what it should be used for.

It prints the result so I know that the code is working.
If I returned a value I could make a mistake, it is an opertunity to make an error.
The code might actually work but the error could be in the extra complexity of returning
a value.

Originally Posted by anon

The thing with this design and globals is that small changes are not localized to a single or a few places but may be required all over the place.

Any change can affect any part of a program, it does not matter whether the variables
are global or local it depends on the overall design of the program, not the scope of
the variable.
The scope only affects where the variable can be changed, it does not restrict how those
changes might affect the overall program.

I have a 1000+ line program it has 17 local variables, about 80 global variables, and 6
functions, one of which requires 2 arguements. None of the functions return any values.
It works fine and is easy to follow.
I don't find any problem whatsoever with the global variables. Infact it is the function which
is passed values which is hardest to follow

Originally Posted by robwhit

Ok, interesting point of view. Before I respond to your post, I have a few questions:

How do you make re-entrant functions?

How do you avoid name conflicts?

"How do you make re-entrant functions?"

Easy, I don't!!!!!!!!!! (shock horror!!!!!!!!)

"How do you avoid name conflicts?"

That's a bit more tricky, after hours of sleepless nights I decide to give the variables different names, a stroke of genius don't you think?

I tried using the same name for every variable but I eventually gave up on it as a 'lost cause'.