English (United Kingdom)

https://curated-unify.zendy.io/wp-json/zendy-region/v1/featured_content/oa?rat=en

https://curated-unify.zendy.io/wp-json/zendy-region/v1/highlighted_journal/

Global: Zendy Plus annual

Presents the access of premium content as premium feature

Premium Content

Presents the keyphrase highlighting as premium feature

Keyphrase Highlighting

Presents the summarisation as premium feature

Summarisation

Insights

Presents the pdf analysis as premium feature

PDF Analysis

Presents the zaia usage as premium feature

ZAIA

Global: Zendy Tools annual

Global: Zendy Free Plan

Global: Zendy Tools monthly

Global: Zendy Plus monthly

by the assembler in constructing code from a macro must be done by the subroutine at run time. However, in a teaching situation where total assembly time is expected to be greater than total run time, this is not a disadvantage. Furthermore, information available to the assembler can be processed by the calling macro and left for the subroutine as a part of the linkage to the sub-routine. The other time consideration involves loading the assembled program into main store. Since loading patterns vary from system to system and even from program to program within a given system, the programmer should evaluate the advantages of macros alone versus subroutines linked by macros in the context of his local environment, In conclusion, Mr. Kent leaves the impression that the use of macros is a panacea for all the programmer's problems. Unfortunately this is not the case, and a more flexible approach must be used. Macro definitions provide a vehicle for the programmer to control code selection and generation during assembly. The quality of the code produced is to a large extent determined by the quality of the design of the macro definitions. Certainly one of the many design decisions the macro designer must make is whether to generate in-line code, or to generate linkages to an out-of-line subroutine. There is no sense in which macros and subrou-tines exclude each other. The programmer is in no way faced with a choice of using macros or using subroutines. Precisely as Dr. Christoph indicates (and as Figure 11 in my paper illustrates), macros can be used very effectively to generate subrou-tine linkages. The use of a macro here complements the use of a subroutine very nicely. By simply altering the macro definition, the programmer can very conveniently (a) restructure his linkage conventions whenever he wants, and (b) decide to generate in-line code instead of sub-routine linkages (or vice versa). In fact, macros can often be used to generate subroutine linkages and to insert a single copy of the subroutine into the program. I certainly didn't mean to suggest that macros are a panacea of any sort. They are simply a very useful tool that must be used with a reasonable comprehension of their role and function.-W.K.

Letter to the Editor: ``Assembler-Language Macroprogramming: A Tutorial Oriented Toward the IBM 360''