I'm now starting on my principal Julia project, which is a finite element mesh generator. This is a large application divided into many smaller functions. I face a commonplace programming style issue in this setting, which is as follows. There are many large data items common to many of the functions (tables about geometric entities, subdivisions and so on). In order for the smaller functions to have access to these data items, there are at least two solutions available in Julia (and in C and Fortran for that matter):
(1) Pass them in around as function arguments (2) Declare them as module-level global variables. The disadvantage of passing them as arguments is that function arguments lists become depressingly long (and hence so do invocations) so code readability suffers. The disadvantage of declaring them as globals is that it is hard to tell which function is accessing and possibly changing which variable. Another disadvantage is that the 'main' routine has to explicitly reinitialize them when it starts and could create hard-to-catch bugs if it fails to reinitialize one. There is also a possible performance hit in Julia for doing this. (Could someone clarify that?) Furthermore, if I ever try parallelizing the code, this may influence whether (1) or (2) is better. (Could anyone comment on that?) I'm wondering which approach is preferable in Julia. Perhaps there is a third approach that beats both of these? Thanks, Steve Vavasis
