Test 042: Developing with IBM Enterprise PL/I

Section 1 - Advanced Language / Environment Topics (30%)

1. Declare and initialize an aggregate correctly (e.g., array of structures or structure of arrays)
2. Write code that uses advanced builtin functions. Representative examples:
1. Arithmetic functions (MAX, MIN, MOD)
2. Array-handling functions (ANY, DIMENSION, LBOUND, HBOUND)
3. Buffer-management functions (COMPARE, MEMSEARCH, XMLCHAR)
4. Condition-handling functions (ONCHAR, ONCODE, ONKEY, ONWCHAR, ONWSOURCE)
5. Date/Time functions (DATE, DATETIME, VALIDDATE)
6. Input/Output functions (COUNT, ENDFILE, FILEOPEN, SAMEKEY)
7. Miscellaneous functions (HEX, PLIRETV, STRING, SOURCEFILE, VALID)
8. Precision-handling functions (BINARY, DECIMAL, UNSIGNED)
9. Psedovariables (ONSOURCE, STRING, SUBSTR)
10. Storage control functions (ADDR, CHECKSTG, POINTER, POINTERDIFF, POINTERVALUE)
11. String-handling functions (BIT, LENGTH, SUBSTR, TRANSLATE, VERIFY, WIDECHAR)
12. Subroutines (PLICANC, PLICKPT, PLIDUMP, PLIFILL, PLIMOVE, PLIOVER, PLIREST)


3. Evaluate PL/I statements that contain data conversions to determine proper use of direct assignment and GET/PUT STRING statements
4. Determine whether programs that incorporate complex flow control work as specified
5. Recognize whether CONTROLLED/BASED variables are being handled correctly in a program
6. Determine the lifespan and scope of the variable (e.g., in functions, user controlled, ALLOCATE/FREE)
7. Describe the difference between usage of heap and stack
8. Describe how implementing recursion in a program impacts it
9. Describe the use of dummy variables
10. Determine whether appropriate condition checking has been applied in a program
11. Interpret the output of the linkage editor (e.g. unresolved external references)
12. Identify some subsystem dependent specifics (e.g., reentrancy, PCB pointer, CICS-LINK)
13. Describe the usage of preprocessor macros
14. Maintain programs that use AREA and OFFSET
15. Maintain programs that are implemented using list processing

Section 2 - Data Access (10%)

1. Describe the correct use of file system access (e.g., sequential file, indexed sequential file, fixed vs. variable record formats, KEY, KEYTO and KEYFROM)
2. Describe the basic characteristics of the relational/hierarchical data model
3. Describe the use of the LUW (logical unit of work)
4. Determine logic for commit and rollback
5. Determine strategies for avoiding deadlocks and timeouts (e.g., mutual exclusion, hold and wait, no preemption, cycle dependencies)

Section 3 - Technical Leadership (13%)

1. Mediate design and code review meetings
2. Provide feedback to programmers when code is incorrect / inefficient
3. Communicate appropriate technical details to stakeholders (e.g. project manager, line manager, requirements engineers, architects)
4. Apply appropriate review technique for a given source code review (e.g., walkthrough, formal review, code coverage, utilization of coding standards)
5. Determine optimum resource allocation to meet project objectives
6. Determine whether the program has good documentation (i.e., inside the program and about the program)
7. Maintain the balance among quality, functionality, costs and deadlines

Section 4 - Application Design (13%)

1. Given a business case, design a new application that meets the requirements using appropriate design and development models
2. Reengineer an application to leverage advances in PL/I technology
3. Restructure an application to increase maintainability
4. Describe how to fulfill non-functional requirements (e.g., maintainability, stability, security) in an application
5. Translate given business logic into the appropriate technical design (e.g., use cases)
6. Practice defensive programming (e.g., risk analysis) to ensure stability of the program
7. Describe commonly known and used principles and techniques of software engineering
8. Describe typical program logic for Batch vs online application programs

Section 5 - Performance and Optimization (14%)

1. Analyze performance and resource utilization
2. Rewrite code to remove bottlenecks
3. Analyze a program to determine whether parallelization can be applied
4. Describe the impact of multithreading (e.g., risk of race conditions, deadlocks)
5. Identify techniques that require too much time or memory to execute
6. Create a structure and an array of structures with proper alignment and describe the implications of padding
7. Describe the usage of performance analyzer tools
8. Identify compiler and run-time options with relevance for performance and optimization

Section 6 - Interface (Other Languages or Programs on the Same or Different Platforms) (9%)

1. Recognize issues associated with PL/I inter-language communication
2. Describe the difference between little endian and big endian
3. Understand the differences between character representations (e.g., UTF-16, ASCII, EBCDIC)
4. Describe the trade-offs between different interface designs (e.g., number of arguments vs. structures vs. use of pointers)
5. Describe the proper usage of synchronous and asynchronous interfaces (e.g., asynchronous via messaging)

Section 7 - Problem Determination (11%)

1. Analyze dumps excluding system dumps (e.g., find last executed statement, identify contents of variables)
2. Read code and describe the intended result
3. Describe ways to make debugging easier (e.g., use of eyecatchers)
4. Test the application to determine whether it meets the specifications
5. Describe advantages and disadvantages of using debuggers (including environment considerations - e.g. online vs. batch, test vs. production)
6. Describe different debugging techniques (e.g., application traces, debugging options – SUBSCRIPTRANGE)
7. Identify compiler messages and compiler options which provide information about code quality