In C, C++, and Perl we use @Include. It’s per file, much like VB.NET’s Imports and C#’s using statements. If you’re a kitchen-sink programmer, loving to hav all of your tools readily available as you type, as opposed to figuring out when you need it and referencing libraries as needed (that’s a lot to keep straight in one’s head…), then you may have a bushel of libraries either for your whole team or personal ones that you include in every project you create. The down side of this is the overhead for your application. It has to carry around the referenced libraries. It has to crunch through them in order to get to a referenced namespace or package. The thought with what is referenced here is, we may be able to have that lazy, at-my-fingertips referenced libraries and still manage our performance before the application goes to production by having the start-up or main handle the circumstance when ”it” isn’t used, don’t reference it at compile time.
There are some of us that have experience in mainframe environments and may be able to consider and provide examples of similar scenarios implemented in that environment. Your feedback on this potential implementation for an improvemen…
Summary:
There’s a link at the bottom that includes a section on using a
statement at start_up that determines whether a library needs to be
included or not in interpretation (in web applications that’s the web
server [IIS, Kestrel, Apache, Tom Cat, Web Sphere, etc.]). Excluding the
libraries in this way can improve performance exponentially. One might
say, if it doesn’t need to be included, why is it included with the
compile? Framework and consistency where cookie-cutter application
solution creation is used even though cookie cutter application solution
design is not.
Thoughts:
As we know, back-in-the-day, resources were severely limited. Today,
with the advent of Internet of Things (IoT defined as high-speed
response time with logic performed at the edges of the network on
routers, switches, and roaming servers closer to a client) and Raspberry
Pi, we’re back to reduced resources on a miniature operating system. In
the case of Raspberry Pi, the whole of its operating system and code can
fit on a standard-sized (much less than a terabyte) thumb drive.
When surveyed, the customers of our custom applications have said that
their three top concerns that were prohibitive in using our services
were:
1) Time-to-go-live (how long it took for us to create an application)
2) Our software life cycle issues relating to limitations of internal
resource sharing and lacking in relatableness when considering other
modern applications available through a third party
3) Performance (generally defined as how fast a page loads and how
quickly a command is processed)
We’re already addressing 1 and 2.
In our environment, we have almost limitless resources. Our SAN drives
are really generous for our servers and provide us with real hard drive
space and virtual RAM to our hearts content. Even though space is not an
issue, where we would want to focus, therefore, is on performance.
If we move our thoughts from limited resources to overall blazing
performance that we all hope our applications will achieve, we get to a
place where we don’t want
1) excessive coding that the compiler and interpreter have to churn
through,
2) unnecessary coding in libraries, and
3) unnecessary libraries
Considering these things, there’s a section on the second page (p. 91)
of the pdf linked below that talks about a statement at the top of main
that checks for a method internally and externally. If it doesn’t find
it, it doesn’t try to interpret an included library that might contain
unnecessary code or a library that, as a whole, is unnecessary. I’m not
exactly sure how we would apply this except at start_up and really
intentionally, but it’s a thought for future performance enhancement
potential where we want the process of creating a solution to be
consistent but where we know the shared libraries may or may not be
wholly necessary, but we want them to be available if needed…
Link:
https://pdfs.semanticscholar.org/cfbc/65b2dec34a8fdf8ca8b909d0c358cb55ccf2.pdf
Summary: How a C program is compiled in terms of stand-alone versus
dependent on other libraries