The general idea to modularize the code is very good, but you might need to review the reasons why you would like to modularize: If the applications you intend to write are quite huge you might want to do this because of 1) compiling speed (if the application is incredibly huge) or 2) just to "keep things in boxes they belong". 3) Other?
If you want to do this because of compiling speed you can use DLL's and/or COM to achieve it, but the learning curve is a bit steep. You need to know several "C-like" things like function-pointers (see the prototype keyword in pb) and/or understand COM-interfaces etc.
If you just want to "keep things in boxes they belong" you could either (easy solution:) develop a standard consisting of naming-conventions and rules for when and how you declare (and name) global variables and how you split code into several source-files. This might work good for small to medium systems written in pb.
(harder solution:) However if you are writing really huge serious systems, I'd really encourage you to take a look at OOP (Object Oriented Programming). Once again you got quite a steep learning curve to become good at OOP but once you grock it you'll be able to write entire enterprise applications with just a handful of globals (if any). OOP is all about boxing all code (and data) into nice named boxes (called classes) that describe certain entities or flows. Since pb is a procedural language you got no OOP support in it. (some people might say you can do OOP in pb, and I agree you can but there is no native support for it as in a real OOP language, that's just a fact.)
If you are interested in OOP but still want fairly easy programming (as in basic-like), I'd recommend you take a look at Microsoft Visual Basic for .NET (express editions are even free). The .NET part also provides a very elegant solution to the compiling times, as you only need to re-compile the source-files you've been editing, all the others are ready since the last compilation and can be executed as they are. (actually I'd really recommend Java/C# but since you said you disliked C you'll not like them very much, I deem.)
Note1: I like pb a lot and advocate it for all the tasks that are perfect for it - generally quite small to medium applications that you want to write fast and easy. I don't however recommend pb for writing huge applications, because of the lack of OOP and serious namespace-compartmentalization support.
Note2: With "small to medium applications" i mean < 500k lines. With "huge applications" i mean 500k ~ 1000k lines. With "incredibly huge applications" i mean 1000k lines (+). I've been lead developer in "huge applications" and I've participated in developing "incredibly huge applications" and I cannot overemphasize the importance to keep code clean and "boxed" if you want to keep code manageable and extendable at such sizes.
Note3: This are my opinions. i.e. feel free to disagree with me, but don't start flame wars over this
