Does Maple support nested modules, to better organize library code?

Look at the following Maple code and output, from Maple 2020. Can you explain the results? I know returning an uninitiated local variable is bad practice, but I cannot make sense of what happens when I do it anyway (just to understand the internals of the Maple language). Should I simply consider the results as undefined behavior?

> f:=proc()                                                                    
>     local x;                                                                 
>     return x;                                                                
> end proc:                                     

> a1 := f() + f();                                                             
                                   a1 := 2 x

> a2 := f() - f();                                                             
                                  a2 := x - x

> a1 + a2;                                                                       
                                  2 x + x - x

> a3 := f() + f() + f();                                                       
                                   a3 := 3 x

> a4 := f() + f() + f() - f();                                                 
                                 a4 := 3 x - x

In Maple, series(f(x), x=x0, order) will produce an expansion where the number of terms is specified by "order". But is it possible to specify the maximum power of (x-x0) that is needed, regardless of the starting order? This is especially a problem if the starting order is negative. To make it worse, in practice the number of terms produced by Maple may not be equal to "order", when nontrivial algebraic cancellations change the exact starting order. Experimenting with different choices of "order" case by case is not practical, when automation is needed for many runs involving different functions. MultiSeries:-series doesn't solve my problem, either.

P.S. MultiSeries:-series is more reliable than series in giving the number of terms specified by the user, but it still breaks down sometimes for complicated problems, for example producing much fewer terms than specified. My main concern, i.e. being able to specifiy an absolute maximium power, is also not addressed by switching from series to MultiSeries:-series.

The expressions f(1), f(1,2,3), or f with any number of arguments, all match the type specfunc(f), while the expression f(g(1), 2 ,3) matches the type f(g(anything), anything, anything). However, is there a type which is matched by expressions like f(g(1), 2, 3 ...), with an arbitrary number of arguments after g(something)?

I'm using Maple 2020 in Linux (Ubuntu 20.04). The screen resolution is 2560×1440, so I have system-wide setting of 200% scaling for all apps, but unfortunately Maple doesn't adopt the system setting and UI elements are tiny. To make it tolerable, in "Tools - Options - Interface", I've set Default Zoom to be 200% and checked the box "Large toolbar icons". However, menus (File, Edit, View etc.) and dialog boxes are still tiny.

Am I right that the Maple GUI is written in Java / Swing? I've heard that Java 9 has better support for high dpi scaling. Does the default Maple installation use Java 9?