Question: I was thinking more about the programming language i am designing. and i was wondering, what are ways i could minimize its compile time?

Answer: 
In most languages (pretty well everything other than C++), compiling individual compilation units is quite fast. 

Binding/linking is often what's slow - the linker has to reference the whole program rather than just a single unit. 

C++ suffers as - unless you use the pImpl idiom - it requires the implementation details of every object and all inline functions to compile client code. 

Java (source to bytecode) suffers because the grammar doesn't differentiate objects and classes - you have to load the Foo class to see if Foo.Bar.Baz is the Baz field of object referenced by the Bar static field of the Foo class, or a static field of the Foo.Bar class. You can make the change in the source of the Foo class between the two, and not change the source of the client code, but still have to recompile the client code, as the bytecode differentiates between the two forms even though the syntax doesn't. AFAIK Python bytecode doesn't differentiate between the two - modules are true members of their parents.

C++ and C suffer if you include more headers than are required, as the preprocessor has to process each header many times, and the compiler compile them. Minimizing header size and complexity helps, suggesting better modularity would improve compilation time. It's not always possible to cache header compilation, as what definitions are present when the header is preprocessed can alter its semantics, and even syntax. 

C suffers if you use the preprocessor a lot, but the actual compilation is fast; much of C code uses `typedef struct _X* X_ptr` to hide implementation better than C++ does - a C header can easily consist of typedefs and function declarations, giving better encapsulation.

So I'd suggest making your language hide implementation details from client code, and if you are an OO language with both instance members and namespaces, make the syntax for accessing the two unambiguous. Allow true modules, so client code only has to be aware of the interface rather than implementation details. Don't allow preprocessor macros or other variation mechanism to alter the semantics of referenced modules.
In the old days you could get dramatic speedups by setting up a RAM drive and compiling there. Don't know if this still holds true, though.