The problem of function-based reuse

Question

I read the quoted text as follows from a book authored by a Microsoft developer. I googled and found a lots of quotes of it, but did not find any explanation.
============
With languages like C, the basic unit of reuse is the function. The problem with function-based reuse is that the function is coupled to the data it manipulates. and if the data is global, a change to benefit one function in one reuse context damages another function used somewhere else.
============
C uses libraries widely,which is of function-based reuse. Can anybody kindly give me a scenario when this problem happens?
Java is typically object-based reuse, and I admit that my question is not a Java one. But I feel it would help to understand more about the concept or benefits of design of Java language. So, thank you to allow me to post this question here,
Edited by: 799160 on Sep 30, 2010 12:38 PM
Edited by: 799160 on Sep 30, 2010 12:57 PM

Answer 1

This is what I got out of reading the quote you posted:
I suppose something like the following could happen:
You (being a general person) have been given a class to modify. You look at the code for the first time and it has a bunch of methods and some class variables in it. Some of the methods use the class variables. How can you be sure if you change the functionality to change a class variable in one method won't affect the other methods when they are used? This problem can be solved by learning what everything does, how it interacts and the correct way to use it. But then again, if you don't think about it and just make changes...Oops!
Perhaps another abstract example would make sense:
Imagine a calculator that could be used by 2 people at the same time? I bet it'd come up with some funny answers :)
I wrote up a short example of this, hopefully it makes some sense:
public class SuperBigProgram
     private int globalVar;
     public static void main ( String[] args )
          new SuperBigProgram();
     public SuperBigProgram()
          System.out.println("I'm a super big program.");
          globalVar = 0;
          //Let's pretend these series of events occur during the program:
          doItHighChanceActivity(); //1
          doItHighChanceActivity(); //2
          doItHighChanceActivity(); //3
          //Whoops super rare event occured!
          doesNotHappenALot();
          doItHighChanceActivity(); //4????    but is really 5.
      * This happens A LOT!
     private void doItHighChanceActivity ()
          superUtilityMethod();
          System.out.println("globalVar: " + globalVar);
      * This utility method does some awesome utility stuff for our Super Big Program.
      * This changes some global data.
     private void superUtilityMethod()
          globalVar++;
      * This does not happen a lot, if at all.
     private void doesNotHappenALot()
          //Hey I don't happen a lot but I'm reusing this really cool utility method that contains global data...
          //Code reuse for the win!
          superUtilityMethod();
}Here is the output:
I'm a super big program.
globalVar: 1
globalVar: 2
globalVar: 3
globalVar: 5
Edited by: kilosi on Sep 30, 2010 1:22 PM