ABAP Performance standards good piece
ABAP Performance Standards
Following are the performance standards need to be following in writing ABAP programs:
<b>1. Unused/Dead code</b>
Avoid leaving unused code in the program. Either comment out or delete the unused situation. Use program --> check --> extended program to check for the variables, which are not used statically.
<b>2. Subroutine Usage</b>
For good modularization, the decision of whether or not to execute a subroutine should be made before the subroutine is called. For example:
This is better:
IF f1 NE 0.
PERFORM sub1.
ENDIF.
FORM sub1.
ENDFORM.
Than this:
PERFORM sub1.
FORM sub1.
IF f1 NE 0.
ENDIF.
ENDFORM.
<b>3. Usage of IF statements</b>
When coding IF tests, nest the testing conditions so that the outer conditions are those which are most likely to fail. For logical expressions with AND , place the mostly likely false first and for the OR, place the mostly likely true first.
Example - nested IF's:
IF (least likely to be true).
IF (less likely to be true).
IF (most likely to be true).
ENDIF.
ENDIF.
ENDIF.
Example - IF...ELSEIF...ENDIF :
IF (most likely to be true).
ELSEIF (less likely to be true).
ELSEIF (least likely to be true).
ENDIF.
Example - AND:
IF (least likely to be true) AND
(most likely to be true).
ENDIF.
Example - OR:
IF (most likely to be true) OR
(least likely to be true).
<b>4. CASE vs. nested Ifs</b>
When testing fields "equal to" something, one can use either the nested IF or the CASE statement. The CASE is better for two reasons. It is easier to read and after about five nested IFs the performance of the CASE is more efficient.
<b>5. MOVE statements</b>
When records a and b have the exact same structure, it is more efficient to MOVE a TO b than to MOVE-CORRESPONDING a TO b.
MOVE BSEG TO *BSEG.
is better than
MOVE-CORRESPONDING BSEG TO *BSEG.
<b>6. SELECT and SELECT SINGLE</b>
When using the SELECT statement, study the key and always provide as much of the left-most part of the key as possible. If the entire key can be qualified, code a SELECT SINGLE not just a SELECT. If you are only interested in the first row or there is only one row to be returned, using SELECT SINGLE can increase performance by up to three times.
<b>7. Small internal tables vs. complete internal tables</b>
In general it is better to minimize the number of fields declared in an internal table. While it may be convenient to declare an internal table using the LIKE command, in most cases, programs will not use all fields in the SAP standard table.
For example:
Instead of this:
data: t_mara like mara occurs 0 with header line.
Use this:
data: begin of t_mara occurs 0,
matnr like mara-matnr,
end of t_mara.
<b>8. Row-level processing and SELECT SINGLE</b>
Similar to the processing of a SELECT-ENDSELECT loop, when calling multiple SELECT-SINGLE commands on a non-buffered table (check Data Dictionary -> Technical Info), you should do the following to improve performance:
o Use the SELECT into <itab> to buffer the necessary rows in an internal table, then
o sort the rows by the key fields, then
o use a READ TABLE WITH KEY ... BINARY SEARCH in place of the SELECT SINGLE command. Note that this only make sense when the table you are buffering is not too large (this decision must be made on a case by case basis).
<b>9. READing single records of internal tables</b>
When reading a single record in an internal table, the READ TABLE WITH KEY is not a direct READ. This means that if the data is not sorted according to the key, the system must sequentially read the table. Therefore, you should:
o SORT the table
o use READ TABLE WITH KEY BINARY SEARCH for better performance.
<b>10. SORTing internal tables</b>
When SORTing internal tables, specify the fields to SORTed.
SORT ITAB BY FLD1 FLD2.
is more efficient than
SORT ITAB.
<b>11. Number of entries in an internal table</b>
To find out how many entries are in an internal table use DESCRIBE.
DESCRIBE TABLE ITAB LINES CNTLNS.
is more efficient than
LOOP AT ITAB.
CNTLNS = CNTLNS + 1.
ENDLOOP.
<b>12. Performance diagnosis</b>
To diagnose performance problems, it is recommended to use the SAP transaction SE30, ABAP/4 Runtime Analysis. The utility allows statistical analysis of transactions and programs.
<b>13. Nested SELECTs versus table views</b>
Since releASE 4.0, OPEN SQL allows both inner and outer table joins. A nested SELECT loop may be used to accomplish the same concept. However, the performance of nested SELECT loops is very poor in comparison to a join. Hence, to improve performance by a factor of 25x and reduce network load, you should either create a view in the data dictionary then use this view to select data, or code the select using a join.
<b>14. If nested SELECTs must be used</b>
As mentioned previously, performance can be dramatically improved by using views instead of nested SELECTs, however, if this is not possible, then the following example of using an internal table in a nested SELECT can also improve performance by a factor of 5x:
Use this:
form select_good.
data: t_vbak like vbak occurs 0 with header line.
data: t_vbap like vbap occurs 0 with header line.
select * from vbak into table t_vbak up to 200 rows.
select * from vbap
for all entries in t_vbak
where vbeln = t_vbak-vbeln.
endselect.
endform.
Instead of this:
form select_bad.
select * from vbak up to 200 rows.
select * from vbap where vbeln = vbak-vbeln.
endselect.
endselect.
endform.
Although using "SELECT...FOR ALL ENTRIES IN..." is generally very fast, you should be aware of the three pitfalls of using it:
Firstly, SAP automatically removes any duplicates from the rest of the retrieved records. Therefore, if you wish to ensure that no qualifying records are discarded, the field list of the inner SELECT must be designed to ensure the retrieved records will contain no duplicates (normally, this would mean including in the list of retrieved fields all of those fields that comprise that table's primary key).
Secondly, if you were able to code "SELECT ... FROM <database table> FOR ALL ENTRIES IN TABLE <itab>" and the internal table <itab> is empty, then all rows from <database table> will be retrieved.
Thirdly, if the internal table supplying the selection criteria (i.e. internal table <itab> in the example "...FOR ALL ENTRIES IN TABLE <itab> ") contains a large number of entries, performance degradation may occur.
<b>15. SELECT * versus SELECTing individual fields</b>
In general, use a SELECT statement specifying a list of fields instead of a SELECT * to reduce network traffic and improve performance. For tables with only a few fields the improvements may be minor, but many SAP tables contain more than 50 fields when the program needs only a few. In the latter case, the performace gains can be substantial. For example:
Use:
select vbeln auart vbtyp from table vbak
into (vbak-vbeln, vbak-auart, vbak-vbtyp)
where ...
Instead of using:
select * from vbak where ...
<b>16. Avoid unnecessary statements</b>
There are a few cases where one command is better than two. For example:
Use:
append <tab_wa> to <tab>.
Instead of:
<tab> = <tab_wa>.
append <tab> (modify <tab>).
And also, use:
if not <tab>[] is initial.
Instead of:
describe table <tab> lines <line_counter>.
if <line_counter> > 0.
<b>17. Copying or appending internal tables</b>
Use this:
<tab2>[] = <tab1>[]. (if <tab2> is empty)
Instead of this:
loop at <tab1>.
append <tab1> to <tab2>.
endloop.
However, if <tab2> is not empty and should not be overwritten, then use:
append lines of <tab1> [from index1] [to index2] to <tab2>.
Hope this will help you all in writing the ABAP program.<b></b>
ABAP Performance Standards
Following are the performance standards need to be following in writing ABAP programs:
<b>1. Unused/Dead code</b>
Avoid leaving unused code in the program. Either comment out or delete the unused situation. Use program --> check --> extended program to check for the variables, which are not used statically.
<b>2. Subroutine Usage</b>
For good modularization, the decision of whether or not to execute a subroutine should be made before the subroutine is called. For example:
This is better:
IF f1 NE 0.
PERFORM sub1.
ENDIF.
FORM sub1.
ENDFORM.
Than this:
PERFORM sub1.
FORM sub1.
IF f1 NE 0.
ENDIF.
ENDFORM.
<b>3. Usage of IF statements</b>
When coding IF tests, nest the testing conditions so that the outer conditions are those which are most likely to fail. For logical expressions with AND , place the mostly likely false first and for the OR, place the mostly likely true first.
Example - nested IF's:
IF (least likely to be true).
IF (less likely to be true).
IF (most likely to be true).
ENDIF.
ENDIF.
ENDIF.
Example - IF...ELSEIF...ENDIF :
IF (most likely to be true).
ELSEIF (less likely to be true).
ELSEIF (least likely to be true).
ENDIF.
Example - AND:
IF (least likely to be true) AND
(most likely to be true).
ENDIF.
Example - OR:
IF (most likely to be true) OR
(least likely to be true).
<b>4. CASE vs. nested Ifs</b>
When testing fields "equal to" something, one can use either the nested IF or the CASE statement. The CASE is better for two reasons. It is easier to read and after about five nested IFs the performance of the CASE is more efficient.
<b>5. MOVE statements</b>
When records a and b have the exact same structure, it is more efficient to MOVE a TO b than to MOVE-CORRESPONDING a TO b.
MOVE BSEG TO *BSEG.
is better than
MOVE-CORRESPONDING BSEG TO *BSEG.
<b>6. SELECT and SELECT SINGLE</b>
When using the SELECT statement, study the key and always provide as much of the left-most part of the key as possible. If the entire key can be qualified, code a SELECT SINGLE not just a SELECT. If you are only interested in the first row or there is only one row to be returned, using SELECT SINGLE can increase performance by up to three times.
<b>7. Small internal tables vs. complete internal tables</b>
In general it is better to minimize the number of fields declared in an internal table. While it may be convenient to declare an internal table using the LIKE command, in most cases, programs will not use all fields in the SAP standard table.
For example:
Instead of this:
data: t_mara like mara occurs 0 with header line.
Use this:
data: begin of t_mara occurs 0,
matnr like mara-matnr,
end of t_mara.
<b>8. Row-level processing and SELECT SINGLE</b>
Similar to the processing of a SELECT-ENDSELECT loop, when calling multiple SELECT-SINGLE commands on a non-buffered table (check Data Dictionary -> Technical Info), you should do the following to improve performance:
o Use the SELECT into <itab> to buffer the necessary rows in an internal table, then
o sort the rows by the key fields, then
o use a READ TABLE WITH KEY ... BINARY SEARCH in place of the SELECT SINGLE command. Note that this only make sense when the table you are buffering is not too large (this decision must be made on a case by case basis).
<b>9. READing single records of internal tables</b>
When reading a single record in an internal table, the READ TABLE WITH KEY is not a direct READ. This means that if the data is not sorted according to the key, the system must sequentially read the table. Therefore, you should:
o SORT the table
o use READ TABLE WITH KEY BINARY SEARCH for better performance.
<b>10. SORTing internal tables</b>
When SORTing internal tables, specify the fields to SORTed.
SORT ITAB BY FLD1 FLD2.
is more efficient than
SORT ITAB.
<b>11. Number of entries in an internal table</b>
To find out how many entries are in an internal table use DESCRIBE.
DESCRIBE TABLE ITAB LINES CNTLNS.
is more efficient than
LOOP AT ITAB.
CNTLNS = CNTLNS + 1.
ENDLOOP.
<b>12. Performance diagnosis</b>
To diagnose performance problems, it is recommended to use the SAP transaction SE30, ABAP/4 Runtime Analysis. The utility allows statistical analysis of transactions and programs.
<b>13. Nested SELECTs versus table views</b>
Since releASE 4.0, OPEN SQL allows both inner and outer table joins. A nested SELECT loop may be used to accomplish the same concept. However, the performance of nested SELECT loops is very poor in comparison to a join. Hence, to improve performance by a factor of 25x and reduce network load, you should either create a view in the data dictionary then use this view to select data, or code the select using a join.
<b>14. If nested SELECTs must be used</b>
As mentioned previously, performance can be dramatically improved by using views instead of nested SELECTs, however, if this is not possible, then the following example of using an internal table in a nested SELECT can also improve performance by a factor of 5x:
Use this:
form select_good.
data: t_vbak like vbak occurs 0 with header line.
data: t_vbap like vbap occurs 0 with header line.
select * from vbak into table t_vbak up to 200 rows.
select * from vbap
for all entries in t_vbak
where vbeln = t_vbak-vbeln.
endselect.
endform.
Instead of this:
form select_bad.
select * from vbak up to 200 rows.
select * from vbap where vbeln = vbak-vbeln.
endselect.
endselect.
endform.
Although using "SELECT...FOR ALL ENTRIES IN..." is generally very fast, you should be aware of the three pitfalls of using it:
Firstly, SAP automatically removes any duplicates from the rest of the retrieved records. Therefore, if you wish to ensure that no qualifying records are discarded, the field list of the inner SELECT must be designed to ensure the retrieved records will contain no duplicates (normally, this would mean including in the list of retrieved fields all of those fields that comprise that table's primary key).
Secondly, if you were able to code "SELECT ... FROM <database table> FOR ALL ENTRIES IN TABLE <itab>" and the internal table <itab> is empty, then all rows from <database table> will be retrieved.
Thirdly, if the internal table supplying the selection criteria (i.e. internal table <itab> in the example "...FOR ALL ENTRIES IN TABLE <itab> ") contains a large number of entries, performance degradation may occur.
<b>15. SELECT * versus SELECTing individual fields</b>
In general, use a SELECT statement specifying a list of fields instead of a SELECT * to reduce network traffic and improve performance. For tables with only a few fields the improvements may be minor, but many SAP tables contain more than 50 fields when the program needs only a few. In the latter case, the performace gains can be substantial. For example:
Use:
select vbeln auart vbtyp from table vbak
into (vbak-vbeln, vbak-auart, vbak-vbtyp)
where ...
Instead of using:
select * from vbak where ...
<b>16. Avoid unnecessary statements</b>
There are a few cases where one command is better than two. For example:
Use:
append <tab_wa> to <tab>.
Instead of:
<tab> = <tab_wa>.
append <tab> (modify <tab>).
And also, use:
if not <tab>[] is initial.
Instead of:
describe table <tab> lines <line_counter>.
if <line_counter> > 0.
<b>17. Copying or appending internal tables</b>
Use this:
<tab2>[] = <tab1>[]. (if <tab2> is empty)
Instead of this:
loop at <tab1>.
append <tab1> to <tab2>.
endloop.
However, if <tab2> is not empty and should not be overwritten, then use:
append lines of <tab1> [from index1] [to index2] to <tab2>.
Hope this will help you all in writing the ABAP program.<b></b>
Similar Messages
-
hi all,
i need to design flow chart for checking for a program whether it satifies the abap coding standards or not. who to do it. if possible send me graphical representations [flow charts] or links to find programming standards.
some of my requirements in that folw chart are
1. how to recognize a blank space in a given program,
2. how to recognize a comment,
3. how to check wheteher a keyword is used or not,
4. how to identify the ' :' symbol
thanks & regards,
suresh babu aluri.plz go through this documementaion,
i think its helpful.
ABAP Programming StandardsContents
1. Objective 5
2. Naming Conventions 5
2.1 Codes for naming conventions 5
2.1.1 Module Codes 5
2.1.2 Free text 6
2.2 Naming Convention of Development Objects 6
2.2.1 Package 6
2.2.2 Executable Program 6
2.2.3 BSP Application 7
2.2.4 Logical Database 8
2.2.5 SAP Scripts /Smartforms 9
2.2.6 Idocs 9
2.2.7 Transaction Code 10
2.2.8 Function Groups 10
2.2.9 Dictionary Objects 11
2.2.10 Message Class 11
2.2.11 Enhancement Projects (User Exits) 11
2.2.12 LSMW Objects 12
2.2.13 Classes 12
2.2.14 BOR Object Types 13
2.2.15 Screen / Transaction Variants 13
2.2.16 Area Menu 13
2.3 Naming of Sub-Objects 13
2.3.1 Program Sub-Objects 13
2.3.2 SAP Script /Smartform sub-objects 14
3. General Programming Guidelines 14
3.1 Modification Logs 14
3.2 Program Organization 15
3.2.1 Executable Programs 15
3.2.2 Dialog Programs 15
3.3 Package 15
3.3.1 Adding Components to existing objects 15
3.3.2 Creation of New Objects 15
3.4 Program Messages 15
3.4.1 Adding Messages to existing landscapes 15
3.4.2 Creation of New Objects 16
3.5 Dictionary Objects 16
4. Structure of ABAP Programs 16
4.1 Type 16
4.2 Status 18
4.3 Authority Check 18
4.4 Program Structure 19
4.4.1 Declaration data for global data, classes and selection screens 19
4.4.2 Container for Processing Blocks 19
4.4.3 Calling Processing Blocks 20
4.5 Screen Flow Logic (Dialog Programs) 20
4.5.1 Place the AT EXIT COMMAND at the beginning of the flow logic. 20
4.5.2 Use FIELD and CHAIN statements to keep fields in error open for correction. 20
4.6 Main Program 20
4.6.1 Events 20
5. General Coding Standards 21
5.1 One command per line 21
5.2 Indented Source Code 21
5.3 Extended Syntax Check 21
5.4 Reusability and Modularity 21
5.5 Text Handling 21
5.6 Usage of System Variables 22
5.7 Chaining Statements 22
5.8 Common Routines 22
5.9 Dialog Messages 22
5.10 Function Keys 23
5.11 Enqueuing and Dequeuing Data Objects 23
5.12 Error Handling (SY-SUBRC) 23
5.13 General Conventions and Hints 24
5.14 Parameters in Sub-Routines 24
6. Performance Standards 25
6.1 General Tips on Performance Tuning 25
6.1.1 Avoid Redundant code 25
6.1.2 Subroutine Usage 25
6.1.3 Case vs. Nested IF 25
6.1.4 Using the MOVE Statement 25
6.1.5 SELECT Queries 25
6.1.6 Using the READ statement 27
6.1.7 Hashed table 27
6.1.8 Transporting 28
6.1.9 Using LDB 28
6.1.10 Append Lines of 28
6.1.11 Use WHILE 28
6.1.12 DELETE <itab> WHERE 28
6.1.13 Using WHERE clause in LOOP .ENDLOOP 28
1. Objective
The objective of this document is to describe general programming guidelines, methodologies, Naming conventions and performance guidelines for all the programs developed for SAP Project.
2. Naming Conventions
This chapter describes the naming conventions to be followed for naming the programming objects for SAP project.
2.1 Codes for naming conventions
The variable portion of naming convention is given with Code ID given in angle brackets(<>). Use the following tables for replacing code IDs with codes in the object naming.
2.1.1 Module Codes
Code ID: mm
Code Description
FI Finance
CO Controlling Module
MM Materials Management
PP Production Planning
SD Sales & Distribution
QM Quality Management
PM Plant Maintenance
IM Inventory Management
WM Warehouse Management
BC Basis Module
BW Business Warehouse
WF Workflows (Master Data Management)
HR Human Resources
EBP EBP
PS Project Systems
PCP Synpro: Product Costing
PAP Synpro: COPA
DP APO : Demand Planning
SP APO : Supply Network Planning
DS APO : Production Planning & Detailed Scheduling
AT APO : Global ATP
TP APO : Transportation Planning/Vehicle Scheduling
CI Core Interface
LC Live Cache
2.1.2 Free text
Code ID: ffff
Developer should replace ffff with meaningful text. The text can be multiple words separated by underscore.
2.2 Naming Convention of Development Objects
2.2.1 Package
Naming Convention: Z<mm>_<ffff>.
Notes:
1. Replace <mm> with Module codes given in section 2.1.1 above.
2. Replace <ffff> with the sub-landscape of the Module that this Message Class caters to as illustrated in examples below.
3. The maximum permissible length for development class is 30 characters
Examples:
Dev. Class Description
ZFI_AR FI: Account Receivables
ZCO_CCA CO: Cost Center Accounting
2.2.2 Executable Program
Naming Convention: Z<mm>_<ffff>.
Notes:
1. Replace <mm> with module codes given in section 2.1.1 above.
2. Replace <ffff> with meaningful text as illustrated in examples below.
3. The maximum permissible length for program name is 30 characters. However, the name should be restricted to 25 characters to accommodate appropriate Include naming as described in 2.2.2.
Examples:
Program Name Description
ZFI_VAT_RET FI: Report for VAT Return
ZMM_AUTO_GR MM: Automated Goods Receipt
ZSD_XX_STCK_SHORTAGE SD: Stock shortage report for stock allocation
2.2.2.1 Includes for executable programs
Naming Convention: Z<mm>_<ffff>_<Inn>.
Notes:
1. All includes of executable program will be prefixed by Z, followed by the same program name as described in 2.2.2 above.
2. Replace <Inn> with include type and sequence number. Use the following table for includes.
Include Type ID Description
TOP Top Include.
Fnn Subroutine pool (Forms)
Inn PAI Modules
Onn PBO Modules
Xnn Other Includes
The maximum permissible length for Include name is 30 characters.
Examples:
Include Name Main Program Name Description
ZFI_VAT_RET_TOP ZFI_VAT_RET FI: Report for VAT Return Top Include
ZFI_VAT_RET_F01 ZFI_VAT_RET FI: Report for VAT Return Forms
ZMM_AUTO_GR_TOP ZMM_FR_AUTO_GR MM: Automated Goods Receipt Top include
ZMM_AUTO_GR_F01 ZMM_FR_AUTO_GR MM: Automated Goods Receipt Forms
2.2.3 BSP Application
2.2.3.1 Main Application
Naming Convention: BSP Applications shall follow the same Naming Convention as Executable Programs i.e. Z<mm>_<ffff>.
Notes:
1. Replace <mm> with module codes given in section 2.1.1 above.
2. Replace <ffff> with meaningful text as illustrated in examples below.
2.2.3.2 Pages & Controllers
Naming Convention: <ffff>
Notes:
1. Replace <ffff> with meaningful text, that adequately describes the function of the page/controller
2.2.3.3 Theme
Naming Convention: Z_<ffff>.
Notes:
1. Replace <ffff> with meaningful text
2.2.3.4 Mime Objects:
Naming Convention: <ffff>
1. A MIME Object can be logo for the company.
2. Replace <ffff> with meaningful text, that adequately describes the function of the MIME objects
2.2.3.5 Controller and Handler Classes:
See section Classes (Section 2.2.133)
2.2.3.6 BSP Extension
Naming Convention: Z_<ffff>
Notes:
1. Replace <ffff> with meaningful text
2.2.3.7 BSP Layout elements id
Label: lb_fffff
Input field: if_fffff
Button: b_fffff
Text Edit: te_fffff
Text View: tv_fffff
Radio button Group: rbg_fffff
Radio button: rb_fffff
Check Box Group: cbg_fffff
Check Box cb_fffff
Tray tr_fffff
Tabstrip ts_fffff
Tableview tab_fffff
1. Replace <fffff> with meaningful text
2.2.4 Logical Database
Naming Convention: Z<mm>_<ffff>.
Notes:
1. Replace <mm> with module codes given in section 2.1.1 above.
2. Replace <ffff> with meaningful text
3. The maximum permissible length for LDB name is 20 characters. However, the name should be restricted to 15 characters to accommodate appropriate Include naming
4. LDB Program and LDB Program Includes shall follow the naming convention Auto-Generated by SAP
2.2.5 SAP Scripts /Smartforms
Naming Convention: ZF<mm>_<ffff>.
Notes:
1. Replace <mm> with module codes given in section 2.1.1 above.
2. Replace <ffff> with meaningful text as illustrated in examples below.
Examples:
Form Name Description
ZFFI_EMP_CONF Employee Confirmation Letter
ZFFI_ANN_TO Annual Turnover Letter To Customers and Vendors
2.2.6 Idocs
2.2.6.1 Idoc Types
Basic Type :
Naming Convention : ZB<FFFF>NN
Notes:
1.Replace <NN> with sequence number.
3. Replace <ffff> with meaningful text.
Extension Type : ZX<Basic type name>_NN
Notes:
1. Replace <NN> with sequence number .
2.2.6.2 Message Types
Naming Convention : ZM<mm><ffff>.
Notes :
1. Replace <mm> with module codes given in section 2.1.1 above.
2. Replace <ffff> with meaningful text .
2.2.6.3 Process Code
Naming Convention : Z<ffff>.
Notes :
1. Replace <ffff> with meaningful text ..
2.2.6.4 IDOC Segments
Naming Convention : Z1<ffff>.
Notes :
1.Replace <ffff> with meaningful text as illustrated in examples below.
2.2.7 Transaction Code
Notes:
1. The tcode name is provided by SAP TIN The Developer must write a mail to SAP Tin asking for the T-Code name with a filled form.
The form can be found at :
2.2.8 Function Groups
Naming Convention: Z<mm><ffff>
Notes:
1. Replace <mm> with relevant module code as given above
2. Replace <ffff> with meaningful text.
2.2.8.1 Function Group Include Programs
Naming Convention: LZ<Function Group><Inn>.
Notes:
1. All includes of Function Group program will be prefixed by LZ, followed by the Function Group name
2. Replace <Inn> with include type and sequence number. Use the values from the table given in 2.2.2.1
Examples:
Include Name Function Group Name Description
SAPLZMMPURCHASING ZMMPURCHASING F.Group-Purchasing: Main Program
LZMMPURCHASINGO01 ZMMPURCHASING F.Group-Purchasing: PBO
LZMMPURCHASINGI01 ZMMPURCHASING F.Group-Purchasing: PAI
LZMMPURCHASINGF01 ZMMPURCHASING F.Group-Purchasing: Forms
LZMMPURCHASINGTOP ZMMPURCHASING F.Group-Purchasing: Data Declarations
2.2.8.2 Function Modules
2.2.8.2.1 Normal Function Modules
Convention: Z_<mm>_<ffff>.
Notes:
1. Replace <mm> with relevant module code as given above.
2. Replace <ffff> with meaningful text.
2.2.8.2.2 IDOC Function Modules
Convention: Z_IDOC_<mode>_<msg type>.
Notes:
1. Replace <mode> with INPUT or OUTPUT depending on whether the function processes incoming or outgoing IDOC.
2. Replace <msg type> with the IDOC message type.
2.2.9 Dictionary Objects
Tables: Z<mm><ffff>
Structures: ZS<mm><ffff>
Views: ZV<mm><ffff>
Data Element: ZDE<mm><ffff>
Domain: ZDO<mm><ffff>
Table Type: ZTT<mm><ffff>
Type Group: Z<ffff>
Search Help: ZSH<mm><ffff>
Lock Object: EZ<mm><ffff>
Notes:
1. Replace <mm> with module code given above.
2. Replace <ffff> with meaningful text.
2.2.10 Message Class
Naming Convention: Z<mm>_<ffff>.
Notes:
1. Replace <mm> with Module codes given in section 2.1.1 above.
2. Replace <ffff> with the sub-landscape of the Module that this Message Class caters to as illustrated in examples below.
3. The maximum permissible length for development class is 30 characters
Examples:
Msg. Class Description
ZFI_AR FI: Account Receivables
ZCO_CCA CO: Cost Center Accounting
2.2.11 Enhancement Projects (User Exits)
Convention: Z<XX><nn>.
Notes:
1. XX is the application area code e.g. for sales it is SD etc.
2. 'nn' is one up number for one application area. It starts with 001.
3. Maximum length of the Project name is 8.
Example: The name of the SD enhancement project can be ZSD001.
2.2.12 LSMW Objects
2.2.12.1 Project
Naming Convention: ZM_<ffff>.
Notes:
1. 1. Replace <ffff> with meaningful text
2. The maximum permissible length for Project name is 16 characters. But please limit it to 12.
Example : ZM_VENDOR
2.2.12.2 SubProject
Naming Convention: ZM_<ffff>_<n>.
Notes:
Suffix Project name with a running sequence no.
Example : ZM_VENDOR_1
2.2.12.3 Object
Naming Convention: ZM_<ffff>_<n><n>.
Notes:
Suffix Subproject name with a running sequence no.
Example : ZM_VENDOR_11
2.2.13 Classes
Naming Convention: ZCL_[IM/DF/BSPCO/BSPHN/BADI]_<ffff>.
1. IM: Implementation Class;
DF: Definition Class
BSPCO: BSP Controller class
BSPHN: BSP Handler class
BADI : BADI implementation
2. Replace <ffff> with meaningful text: In case of Implementation classes, it should preferably be the same as that of the Definition Class
3. Example:
IMPLEMENTATION Class: ZCL_IM_REBATE_SETTL
DEFINITION: ZCL_DF_REBATE_SETTL
2.2.14 BOR Object Types
Object Convention Example
Supertype Z<ffff> ZLVAPPL
SubType Z<SuperType><nn> ZZLVAPPL01
Program <Subtype> ZZLVAPPL01
1. Replace <nn> with a running 2 digit serial Number
2. Replace <ffff> with meaningful text
2.2.15 Screen / Transaction Variants
Naming Convention: <tcode>_<ffff>
Where:
1. Replace <tcode> with the t-code that will be assigned to this Variant
2. Replace ffff with a meaningful text
E.g.:
For an SE16 variant for table KONA that will be used by T-Code Z_CH_SD_001:
Z_CH_SD_001_KONA
2.2.16 Area Menu
Naming Convention: Z<mm>_<Main Menu>_<Sub Menu> <ffff>
Where:
1. Replace <mm> with the Module code
2. Followed by the hierarchical position of the immediate parent of this Area Menu
3. Followed by a Meaningful text for this Menu
E.g.:
ZSD
ZSD_TAB
ZSD_TAB_VIEW
ZSD_TAB_UPDT
Notes:
1. Clusters of Transactions should be introduced as Sub-Menus rather than as Folders
2. As a gradual process, the current Clusters that exist as Folders should also be replaced with Sub-Menus
2.3 Naming of Sub-Objects
2.3.1 Program Sub-Objects
Naming of all the internal components of a program will be consistent across the project.
Naming Convention: <Prefix>ffff.
Notes:
1. Replace <Prefix> with the component prefix values given in the table below.
Program Component Prefixed by
Program Constants C_
Global Variables W_
Types Definition T_
Global Structures WA_
Global Internal Tables I_
Select-Options SO_
Parameters PO_
Table Type TT_
Field Symbols FS_
Ranges R_
Local Constants LC_
Local Variables L_
Local Static Variables LS_
Local Internal Tables LI_
Local Work Area LWA_
Local Range LR_
Field Groups FG_
Container CO_
Macro MA_
Important: The Same sequence as above must be followed in the Data declaration part of all the ABAP/4 programs.
2.3.2 SAP Script /Smartform sub-objects
Naming of all the internal components of a SAPScript/SmartForm shall follow the same convention as for Programs (2.2.2), with the addition of the Field Label on the FRS. E.g. if the FRS has labeled a field for Sales Order Number as Field 27 on the Layout, the variable name should be W_27_VBELN.
3. General Programming Guidelines
3.1 Modification Logs
At the top of every ABAP Object Modified by a Developer, there should be a Modification Log Every Line Created/Changed by the developer should be Identifiable by the TR Number.
ABAP Patterns: Following Patterns should be used for Uniform ModLogs:
Nature of Change Pattern to Use
New Development ZZNEWPROG
In-Line Logs ZZLINE
Modification Logs at the Top of Object ZZMODLOG
3.2 Program Organization
All the programs will be organized as described below.
3.2.1 Executable Programs
TOP Include: For global data declarations
Form Include: For definition of all the FORMs.
3.2.2 Dialog Programs
TOP Include: For global data declarations
Form Include: For definition of all the FORMs.
PBO Include: Include for PBO Modules
PAI Include: Include for PAI Modules
3.3 Package
All the related objects within a sub-module of SAP will be developed under a single Package.
3.3.1 Adding Components to existing objects
When adding new workbench components to existing Objects, the same Package will be used as has been used for the existing Components
3.3.2 Creation of New Objects
When creating new Objects or new Sub-lanscapes, Packages used should have the Naming convention as in Section 2 Above
3.4 Program Messages
All the messages within a sub-module of SAP will be grouped under a single Message Class.
3.4.1 Adding Messages to existing landscapes
When adding new messages for existing Objects, the same Message Class will be used as has been used for the existing Objects
3.4.2 Creation of New Objects
When creating new Objects or new Sub-landscapes, Message classes used should have the Naming convention as in Section 2 Above
3.5 Dictionary Objects
Whenever you create a Z table in system always include MANDT field as the first field, except when the table contains client independent data. Also create the table with attribute Data Class as USER.
4. Structure of ABAP Programs
4.1 Type
When an ABAP program is run, its processing blocks are called. ABAP programs are controlled from outside the program itself by the processors in the current work process. For the purposes of program flow, we can summarize the screen processor and ABAP processor into the ABAP runtime environment. The runtime environment controls screens and ABAP processing blocks. It contains a range of special control patterns that call screens and processing blocks in certain orders. These sections are also called processors. When a ABAP program is run, the control passes between various processors.
In the R/3 System, there are various types of ABAP program. The program type determines the basic technical attributes of the program, and must be set when created. The main difference between the different program types is the way in which the runtime environment calls its processing blocks.
When an application program is run, it must at least call the first processing block from outside the program, that is, from the runtime environment. This processing block can then either call further processing blocks or return control to the runtime environment. When an ABAP program is started, the runtime environment starts a processor (dependent on the program type), which calls the first ABAP processing block.
The following program types are relevant to application programming:
Type 1
Type 1 programs have the important characteristic that they do not have to be controlled using user-defined screens. Instead, they are controlled by the runtime environment, which calls a series of processing blocks (and selection screens and lists where necessary) in a fixed sequence. User actions on screens can then trigger further processing blocks.
Type M
The most important technical attribute of a type M program is that it can only be controlled using screen flow logic and run via a transaction code which is linked to the program and one of its screens (initial screen).
ABAP programs with type M contain the dialog modules belonging to the various screens. They are therefore known as module pools.
Type F
Type F programs are containers for function modules, and cannot be started using a transaction code or by entering their name directly.
Type F programs are known as function groups. Function modules may only be programmed in function groups. The Function Builder is a tool in the ABAP Workbench that is used to create function groups and function modules. Apart from function modules, function groups can contain global data declarations and subroutines. These are visible to all function modules in the group. They can also contain event blocks for screens in function modules.
Type K
Type K programs are containers for global classes in ABAP Objects. Type K programs are known as class definitions. The Class Builder is a tool in the ABAP Workbench that can be used to create class definitions.
Type J
Type J programs are containers for global interface in ABAP Objects. Type J programs are known as interface definitions and are created in the Class Builder.
Type I
Type I programs - called includes - are a means of dividing up program code into smaller, more manageable units. The coding of an include program can be inserted at any point in another ABAP program using the INCLUDE statement. There is no technical relationship between include programs and processing blocks. Includes are more suitable for logical programming units, such as data declarations, or sets of similar processing blocks. The ABAP Workbench has a mechanism for automatically dividing up module pools and function groups into include programs.
4.2 Status
P = SAP standard production program
K = Customer production program
S = System program
T = Test program
Application
Categorize the program according to the purpose it fulfills.
4.3 Authority Check
Authority checks will be carried out as given in the respective FRSs.
4.4 Program Structure
ABAP programs are responsible for data processing within the individual dialog steps (ie. events) of an application program. This means that the program cannot be constructed as a single sequential unit, but must be divided into sections that can be assigned to the individual dialog steps. To meet this requirement, ABAP programs should have a modular structure. Each module is called a processing block. A processing block consists of a set of ABAP statements. When a program is run, effectively a series of processing blocks is called. Therefore, they should not be nested but modularized.
Each ABAP program consists of the following two parts:
4.4.1 Declaration data for global data, classes and selection screens
The first part of an ABAP program is the declaration part for global data, classes, and selection screens. This consists of:
All declaration statements for global data. Global data is visible in all internal processing blocks and should be defined using declarative statements that appear before the first processing block, in dialog modules, or in event blocks. Local data should not be declared in dialog modules or event blocks.
All selection screen definitions.
All local class definitions (CLASS DEFINITION statement). Local classes are part of ABAP Objects, the object-oriented extension of ABAP.
Declaration statements which occur in procedures (methods, subroutines, function modules) form the declaration part for local data in those processing blocks. This data is only visible within the procedure in which it is declared.
4.4.2 Container for Processing Blocks
The second part of an ABAP program contains all of the processing blocks for the program. The following types of processing blocks are allowed:
1. Dialog modules (no local data area)
2. Event blocks (no local data area)
3. Procedures (methods, subroutines and function modules with their own local data area).
Whereas dialog modules and procedures are enclosed in the ABAP keywords which define them, event blocks are introduced with event keywords and concluded implicitly by the beginning of the next processing block.
All ABAP statements (except declarative statements in the declaration part of the program) are part of a processing block. Non-declarative ABAP statements, which occur between the declaration of global data and a processing block are automatically assigned to the START-OF-SELECTION processing block.
4.4.3 Calling Processing Blocks
Processing blocks can be called from either the ABAP program or using ABAP commands which are themselves part of a processing block. Dialog modules and event blocks are called from outside the ABAP program. Procedures are called using ABAP statements in ABAP programs.
Calling event blocks is different from calling other processing blocks for the following reasons:
An event block call is triggered by an event. User actions on selection screens and lists, and the runtime environment trigger events that can be processed in ABAP programs. Define event blocks for the events that the program needs to react to (whereas a subroutine call, for example, must have a corresponding subroutine). This ensures that while an ABAP program may react to a particular event, it is not forced to do so.
4.5 Screen Flow Logic (Dialog Programs)
4.5.1 Place the AT EXIT COMMAND at the beginning of the flow logic.
Example:
PROCESS AFTER INPUT
MODULE EXIT_1170 AT EXIT-COMMAND.
MODULE PAINT_1170.
4.5.2 Use FIELD and CHAIN statements to keep fields in error open for correction.
Example:
PROCESS AFTER INPUT.
MODULE EXIT_1170 AT EXIT-COMMAND.
CHAIN.
FIELD BTCH1170-JOBNAME.
FIELD BTCH1170-USERNAME.
FIELD BTCH1170-FROM_DATE.
FIELD BTCH1170-FROM_TIME.
MODULE PAINT_1170.
ENDCHAIN.
4.6 Main Program
4.6.1 Events
The Program MUST NOT be coded without the use of Proper Coding blocks
Initializations
Top-of-page during line-selection
At Selection-Screen
At Line-Selection
At User-Command
At Pfn
Start-Of-Selection
Top-Of-Page
Get
End-Of-Page
End-Of-Selection
NOTE: The coding for each event should be logically split into forms (subroutines). That is to say, each event will comprise mostly of PERFORM statements.
5. General Coding Standards
5.1 One command per line
Each ABAP/4 command consists of a sentence ending with a period. Multiple commands can be on one line; however, as a standard start each new command on a new line. This will allow for easier deleting, commenting, and debugging.
5.2 Indented Source Code
The ABAP/4 editor has a "Pretty Printer" command to indent by 2 positions specific lines of code and add subroutine comments. Event keywords are typically not indented.
5.3 Extended Syntax Check
Extended Program Check (EPC) to be done on each object to make sure the code is Syntactically correct. There should be no Error/warning messages in the code.
5.4 Reusability and Modularity
If a block of code is executed more than once, it should be placed in a subroutine at the bottom of the code. This makes the code more readable, requires less indentation, and is easier to debug since the debugger can jump through an entire subroutine via a PF key. Also, when possible parameters should be passed to and from subroutines to make the purpose easier to understand and reduce the need for global variables. Always document the purpose of each parameter.
5.5 Text Handling
Text elements must be used to display any text messages.
5.6 Usage of System Variables
The system variables should be used wherever possible. The SY-SUBRC is to be checked after any function call, selection operation, etc.
5.7 Chaining Statements
Consecutive sentences with an identical beginning shall be combined into a chained statement.
Example:
Instead of the statements
MOVE SY-MANDT TO D00001-MANDT.
MOVE SY-LANGU TO D00001-SPRAS.
A chained statement shall be used
MOVE:
SY-MANDT TO D00001-MANDT,
SY-LANGU TO D00001-SPRAS,
SY-UNAME TO D00001-BNAME.
5.8 Common Routines
Standard sub-routines should be implemented as FUNCTION's rather than a FORM (ie. SUBROUTINE). A FUNCTION is easier to maintain and can be easily tested without a calling program. Standard SAP function modules are also available and the function library should be used to check if function modules already exist for a function that needs to be performed i.e.POPUP_TO_CONFIRM_LOSS_OF_DATA etc.
Includes can also be created for re-usable or common code e.g. common data declaration statements.
5.9 Dialog Messages
Dialogue messages are stored in table T100. Programmers shall check to see if an appropriate message exists before adding a new message. Programs shall use the message-id which corresponds to the SAP module that the program most relates to.
5.10 Function Keys
PF-keys should be programmed to execute functions where required. SAP Standard function keys should be used where appropriate. The most commonly used buttons should be displayed as pushbuttons in the application toolbar.
5.11 Enqueuing and Dequeuing Data Objects
All database objects being processed by a program, for purposes other than for display, shall be enqueued before such processing is executed. If the enqueue is unsuccessful, then a message shall be returned stating why the enqueue was unsuccessful.
Enqueue and Dequeue objects should be created via the data dictionary.
5.12 Error Handling (SY-SUBRC)
Return codes shall always be checked immediately after an event which returns a code.
Eg. Function calls, Select statements, Updates etc.
The value of SY-SUBRC is 0 when successful and generally produces a value of 4 when unsuccessful (there are a few exceptions).
Therefore, rather check SY-SUBRC with:
IF SY-SUBRC <> 0
than with
IF SY-SUBRC = 4 (which is redundant and makes the system do a double check)
Error messages displayed to the user must be clear and descriptive.
Remember to group related / dependant steps together and to Rollback all changes for steps in that group should any one of them fail, thus maintaining the integrity of the system.
Check whether an Error Log, (file), must be produced by your program and if so check on the format of the file.
If any Error Logging is done to a custom table in the database then make sure this table is maintained and monitored correctly. (Dev. Note)
Transaction SE91 provides the facility to create and utilize messages in their appropriate message class. Elaborate on the message if necessary, using the long text documentation for that message number.
5.13 General Conventions and Hints
There should be NO hard coding of values in programs easy maintainability
For amounts, use the CURRENCY command in write statements to automatically convert fields into their correct decimal format. The currency specified in the write statement is treated as a key for the table TCURX. If no entry exists for the currency specified, the system assumes two decimal places.
For quantities, use the UNIT command in write statements to automatically convert fields into their correct decimal format. The contents of the unit specified are used on table T006. If no entry exists for the unit specified, the formatting has no effect.
Use the LIKE statement as often as possible to declare DATA variables instead of an explicit TYPE declarations.
Try to use the INCLUDE statement with standard SAP structures and tables for your structures and internal tables where possible. If you use the include statement to include other program components in your code then document what those components are, what they do and how to use them.
Try to make use of standard SAP Function Modules wherever possible rather than building your own. Use the pull down functionality in transaction SE37 to find suitable standard function modules.
Make use of the SAP PATTERN tool to automatically insert the standard code for:
CALL FUNCTION
MESSAGE ID
SELECT*FROM
PERFORM
AUTHORITY-CHECK
WRITE
CASE
CALL DIALOG
The standard date format to use is DD/MM/YYYY. (Dev. Note)
The standard time format to use is HH:MM:SS.
5.14 Parameters in Sub-Routines
Naming convention for Parameters in subroutine is P_
6. Performance Standards
6.1 General Tips on Performance Tuning
6.1.1 Avoid Redundant code
Avoid leaving "dead" code in the program. Comment out variables that are not referenced and code that is not executed. To analyze the program, use the Program Analysis function in SE38 -> Utilities -> Program Analysis.
6.1.2 Subroutine Usage
For good modularization, the decision of whether or not to execute a subroutine should be made before the subroutine is called.
Example:
IF f1 NE 0.
PERFORM sub1.
ENDIF.
FORM sub1.
ENDFORM.
6.1.3 Case vs. Nested IF
When testing fields "equal to" something, one can use either the nested IF or the CASE statement. The CASE is better for two reasons. It is easier to read and after about five nested IFs the performance of the CASE is more efficient.
6.1.4 Using the MOVE Statement
When records a and b have the exact same structure, it is more efficient to MOVE a TO b than to MOVE-CORRESPONDING a TO b.
6.1.5 SELECT Queries
The performance of any ABAP program mainly depends on the ABAP Queries used in it. More optimum the queries , better the performance. Take care of the points mentioned nin the following sections while writing any ABAP queries.
6.1.5.1 Using all the keys in SELECT statement
When using the SELECT statement, study the key and always provide as much of the left-most part of the key as possible. The SELECT * command is to be avoided everywhere.
6.1.5.2 Fetching Single Record
If the entire key can be qualified, code a SELECT SINGLE not just a SELECT. If all the keys are not available, we should use SELECT UPTO 1 ROWS if we are interested only in the first record.
6.1.5.3 Avoid SELECT-ENDSELECT
Selecting data into an internal table using an array fetch versus a SELECT-ENDELECT loop will give at least a 2x performance improvement. After the data has been put into the internal data, then row-level processing can be done.
Example:
select ... from table <..>
into <itab>
where ...
loop at <itab>
<do the row-level processing here>
endloop.
6.1.5.4 Using Indexs
Use indexes wherever possible. Tune the Query so that optimum Indexing will happen.
6.1.5.5 Provide all the keys
Give as many keys as possible in the WHERE clause to optimize the database fetching. Use the Index fields in the first position to optimize performance.
6.1.5.6 Avoid INTO CORRESPONDING
Avoid using INTO CORESPONDING FIELDS of Table. Instead, explicitly mention the fields. Else, The Table Fields should be in the same sequence as the selection
6.1.5.7 SELECT statement inside LOOP
Do not write SELECT statements inside the loop. Instead, use the FOR ALL ENTRIES Command
Before using FOR ALL ENTRIES command, check that the
1. Corresponding Internal table is not empty. If the Internal table is empty, the statement will select ALL the entries in the Database
2. The Internal table is sorted by the Filed used in the Where Clause: This makes selection faster
6.1.5.8 Nested SELECT statement
Avoid Using nested SELECT statements. Instead, make use of different internal tables to fetch the data, and Use Nested LOOPS to read them.
6.1.5.9 Select Distinct
Whenever its possible avoid SELECT DISTINCT, instead select data into internal table, sort and use DELETE ADJACENT DUPLICATES
6.1.5.10 Use of OR in Where Clause
Do not use OR when selecting data from DB table using an index because The optimizer generally stops if the WHERE condition contains an OR expression.
e.g.
Instead of
SELECT * FROM spfli WHERE carrid = LH
AND (cityfrom = FRANKFURT OR
city from = NEWYORK)
Use
SELECT * FROM spfli WHERE (carrid = LH AND cityfrom = FRANKFURT)
OR (carrid = LH AND cityfrom = NEWYORK).
6.1.5.11 Order By
ORDER BY will Bypass buffer. So, performance will decrease. If you want to sort data, it is efficient to SORT them in INTERNAL TABLE rather than using ORDER BY. Only use an ORDER BY in your SELECT if the order matches the index, which should be used.
6.1.6 Using the READ statement
When reading a single record in an internal table, the READ TABLE WITH KEY is not a direct READ. The table needs to be sorted by the Key fields and the command READ TABLE WITH KEY BINARY SEARCH is to be used.
6.1.7 Hashed table
If the number of entries in the Internal Table is high then use Hashed Table with Keys to access the table.
6.1.8 Transporting
With READ or MODIFY Statements use TRANSPORTING
6.1.9 Using LDB
In order to improve performance in case of an LDB, individual tables can be excluded from selection. Under the section Table Selection in the Documentation of LDB the fields with proper description has been given those fields can be set in the application report at the time of INITIALIZATION or at the START OF SELECTION. This can enhance the performance.
6.1.10 Append Lines of
Whenever it is possible use APPEND LINES OF to append the internal Tables instead of using loop and then APPEND Statement.
6.1.11 Use WHILE
Use WHILE instead of a DO+EXIT-construction, as WHILE is easier to understand and faster to execute
6.1.12 DELETE <itab> WHERE
Use DELETE <itab> WHERE for deleting records from an internal table.
e.g.
Instead of
LOOP AT <itab> WHERE <field> = 0001
DELETE <itab>.
ENDLOOP.
Use
DELETE <itab> WHERE <field> = 0001.
6.1.13 Using WHERE clause in LOOP .ENDLOOP
Use:
Sort ITAB by NAME.
Loop at itab where name EQ SY-UNAME
Endloop.
Instead Of:
Read itab with key name = SY-UNAME.
L_tabix = sy-tabix.
Loop at itab from l_tabix.
If name eq bijoy
Endif.
Endloop. -
I have been charged with creating ABAP Object Standards for my company. I have found naming conventions, but have not found any programming standards anywhere. Does anyone know of any that I could use?
Thanks
CraigHello Craig
I assume you have found the following documentation about
<a href="http://help.sap.com/saphelp_nw04/helpdata/en/92/c2b084bc1d11d2958700a0c94260a5/content.htm">Naming Conventions in ABAP Objects</a>
ABAP Objects standards are, in principle, <b>OO standards</b> meaning that all OO-principles and OO designs/patterns that have proven to be useful should be standard in ABAP as well.
I cannot forward you any standards in detail yet you may find more information in one of the books written by Horst Keller. Others sources may be good introductory books to Java (here I can recommend the books of the "Head First" series).
Regards
Uwe -
dear abapers,
i have a problem in optimize abap code, especially report program.
is there any documentation / step by step guide / tips n tricks for best practise in abap performance optimizer ?
if there any, could you please send to my mail : [email protected]
many thanks in advance
regards
eddhieHi,
Take a look at the links below they have useful info and tips.
http://www.sapdevelopment.co.uk/perform/performhome.htm
http://www.thespot4sap.com/Articles/SAPABAPPerformanceTuning_PerformanceAnalysisTools.asp
http://help.sap.com/saphelp_nw2004s/helpdata/en/6b/4b5ceb971afa469a02268df33f545f/content.htm
http://www.asug.com/client_files/Calendar/Upload/ACF3DBF.ppt#264,1,Slide 1
Cheers
VJ -
ABAP performance issues and improvements
Hi All,
Pl. give me the ABAP performance issue and improvement points.
Regards,
HemaPerformance tuning for Data Selection Statement
For all entries
The for all entries creates a where clause, where all the entries in the driver table are combined with OR. If the number of
entries in the driver table is larger than rsdb/max_blocking_factor, several similar SQL statements are executed to limit the
length of the WHERE clause.
The plus
Large amount of data
Mixing processing and reading of data
Fast internal reprocessing of data
Fast
The Minus
Difficult to program/understand
Memory could be critical (use FREE or PACKAGE size)
Some steps that might make FOR ALL ENTRIES more efficient:
Removing duplicates from the the driver table
Sorting the driver table
If possible, convert the data in the driver table to ranges so a BETWEEN statement is used instead of and OR statement:
FOR ALL ENTRIES IN i_tab
WHERE mykey >= i_tab-low and
mykey <= i_tab-high.
Nested selects
The plus:
Small amount of data
Mixing processing and reading of data
Easy to code - and understand
The minus:
Large amount of data
when mixed processing isnt needed
Performance killer no. 1
Select using JOINS
The plus
Very large amount of data
Similar to Nested selects - when the accesses are planned by the programmer
In some cases the fastest
Not so memory critical
The minus
Very difficult to program/understand
Mixing processing and reading of data not possible
Use the selection criteria
SELECT * FROM SBOOK.
CHECK: SBOOK-CARRID = 'LH' AND
SBOOK-CONNID = '0400'.
ENDSELECT.
SELECT * FROM SBOOK
WHERE CARRID = 'LH' AND
CONNID = '0400'.
ENDSELECT.
Use the aggregated functions
C4A = '000'.
SELECT * FROM T100
WHERE SPRSL = 'D' AND
ARBGB = '00'.
CHECK: T100-MSGNR > C4A.
C4A = T100-MSGNR.
ENDSELECT.
SELECT MAX( MSGNR ) FROM T100 INTO C4A
WHERE SPRSL = 'D' AND
ARBGB = '00'.
Select with view
SELECT * FROM DD01L
WHERE DOMNAME LIKE 'CHAR%'
AND AS4LOCAL = 'A'.
SELECT SINGLE * FROM DD01T
WHERE DOMNAME = DD01L-DOMNAME
AND AS4LOCAL = 'A'
AND AS4VERS = DD01L-AS4VERS
AND DDLANGUAGE = SY-LANGU.
ENDSELECT.
SELECT * FROM DD01V
WHERE DOMNAME LIKE 'CHAR%'
AND DDLANGUAGE = SY-LANGU.
ENDSELECT.
Select with index support
SELECT * FROM T100
WHERE ARBGB = '00'
AND MSGNR = '999'.
ENDSELECT.
SELECT * FROM T002.
SELECT * FROM T100
WHERE SPRSL = T002-SPRAS
AND ARBGB = '00'
AND MSGNR = '999'.
ENDSELECT.
ENDSELECT.
Select Into table
REFRESH X006.
SELECT * FROM T006 INTO X006.
APPEND X006.
ENDSELECT
SELECT * FROM T006 INTO TABLE X006.
Select with selection list
SELECT * FROM DD01L
WHERE DOMNAME LIKE 'CHAR%'
AND AS4LOCAL = 'A'.
ENDSELECT
SELECT DOMNAME FROM DD01L
INTO DD01L-DOMNAME
WHERE DOMNAME LIKE 'CHAR%'
AND AS4LOCAL = 'A'.
ENDSELECT
Key access to multiple lines
LOOP AT TAB.
CHECK TAB-K = KVAL.
ENDLOOP.
LOOP AT TAB WHERE K = KVAL.
ENDLOOP.
Copying internal tables
REFRESH TAB_DEST.
LOOP AT TAB_SRC INTO TAB_DEST.
APPEND TAB_DEST.
ENDLOOP.
TAB_DEST[] = TAB_SRC[].
Modifying a set of lines
LOOP AT TAB.
IF TAB-FLAG IS INITIAL.
TAB-FLAG = 'X'.
ENDIF.
MODIFY TAB.
ENDLOOP.
TAB-FLAG = 'X'.
MODIFY TAB TRANSPORTING FLAG
WHERE FLAG IS INITIAL.
Deleting a sequence of lines
DO 101 TIMES.
DELETE TAB_DEST INDEX 450.
ENDDO.
DELETE TAB_DEST FROM 450 TO 550.
Linear search vs. binary
READ TABLE TAB WITH KEY K = 'X'.
READ TABLE TAB WITH KEY K = 'X' BINARY SEARCH.
Comparison of internal tables
DESCRIBE TABLE: TAB1 LINES L1,
TAB2 LINES L2.
IF L1 <> L2.
TAB_DIFFERENT = 'X'.
ELSE.
TAB_DIFFERENT = SPACE.
LOOP AT TAB1.
READ TABLE TAB2 INDEX SY-TABIX.
IF TAB1 <> TAB2.
TAB_DIFFERENT = 'X'. EXIT.
ENDIF.
ENDLOOP.
ENDIF.
IF TAB_DIFFERENT = SPACE.
ENDIF.
IF TAB1[] = TAB2[].
ENDIF.
Modify selected components
LOOP AT TAB.
TAB-DATE = SY-DATUM.
MODIFY TAB.
ENDLOOP.
WA-DATE = SY-DATUM.
LOOP AT TAB.
MODIFY TAB FROM WA TRANSPORTING DATE.
ENDLOOP.
Appending two internal tables
LOOP AT TAB_SRC.
APPEND TAB_SRC TO TAB_DEST.
ENDLOOP
APPEND LINES OF TAB_SRC TO TAB_DEST.
Deleting a set of lines
LOOP AT TAB_DEST WHERE K = KVAL.
DELETE TAB_DEST.
ENDLOOP
DELETE TAB_DEST WHERE K = KVAL.
Tools available in SAP to pin-point a performance problem
The runtime analysis (SE30)
SQL Trace (ST05)
Tips and Tricks tool
The performance database
Optimizing the load of the database
Using table buffering
Using buffered tables improves the performance considerably. Note that in some cases a stament can not be used with a buffered table, so when using these staments the buffer will be bypassed. These staments are:
Select DISTINCT
ORDER BY / GROUP BY / HAVING clause
Any WHERE clasuse that contains a subquery or IS NULL expression
JOIN s
A SELECT... FOR UPDATE
If you wnat to explicitly bypass the bufer, use the BYPASS BUFFER addition to the SELECT clause.
Use the ABAP SORT Clause Instead of ORDER BY
The ORDER BY clause is executed on the database server while the ABAP SORT statement is executed on the application server. The datbase server will usually be the bottleneck, so sometimes it is better to move thje sort from the datsbase server to the application server.
If you are not sorting by the primary key ( E.g. using the ORDER BY PRIMARY key statement) but are sorting by another key, it could be better to use the ABAP SORT stament to sort the data in an internal table. Note however that for very large result sets it might not be a feasible solution and you would want to let the datbase server sort it.
Avoid ther SELECT DISTINCT Statement
As with the ORDER BY clause it could be better to avoid using SELECT DISTINCT, if some of the fields are not part of an index. Instead use ABAP SORT + DELETE ADJACENT DUPLICATES on an internal table, to delete duplciate rows. -
Hi all,
Please give me some information for abap code standards using in it companies.Hi
Normally company or client specific.
Mostly used common are
Modification history should be there..
for local variables l_variable
Internal tables i_ vbak etc....
any report shud start with z_modulename_programname -
Can not perform the goods receive throught MIGO_GR
Hello
I´m having these issue : receiving area can not perform the goods receive throught the MIGO_GR and the error that display this transacction is "Document XXXXXXX does not containg any selectable items" and when I go to see the transaction ME38 the street light is in green
Your help will be appreciated
RegardsHi
According you sad you have a release created and a schedule line with open quantity for the delivery schedule. So...
Do you have the confirmation control key defined in the schedule agreement? If yes you have to create an inbound delivery through VL31N.
Do you have release strategy defined for the agreement?
Regards
Eduardo Chagas -
hi can u tell me the standards that are followed in a company for ABAP CODE.
There are some coding guidelines need to be followed during coding . here are a few ones
Avoid dead-code
Remove unnecessary code and redundant processing
Spend time documenting and adopt good change control practices
Spend adequate time anayzing business requirements, process flows, data-structures and data-model
ensure careful usage of "OR", "NOT" and value range tables (INTTAB) that are used inappropriately in Open SQL statements.
f you are interested in exactly one row of a database table or view, use the SELECT SINGLE statement instead of a SELECT * statement. SELECT SINGLE requires one
communication with the database system whereas SELECT * requires two.
It is usually faster to use the INTO TABLE version of a SELECT statement than to use APPEND statements
f you want to find the maximum, minimum, sum and average value or the count of a database column, use a select list with aggregate functions instead of computing the aggregates within the program. The RDBMS is responsible for aggregated computations instead of transferring large amount of data to the application. Overall Network, Application-server and Database load is also considerably less.
If you process your data only once, use a SELECT-ENDSELECT loop instead of collecting data in an internal table with SELECT ... INTO TABLE. Internal table handling takes up much more space
Using nested selects is a technique with low performance. The inner select statement is executed several times which might be an overhead. In addition, fewer data must be transferred if another technique would be used eg. join implemented as a view in ABAP/4 Repository.
Whenever possible, use array operations instead of single-row operations to modify the database tables.
Frequent communication between the application program and database system produces considerable overhead.
some best practices are :
1. Use of local variables instead of global variables - will save memory. Use global variables ony when absolutely necessary!
2. (a.) Do not change variables in the "using", use the "changing" parameters instead for this purpose
(b.) "tables" parameter is now obsolete - do NOT use
3. Inside subroutines (forms), the using and changing parameters should have reference to a "TYPE"
4. NO literals, instead use constants / text elements - as the case may be.
5. All constants should be defined globally.
6. Query on database tables within: loop.... endloop - to be strictly avoided
7. Internal table definition technique - using DDIC Structures and DDIC Table Types. Avoid defining local types in programs. Do not define internal tables with header line.
8. Initialize, clear variables/work areas before internal table reads.
9. Sort internal tables before using "delete adjacent duplicates".
10. Use the "binary search" option while reading internal tables, and sort the internal table prior to read.
11. Check that the internal table has entries (not initial) before using "for all entries" option in select statements.
12. sy-ucomm = 'ONLI'?? Is this to check if program executed online or in background? Use the sy-batch variable instead
13. Use function modules to read: Customizing and Master tables. Only Transaction tables to be directly queried.
14. SY-SUBRC check is a MUST after all function calls; and please handle the exception suitably.
15. Use of field symbols with internal tables [LOOP at itab ASSIGNING <fs>] is always a preferred/better option, as against loop at itab into <WORK_AREA>.
16. Use of too many includes ?? (We could use: one include for global data declarations, one include for class methods, one include for subroutines and probably one more include for Application logs)
17. No dead code please - remove if not required.
18. Use of case.... endcase, is preferred instead of: if.. elseif.. endif.
19. Try NOT to use "into corresponding fields of" or "move corresponding" - these are detrimental from a performance perspective
20. Instead of "select single", it is better to use "*_SINGLE_READ" function modules if available. Check always for availability of standard function modules for data retrieval from Master / Customizing tables.
21. Use of Memory ID's to be strictly avoided, as these could be overwritten globally.. Please write explicit GET, SET function modules for this purpose.
22. Locking the database before direct table updates is mandatory, database updates should always be in -> 'Update task' function modules.
23. After BAPI calls, use BAPI_TRANSACTION_COMMIT. Do NOT call BAPI_TRANSACTION_COMMIT in a loop.
24. Case 'X'. when <variable> ???? - refrain from using in this manner
25. Provide adequate inline comments, explaining what the piece of code is supposed to do / intended to achieve.
Message was edited by:
Sridhar Srirama -
Hi all
I have recently started working in an organization as an ABAP programmer. Earlier, as part of my curriculum, I have designed a couple of systems using UML and coded the same in JAVA. Having worked on OO systems, I have a few questions to ask about ABAP and Web AS.
1) Does a company implementing SAP 6.0/ECC 6 have to decide in advance whether it will be coding its business logic/applications in JAVA or ABAP? Or Wes AS can process both languages once installed.
2) If a program is written in OO ABAP as well as in JAVA for a given business scenario (using the same OO (UML) structure) and executed on a Web AS, which one will perform better? Why?
3) Why is it that organizations, in spite of the visible benefits of OO programming, are unwilling to let go of procedural ABAP and adapt OO ABAP? Anyways, they dont have to convert their existing code but just to begin any new development using OO concepts. Is it because programs written in ABAP are usually not that complex to be modeled in OO concepts or there are not many people who know both ABAP and OO concepts.
Regards,
Anoop Sahu1) If a company is implementing ECC, it is all written in ABAP. THe R/3(ECC) backend system is comprised entirely in ABAP, so there is no decision, if you want to develop an application in ECC(R/3), you use ABAP. If you want to develop a java based application to access the ECC backend, you may do so using tools like jCo and JCA, and the webdynpro java environment supplies tools for you to access the backend. You can not directly access the ABAP backend data/tables from a java application, you must use the data access tools mentioned. Of course you need the java add on, or a standalone java application server to do this.
3) A lot of shops are used to the procedural ABAP model and have not yet had a need to implement an application using OO concepts, there are advantages, but an application does not have to use it. In some cases, it is a better way to go, but really it is all about the design, using ABAP OO is really not worth it without a good design. It is advantagious for ABAPers to imbraced ABAP OO concepts as this will be the design paradigm of future developments in ECC. In order to understand how a standard program works, they will need to know OO concepts.
Regards,
Rich Heilman -
Perform Post Goods Receipt Against Scheduling Agreement
Dear all,
I've weird problem here. This is concering GR against Scheduling Agreement. I've a "LPA" type Scheduling Agreement and all the delivery schedule maintained and schedule line released successfully in ME38.
When I do GR via MIGO by entering the Scheduling Agreement #, a prompt was given with no items selected. Note: My schedule line delivery date = GR posting date.
What I did was, inside MIGO I go to Settings | Default Values and check on "Propose All Items". Finally, the affected line item appears but with "blank" quantity. So, I key in the actual quantity per the released schedule line and complete the GR posting successfully.
Question 1: Why do I need to perform the MIGO propose all items setting? Normal PGR against PO doesn't require this.
Question 2: Is this a standard SAP behavior or I'm doing PGR - scheduling agreement process the wrong way?
Appreciate any expert clarification.
Thanks in advance.
StevenHi Jurgen,
I've read Notes 493404 and I'm facing Question 10
10. Question:
For the goods receipt for the scheduling agreement the system displays error M7 064: "Document xx does not contain any selectable items".
Answer:
A possible reason is that the document is subject to a release strategy and has yet to be released. You can check this using transaction ME33 and release it subsequently if necessary.
Another reason can be that although a confirmation control key that contains a confirmation category with GR assignment has been maintained for the scheduling agreement item, this category has yet to be confirmed. You can check this using transactions ME33 and OMGZ. If necessary, create the relevant confirmation.
Another reason may be that no undelivered schedule line exists up to the posting date. If nevertheless you want to post the GR, you can use transaction ME38 to bring the next schedule line date forward, or in transaction MB01 you can select the "Suggest Zero Lines" field or in transaction MIGO the "Propose All Items" field under Settings - Default values.
From the snapshot of the notes 493404 above:
1. I don't have a release strategy for the scheduling agreement. Have checked via ME33L
2. I didn't implement any confirmation control in the scheduling agreement. Have checked via ME33L
3. I've a delivery schedule line up to the posting date. In my scenario, schedule line date = GR posting date
Therefore, I'm still truly puzzle with the system behavior. Any further help will be most appreciated.
Thanks.
Steven -
I recently saw a set of programming standards that stated it was better not to use an ORDER BY clause on a SELECT statement. Instead SELECT into an internal table and use SORT. The actual statement was....."In most cases it is preferable to do the sorting within the ABAP program instead of on the database server. That means: fill the internal table via a SELECT statement and then sort via the SORT statement instead of coding a SELECT u2026 ORDER BY. The sorting of large amounts of data on the database server affects the performance of all users on the system, whereas the sorting within the ABAP program u2018onlyu2019 affects the application server. However, if an index exists on the table that can be used for the sorting then the SELECT u2026 ORDER BY doesnu2019t cause any undue strains on the system."
I think this is no longer correct particularily with regards to Systemi/iSeries which we normally run in 2 tier mode.
What are people opinion on this?Peter,
the correct answer for DB2 on IBM i is "it depends". To implement "ORDER BY", the optimizer has basically these choices:
- If an index with the columns of the "ORDER BY" clause exists, the database can access the data through this index, which returns them in the desired order. However, the data needs to be fetched row by row, so for each returned row you need one I/O request.
- If such an index does not exist, the database can choose to perform a sequential read into a temporary storage and sort the temporary result set before returning the data to the caller. This is basically the same as reading the data into an internal table and let ABAP do the sort. Even if an index exist, reading the whole table into memory and sorting it there may be faster, because on a sequential read, the database can execute a "blocked" fetch rather than many individual I/O operations. You may see this if the table is relatively small.
- If such an index does not exist, the database could also choose to create a temporary index and access the data through the temporary index. For the first execution, you don't gain much, but subsequent executions may perform much better. However, after an IPL you loose all temporary indexes, so the index needs to be built again on the first execution after the IPL.
If you code your ABAP to read the table sequentially and sort it in memory, you are forcing the second implementation. If you code ABAP with the ORDER BY in the SELECT statement, you allow the database optimizer to choose the best possible implementation depending on the size of the table, the size of the result set, and the available indexes.
If your table is relatively large but the result set (based on the WHERE clause) is relatively small, make sure to have an index that combines the WHERE clause elements returning only one value with the ORDER BY clause elements.
For example, if you have a query like:
SELECT * FROM T
WHERE A = ? AND B = ? AND C IN (?, ?, ?)
ORDER BY D, E
you should have an index over columns A, B, D, and E for the best possible performance. A and B in the index can be used to limit the result set without any influence on the sort order D, E, but C cannot.
Kind regards,
Christian Bartels. -
WD ABAP performance tips and tricks
Hi all,
I was wondering if there is any good approach to build WD applications so performance does not have to suffer. Do you know of any good documentation on this topic?
Thank you,
GeorgyHello, Georgy,
From my experience, I follow some guidelines. These can be correct or not, but from my researches across SDN and other sources (help.sap.com and Ulli's book), it's proven to be good guidelines. Of course, I'll be presenting here only those tips related to WDA, not ABAP. Here they are:
1. Design your Context nodes carefully:
- Avoid non-Singleton nodes;
- Make your supply functions as simple as possible;
2. Controllers:
- If you use a component (such as ALV or MESSAGE_MANAGER) frequently, instantiate it at WDDOINIT and save it as a public attribute of the COMPONENTCONTROLLER. This way, whenever you need to call a method of the component, you can refer to wd_comp_controller->attribute->method.
3. Views:
- Instead of using dynamic programming to control properties of view elements (visibility, read-only, text, etc), use context attributes. This way, you can control, for instance, the visibility of an element in any method, not only inside WDDOMODIFYVIEW;
4. Methods:
- Use the WDA framework correctly: if you need to consist user entered data, use WDDOBEFOREACTION; if you need to control aspects of the view, use WDDOMODIFYVIEW;
- Learn the Phase Model better than the back of your hands
Well, that's some guidelines I use, and I'd like you to comment it also, or further expand this list.
Regards,
Andre -
Hi Folks,
I'm in need of help. I have just come into a shop that has no SAP OO standards. There are many kingdoms that are not even using SE24 to build classes. Is there a SAP document or guide I can use to set standards. I am really fighting with producing good code over what is in place.
Thanks
BruceHi Bruce,
I am sorry for saying things that have nothing to do with ABAP , i really thought that what i said about zevolving.com had something to do with ABAP OO, regarding design patterns and OO concepts applied to it.
See below my reason to think it: (there's much more, i really appreciate this blog and several times i merged these approaches to mine )
and etc,
I like to learn concepts, because these are made of ideas. Ideas aren't bonded to physical limitations. Your physical resources may evolve and become obsolete over time, an idea can evolve but it can't die, although it can be changed with a tremendous flexibility, it will never be obsolete over a reasonable amount of time.
I am a bit sad because you said i am hiding behind the first link i sent . Robert Martin (CEO of Object Mentor) has so much to say about this matter, and his text about Symptoms of Rotting Design says about an absurd quantity of problems i have seen and interacted with in my ABAP experience. The other book i mentioned has so much good concepts and ideas that in here ... i can't put in words.
I am really sorry for being a nuisance. Lesson learned, i won't talk about matters that are so far from the topic ever again.
Obs.: About official SAP documentation, in the SAP Official Course TAW12 (since 2007 *when i saw this subject in it), SAP released in part 1, around 300 pages of content about ABAP Objects. And there are others you can check in SAP PRESS
Regards,
Renan -
Hello,
I've looked for answer, read all the articles about making better performance of PS and I still can't solve the problem... I even tried Photoshop CC and the performance was... worse. I measured time it took to open some files or make some of my actions.
Programs performance is so incredible bad, it's not even annoying it is some disaster... sometimes I have to wait more than 10 seconds for response when I'm moving a layer or few seconds when applying some very simple transformations to smart object (logo etc.). I spent a lot of money on my workstation hoping it will work smooth and fine, and it seems that it is working worse than my old machine for 1/10 of its price. I hoped that moving to Cloud will solve the problem and the new software understands better new hardware I own, but NO! as I mentioned it is working even slower.
The problem only affects Photoshop and Illustrator, After Effects run perfectly fast... but I work mostly on Photoshop and Illustrator. Most of the time both programs are opened.
Some more hardware details of my workstation:
Dual Xeon 2630 @ 2.3 GHz
32 GB Ram
System Drive: PCI-E Revodrive 3 x2 240 GB
Storage Drive: 3GB WD
Graphic Card: 2x GF GTX 680 in SLI (2GB memory each)
System: Windows 8.1 Pro 64-bit
Adobe Suite CS 6 Master
I keep to all advices from "Photoshop performance" articles. I tried another SSD drive as scratch drive, all drivers are up to date, system is "fresh installed" without any garbage...
I'll really apreciate any good advice that could help me solve the problem, so I'll be able to work normal. Without lost hours on waiting for the simpliest actions.I just to reinstalled drivers and NOTHING... (Latest nVidia drivers clean install)... I also looked on my resources manager and after few munutes photoshop easly uses more than 50% of avaiable RAM... when I'M working procesor usage is about 5-9% (12% was maximum) and when I run also Adobe Illustrator memory usage goes above 60% but cpu usage is still low (5-7%). I have 32GB of memory... PSD file I work on is 750MB... Maybe there is some issue with my memory, buffer or something like this? Any idea?
When I copy 1920x1080px layer from one program to the other it takes few minutes, and sometimes programes crush... even if I'm not working the memory usage is now above 60% - shouldn't it go down?
oth Photoshop and files I work on are on the same drive (PCI-E SSD OCZ RevoDrive 3x2 - so it shoulb be super-fast...).
Sorry for bad spellings - I'm so angry now!!!
HELP PLEASE! -
UI API: Poor performance in Goods Receipt (PO) while inserting rows
Hi all,
we wrote small procedure, where we import some data from .txt file into Good Receipt (PO) document. There is no many infos there, we fill only these columns in GR matrix:
ItemCode, Quantity, Warehouse
For inserting data into document's row we use this code:
oItCdCol.Cells(lRow).Specific.Value = Trim(sItm)
oQtyCol.Cells(lRow).Specific.Value = Trim(sQty)
oWHSCol.Cells(lRow).Specific.Value = Trim(sWHS)
lRow = lRow + 1
but with more than 30 lines in import file the performance is very poor, with cca. 300 lines it takes many hours. The GoodReceipt form is during import freezed of course.
We use SBO2005 SP01 Patch 22. Is there performance problem with documents generally in this patch or something else?
Thanks in advice.
Kind regards
Libor Mego.Are you working with Visual Basic 6 or Visual Basic from Visual Studio?.
If you response VS, then try to use directly
oItCdCol.Cells(lRow).Specific.Value = sItm.<b>Trim</b>()
There is not the same througputh with olders function versus the newest.
My recomendation is the same from Microsoft, "enjoy" always to use the Class routines like Trim, Integer.parse, <object>.ToString, ....
Maybe you are looking for
-
K7N2 Delta, USB Keybord, Mouse, Login XP
K7N2 Delta, Logitech Cordless Keyboard and Mouse (Cordles Desktop Optical) and "Cold-Boot Problem" with login on Win XP SP1 Sometimes the mouse and keyboard are dead, when I want to login to XP. This happens only, if I use the High Performance-Settin
-
Dear All, I started to generate on my MacBook, with the Tools provided with XCode 5, to generate a dictionary for the Dictionary App which runs fine on my Max OSX machines. Now I wonder if there is a way to upload the dictionary to the hidden diction
-
Passing values to different classes.
Class A (main panel) calls Class B (calendar panel) and Class C (textbox and buttons panel). When the users changes dates on the calendar class B, class C needs to be notified of the new values. I have two constructors in class C...an empty parameter
-
Can't login to new open directory users
I have a Mac Mini Server running 10.8.2 Server. I have existing users, most with no home directory and a couple with network home directories. However, any NEW users I add (in LDAPv3), they aren't able to login. When I create the user, the "access ac
-
Migration Assistant, Target Disk Mode and Bluetooth Keyboards
Wanted to migrate my iMac setup to a new MBP last night. Kept trying to start up my iMac in target disk mode and it would only boot normally not in TD. Finally realized that my bluetooth keyboard was the culprit in that it wasn't connected once the i