Name: ABAP limpio - Guía de estilo para desarrolladores
Brand: SAP
SKU: BOOK-SAPPRESS-EBOOK-2021-9781493220274

ABAP limpio - Guía de estilo para desarrolladores

Idioma

🇺🇸 Inglés

Editorial SAP PRESS

Año / Edición 2021 / 1

Páginas 351

Autores Klaus Haeuptle, Florian Hoffmann, Rodrigo Jordão, Michel Martin, Anagha Ravinarayan, Kai Westerholz

ABAP limpio

Desarrolladores ABAP, ¿desean limpiar su código? ¡Entonces adquieran esta guía oficial del repositorio GitHub Clean ABAP! Este libro está repleto de las mejores prácticas, directamente de los expertos, para ayudarlos a escribir código ABAP eficaz. Comiencen por aprender cuándo aplicar cada práctica de Clean ABAP. A continuación, sumérjanse en ejemplos de código detallados y explicaciones sobre el uso de clases, métodos, nombres, variables, tablas internas y mucho más. Desde la escritura de código hasta la resolución de problemas y las pruebas, ¡esta es su guía de estilo completa!

Aprenda a escribir código ABAP legible y fácil de mantener.
Mejora tu forma de trabajar con clases, interfaces, métodos, variables, tablas y mucho más.
Comprender cómo elegir nombres útiles, escribir comentarios sólidos y dar formato al código correctamente.

Aprenderás sobre:

Conceptos limpios de ABAP:
¿Qué es ABAP limpio y por qué es importante escribir código limpio? Comprenda los conceptos de ABAP limpio con la opinión de los expertos, incluyendo consideraciones especiales para el código heredado y el rendimiento.
Mejores prácticas:
Descubra el qué, el porqué y el cómo de las mejores prácticas de ABAP. Aprenda a mejorar su código, incluyendo el uso adecuado de clases e interfaces, el manejo del diseño de métodos y el flujo de control, el diseño y la ejecución de pruebas unitarias, y mucho más.
Ejemplos prácticos:
¡Vea las prácticas limpias de ABAP en acción! Mejore su comprensión sobre cómo escribir código eficaz. Utilice ejemplos detallados para cada práctica recomendada que demuestran la diferencia entre código limpio y código desordenado.

Aspectos Destacados:

Clases e interfaces
Métodos
Nombres
Variables y literales
Tablas internas
Flujo de control
Comentarios
Formato
Manejo de errores
Pruebas unitarias
Paquetes

Ver Tabla de Contenidos Completa

Prefacio
- A quién va dirigido este libro
- Cómo está organizado este libro
- Agradecimientos
- Conclusión
1 Introducción
- 1.1 ¿Qué es Clean ABAP?
  - 1.1.1 ¿Qué es la legibilidad?
  - 1.1.2 ¿Cuál es la historia detrás de Clean ABAP?
- 1.2 Cómo empezar con Clean ABAP
- 1.3 Cómo manejar el código heredado
- 1.4 Cómo revisar el código automáticamente
- 1.5 ¿Cómo se relaciona Clean ABAP con otras guías?
- 1.6 Cómo participar en la comunidad Clean ABAP
- 1.7 Resumen
2 El lenguaje ABAP
- 2.1 Código heredado mental
- 2.2 Rendimiento mental
  - 2.2.1 En su mayoría inofensivo
  - 2.2.2 Comience limpio, degrade solo cuando sea necesario
  - 2.2.3 Mida, no dé nada por sentado
- 2.3 Prefiera la orientación a objetos a la programación procedimental
  - 2.3.1 Paradigma de programación de ABAP
  - 2.3.2 La diferencia entre grupos funcionales y clases
  - 2.3.3 Diferencias en la orientación a objetos de ABAP
  - 2.3.4 Si no tiene otra opción
- 2.4 Prefiera las construcciones lingüísticas funcionales a las construcciones lingüísticas procedimentales.
- 2.5 Evita los elementos lingüísticos obsoletos
- 2.6 Utilizar los patrones de diseño de forma inteligente
  - 2.6.1 Demasiados singletons
  - 2.6.2 Demasiados patrones mezclados
- 2.7 Resumen
3 Clases e interfaces
- 3.1 Orientación a objetos
  - 3.1.1 Interfaces
  - 3.1.2 Clases y objetos
  - 3.1.3 Estado
- 3.2 Alcance y visibilidad
  - 3.2.1 Alcance global y local
  - 3.2.2 Visibilidad
- 3.3 Constructores
  - 3.3.1 Alcance y visibilidad
  - 3.3.2 Inyección de dependencias
  - 3.3.3 Métodos de creación estáticos
  - 3.3.4 Patrones de creación
  - 3.3.5 Instanciación
- 3.4 Resumen
4 métodos
- 4.1 Programación orientada a objetos
  - 4.1.1 Métodos estáticos e instancias
  - 4.1.2 Métodos de instancia pública
  - 4.1.3 Redefinición del método
- 4.2 Parámetros
  - 4.2.1 ¿Cuántos parámetros de entrada son demasiados?
  - 4.2.2 Parámetros de entrada opcionales
  - 4.2.3 Parámetros de entrada preferidos
  - 4.2.4 Parámetros de entrada booleanos
  - 4.2.5 Parámetros de EXPORTACIÓN
  - 4.2.6 Parámetros de RETORNO
  - 4.2.7 Cambio de parámetros
  - 4.2.8 Paso por valor y paso por referencia
- 4.3 Cuerpo del método
  - 4.3.1 Haz una sola cosa
  - 4.3.2 Descender un nivel de abstracción
  - 4.3.3 Mantenga los métodos pequeños
  - 4.3.4 Fallar rápido
  - 4.3.5 COMPROBAR frente a DEVOLVER
- 4.4 Métodos de llamada
  - 4.4.1 Transmisión de parámetros de entrada
  - 4.4.2 Captura de parámetros de salida
  - 4.4.3 La construcción CALL METHOD
  - 4.4.4 Nombre del parámetro opcional
  - 4.4.5 Autorreferencia
- 4.5 Resumen
5 nombres
- 5.1 Buen nombre
  - 5.1.1 Nombres descriptivos
  - 5.1.2 Términos del dominio
  - 5.1.3 ¿Plural o singular?
  - 5.1.4 Abreviaturas
  - 5.1.5 Nombrar clases y métodos
  - 5.1.6 Palabras de relleno
  - 5.1.7 Coherencia terminológica
  - 5.1.8 Patrones de diseño en el código
  - 5.1.9 Notación húngara y prefijos
- 5.2 Peculiaridades de ABAP
  - 5.2.1 Grupo de objetos con posibles conflictos de nombres
  - 5.2.2 snake_case frente a camelCase
- 5.3 Afijos: prefijos, sufijos e infijos
  - 5.3.1 Lo imprescindible
  - 5.3.2 Afijos útiles
  - 5.3.3 Afijos que no aportan valor
- 5.4 Cómo lidiar con el código heredado
- 5.5 Resumen
6 Variables y literales
- 6.1 Variables
  - 6.1.1 Declaración de variables
  - 6.1.2 Ramas y alcance
  - 6.1.3 Encadenamiento de declaraciones
  - 6.1.4 Variables de bucle
- 6.2 Constantes
  - 6.2.1 Uso adecuado de las constantes
  - 6.2.2 Clases de enumeración
  - 6.2.3 Agrupación constante
- 6.3 Cuerdas
  - 6.3.1 Literales de cadena
  - 6.3.2 Construcción de cadenas
- 6.4 Booleanos
  - 6.4.1 Cuándo utilizar booleanos
  - 6.4.2 XSDBOOL para decisiones en línea
- 6.5 Expresiones regulares
  - 6.5.1 Expresiones regulares simples
  - 6.5.2 Verificaciones básicas
  - 6.5.3 Expresiones regulares complejas
- 6.6 REDUCIR
- 6.7 Resumen
7 Tablas internas
- 7.1 Uso de la categoría de tabla adecuada
  - 7.1.1 Tablas estándar
  - 7.1.2 Tablas ordenadas
  - 7.1.3 Tablas hash
- 7.2 Evitar la CLAVE PREDETERMINADA
- 7.3 INSERTAR EN TABLA y AÑADIR A
  - 7.3.1 Instrucción APPEND
  - 7.3.2 Instrucción INSERT
- 7.4 Verificación de la existencia de una fila
  - 7.4.1 LECTURA DE TABLA
  - 7.4.2 LOOP AT
  - 7.4.3 LINE_EXISTS
- 7.5 Recuperación del contenido de las tablas
  - 7.5.1 BUCLE AT
  - 7.5.2 LEER TABLA
- 7.6 LOOP AT WHERE y IF anidado
  - 7.6.1 IF anidado
  - 7.6.2 BUCLE EN… DONDE
- 7.7 Identificación de lecturas innecesarias de tablas
- 7.8 Procesamiento por bloques de filas de tabla y operaciones de una sola fila
- 7.9 DESCRIBE TABLE y función de tabla LINES
  - 7.9.1 DESCRIBIR TABLA
  - 7.9.2 LÍNEAS
- 7.10 Resumen
8 Flujo de control
- 8.1 IF
  - 8.1.1 Sucursales de IF
  - 8.1.2 Hazlo comprensible
- 8.2 Profundidad de anidación
- 8.3 Condiciones
  - 8.3.1 Intenta crear condiciones positivas
  - 8.3.2 NO ES o NO ES
  - 8.3.3 Condiciones complejas
- 8.4 CASO
  - 8.4.1 CASE o IF
  - 8.4.2 CASE o SWITCH
  - 8.4.3 Usos múltiples del mismo CASO
- 8.5 Hazlo 1 vez
  - 8.5.1 Pseudo bucles para el flujo de control
  - 8.5.2 Refactorización
- 8.6 Resumen
9 comentarios
- 9.1 Exprésate mediante código
- 9.2 Ubicación y uso de los comentarios
- 9.3 Comentarios que se deben evitar
- 9.4 Comentarios FIXME, TODO y XXX
- 9.5 Comentarios especiales: ABAP Doc, pragmas y pseudocomentarios
- 9.6 Resumen
10 Formato
- 10.1 Coherencia en el estilo de codificación
- 10.2 Optimización para la lectura
- 10.3 La impresora bonita
- 10.4 Número de declaraciones por línea
- 10.5 Longitud de línea
- 10.6 Condensación del código
- 10.7 Líneas en blanco
- 10.8 Alineación de las declaraciones de asignación
- 10.9 Alineación de las declaraciones de variables
- 10.10 Colocación de los soportes de cierre
- 10.11 Parámetros del método de formato
  - 10.11.1 Llamadas de un solo parámetro
  - 10.11.2 Parámetros múltiples de salto de línea
  - 10.11.3 Ubicación de los parámetros
  - 10.11.4 Parámetros de sangría
  - 10.11.5 Alineación vertical de los valores de los parámetros
  - 10.11.6 Transferencia de llamadas a una nueva línea
  - 10.11.7 Sangrados y uso de la tecla Tab
  - 10.11.8 Sangría de las declaraciones en línea
- 10.12 Resumen
11 Manejo de errores
- 11.1 Mensajes
- 11.2 Códigos de retorno
  - 11.2.1 Excepciones frente a códigos de retorno
  - 11.2.2 Manejo de fallas
- 11.3 Excepciones
  - 11.3.1 Las excepciones son para errores
  - 11.3.2 Excepciones basadas en clases
  - 11.3.3 CX_STATIC_CHECK
  - 11.3.4 CX_NO_CHECK
  - 11.3.5 CX_DYNAMIC_CHECK
- 11.4 Levantamiento y captura
  - 11.4.1 Superclase de excepción
  - 11.4.2 Generación de excepciones
  - 11.4.3 Captura de excepciones
  - 11.4.4 Cuándo volcar
- 11.5 Resumen
12 Pruebas unitarias
- 12.1 Clases de prueba
  - 12.1.1 Propiedades de la clase de prueba
  - 12.1.2 Alcance de la clase de prueba
  - 12.1.3 Clases auxiliares de prueba
  - 12.1.4 Ejecución de pruebas
- 12.2 Métodos de prueba
  - 12.2.1 Métodos de fijación de pruebas
  - 12.2.2 Estilo «Dado-Cuando-Entonces»
- 12.3 Clase en prueba
- 12.4 Denominación
- 12.5 Afirmaciones
  - 12.5.1 Redacción de afirmaciones eficaces
  - 12.5.2 Comprobación de excepciones esperadas
  - 12.5.3 Excepciones estáticas inesperadas
  - 12.5.4 Aserciones personalizadas
  - 12.5.5 Restricciones
- 12.6 Dobles de prueba
  - 12.6.1 Inversión de dependencias y dobles de prueba
  - 12.6.2 Marco de pruebas dobles orientado a objetos ABAP
  - 12.6.3 Más herramientas de prueba ABAP
- 12.7 Prueba de costuras
- 12.8 Principios
  - 12.8.1 Desarrollo basado en pruebas
  - 12.8.2 Propiedades de la prueba de limpieza
  - 12.8.3 Cobertura de pruebas
- 12.9 Resumen
13 paquetes
- 13.1 Conceptos generales sobre paquetes
  - 13.1.1 Casos de uso
  - 13.1.2 Niveles de reutilización
  - 13.1.3 Cohesión
- 13.2 Conceptos de paquetes en ABAP
  - 13.2.1 Tipos de paquetes
  - 13.2.2 Paquetes encapsulados
  - 13.2.3 Interfaces de paquetes
  - 13.2.4 Mejores prácticas
- 13.3 Opciones de diseño de paquetes
  - 13.3.1 Jerarquías de aplicaciones en paralelo
  - 13.3.2 Jerarquías basadas en capas
  - 13.3.3 Jerarquías de división de relevancia de traducción
- 13.4 Verificación de paquetes
  - 13.4.1 ¿Qué son las verificaciones de paquetes?
  - 13.4.2 Ejecución manual de comprobaciones de paquetes
  - 13.4.3 Ejecución automatizada de verificaciones de paquetes
  - 13.4.4 Cómo solucionar errores de verificación de paquetes
  - 13.4.5 Mejores prácticas
- 13.5 Consecuencias de una estrategia de empaquetado deficiente o inexistente
- 13.6 Resumen
14 Cómo implementar ABAP limpio
- 14.1 Entendimiento común entre los miembros del equipo
- 14.2 Propiedad colectiva del código
- 14.3 Iniciativa para desarrolladores de código limpio
- 14.4 Abordar el efecto de la ventana rota
  - 14.4.1 Verificación estática del código
  - 14.4.2 Métricas
  - 14.4.3 Cobertura del código
- 14.5 Revisión y aprendizaje del código
  - 14.5.1 Prefijo de revisión de código
  - 14.5.2 Guía de estilo
  - 14.5.3 Hazlo visible
  - 14.5.4 Cultura de retroalimentación
- 14.6 Asesor de código limpio
- 14.7 Técnicas de aprendizaje
  - 14.7.1 Kata
  - 14.7.2 Dojo
  - 14.7.3 Retiro de programación
  - 14.7.4 Compañerismo
  - 14.7.5 Programación en pareja
  - 14.7.6 Programación en grupo
  - 14.7.7 Hábitos
- 14.8 Aprendizaje continuo en equipos multifuncionales
  - 14.8.1 Perfil de un miembro del equipo
  - 14.8.2 Equipos multifuncionales
  - 14.8.3 Multiplicadores: necesidad de contar con expertos en la materia en el equipo
  - 14.8.4 Necesidad de una comunidad de práctica
- 14.9 Resumen
Los autores
Índice

Clean ABAP

ABAP developers, are you looking to clean up your code? Then pick up this official companion to the Clean ABAP GitHub repository! This book is brimming with best practices, straight from the experts, to help you write effective ABAP code. Start by learning when to apply each clean ABAP practice. Then, dive into detailed code examples and explanations for using classes, methods, names, variables, internal tables, and more. From writing code to troubleshooting and testing, this is your complete style guide!

Learn to write readable, maintainable ABAP code
Improve the way you work with classes, interfaces, methods, variables, tables, and more
Understand how to choose useful names, write strong comments, and format code correctly

You'll learn about:

Clean ABAP Concepts:
What is clean ABAP and why is it important to write clean code? Understand clean ABAP concepts with insight from the experts, including special considerations for legacy code and performance.
Best Practices:
Walk through the what, why, and how behind clean ABAP best practices. Learn to improve your code, including using classes and interfaces appropriately, handling method design and control flow, designing and running unit tests, and much more.
Practical Examples:
See clean ABAP practices in action! Improve your understanding of how to write effective code. Use detailed examples for each best practice that demonstrate the difference between clean and messy code.

Key Highlights:

Classes and interfaces
Methods
Names
Variables and literals
Internal tables
Control flow
Comments
Formatting
Error handling
Unit testing
Packages

View Full Table of Contents

Preface
- Who This Book Is For
- How This Book Is Organized
- Acknowledgments
- Conclusion
1 Introduction
- 1.1 What Is Clean ABAP?
  - 1.1.1 What Is Readability?
  - 1.1.2 What’s the Story behind Clean ABAP?
- 1.2 How to Get Started with Clean ABAP
- 1.3 How to Handle Legacy Code
- 1.4 How to Check Code Automatically
- 1.5 How Does Clean ABAP Relate to Other Guides?
- 1.6 How to Engage with the Clean ABAP Community
- 1.7 Summary
2 The ABAP Language
- 2.1 Mind Legacy Code
- 2.2 Mind Performance
  - 2.2.1 Mostly Harmless
  - 2.2.2 Start Clean, Degrade Only Where Needed
  - 2.2.3 Measure, Don’t Assume
- 2.3 Prefer Object Orientation to Procedural Programming
  - 2.3.1 ABAP’s Programming Paradigm
  - 2.3.2 The Difference between Function Groups and Classes
  - 2.3.3 Differences in ABAP’s Object Orientation
  - 2.3.4 If You Have No Choice
- 2.4 Favor Functional Language Constructs over Procedural Language Constructs
- 2.5 Avoid Obsolete Language Elements
- 2.6 Use Design Patterns Wisely
  - 2.6.1 Too Many Singletons
  - 2.6.2 Too Many Patterns Mixed
- 2.7 Summary
3 Classes and Interfaces
- 3.1 Object Orientation
  - 3.1.1 Interfaces
  - 3.1.2 Classes and Objects
  - 3.1.3 State
- 3.2 Scope and Visibility
  - 3.2.1 Global and Local Scope
  - 3.2.2 Visibility
- 3.3 Constructors
  - 3.3.1 Scope and Visibility
  - 3.3.2 Dependency Injection
  - 3.3.3 Static Creation Methods
  - 3.3.4 Creational Patterns
  - 3.3.5 Instantiation
- 3.4 Summary
4 Methods
- 4.1 Object-Oriented Programming
  - 4.1.1 Static and Instance Methods
  - 4.1.2 Public Instance Methods
  - 4.1.3 Method Redefinition
- 4.2 Parameters
  - 4.2.1 How Many Input Parameters Are Too Many?
  - 4.2.2 Optional Input Parameters
  - 4.2.3 Preferred Input Parameters
  - 4.2.4 Boolean Input Parameters
  - 4.2.5 EXPORTING Parameters
  - 4.2.6 RETURNING Parameters
  - 4.2.7 CHANGING Parameters
  - 4.2.8 Pass-by-Value and Pass-by-Reference
- 4.3 Method Body
  - 4.3.1 Do One Thing
  - 4.3.2 Descend One Level of Abstraction
  - 4.3.3 Keep Methods Small
  - 4.3.4 Fail Fast
  - 4.3.5 CHECK versus RETURN
- 4.4 Calling Methods
  - 4.4.1 Passing Input Parameters
  - 4.4.2 Capturing Output Parameters
  - 4.4.3 The CALL METHOD Construct
  - 4.4.4 Optional Parameter Name
  - 4.4.5 Self-Reference
- 4.5 Summary
5 Names
- 5.1 Good Naming
  - 5.1.1 Descriptive Names
  - 5.1.2 Domain Terms
  - 5.1.3 Plural or Singular?
  - 5.1.4 Abbreviations
  - 5.1.5 Naming Classes and Methods
  - 5.1.6 Noise Words
  - 5.1.7 Term Consistency
  - 5.1.8 Design Patterns in Code
  - 5.1.9 Hungarian Notation and Prefixes
- 5.2 ABAP Peculiarities
  - 5.2.1 Group of Objects with Possible Name Collisions
  - 5.2.2 snake_case versus camelCase
- 5.3 Affixes: Prefixes, Suffixes, and Infixes
  - 5.3.1 The Musts
  - 5.3.2 Helpful Affixes
  - 5.3.3 Affixes That Don’t Bring Value
- 5.4 Dealing with Legacy Code
- 5.5 Summary
6 Variables and Literals
- 6.1 Variables
  - 6.1.1 Declaring Variables
  - 6.1.2 Branches and Scope
  - 6.1.3 Declaration Chaining
  - 6.1.4 Looping Variables
- 6.2 Constants
  - 6.2.1 Proper Use of Constants
  - 6.2.2 Enumeration Classes
  - 6.2.3 Constant Grouping
- 6.3 Strings
  - 6.3.1 String Literals
  - 6.3.2 String Building
- 6.4 Booleans
  - 6.4.1 When to Use Booleans
  - 6.4.2 XSDBOOL for Inline Decisions
- 6.5 Regular Expressions
  - 6.5.1 Simple Regular Expressions
  - 6.5.2 Basic Checks
  - 6.5.3 Complex Regular Expressions
- 6.6 REDUCE
- 6.7 Summary
7 Internal Tables
- 7.1 Using the Right Table Category
  - 7.1.1 Standard Tables
  - 7.1.2 Sorted Tables
  - 7.1.3 Hashed Tables
- 7.2 Avoiding DEFAULT KEY
- 7.3 INSERT INTO TABLE and APPEND TO
  - 7.3.1 APPEND Statement
  - 7.3.2 INSERT Statement
- 7.4 Verifying the Existence of a Row
  - 7.4.1 READ TABLE
  - 7.4.2 LOOP AT
  - 7.4.3 LINE_EXISTS
- 7.5 Retrieving Table Contents
  - 7.5.1 LOOP AT
  - 7.5.2 READ TABLE
- 7.6 LOOP AT WHERE and Nested IF
  - 7.6.1 Nested IF
  - 7.6.2 LOOP AT … WHERE
- 7.7 Identifying Unnecessary Table Reads
- 7.8 Block Processing of Table Rows and Single Row Operations
- 7.9 DESCRIBE TABLE and Table Function LINES
  - 7.9.1 DESCRIBE TABLE
  - 7.9.2 LINES
- 7.10 Summary
8 Control Flow
- 8.1 IFs
  - 8.1.1 IF Branches
  - 8.1.2 Keep It Understandable
- 8.2 Nesting Depth
- 8.3 Conditions
  - 8.3.1 Try to Make Conditions Positive
  - 8.3.2 IS NOT or NOT IS
  - 8.3.3 Complex Conditions
- 8.4 CASE
  - 8.4.1 CASE or IF
  - 8.4.2 CASE or SWITCH
  - 8.4.3 Multiple Uses of the Same CASE
- 8.5 Do 1 Times
  - 8.5.1 Pseudo Loops for Control Flow
  - 8.5.2 Refactoring
- 8.6 Summary
9 Comments
- 9.1 Express Yourself in Code
- 9.2 Comment Placement and Usage
- 9.3 Comments to Avoid
- 9.4 FIXME, TODO, and XXX Comments
- 9.5 Special Comments: ABAP Doc, Pragmas, and Pseudo Comments
- 9.6 Summary
10 Formatting
- 10.1 Consistency in Coding Style
- 10.2 Optimizing for Reading
- 10.3 The Pretty Printer
- 10.4 Number of Statements Per Line
- 10.5 Line Length
- 10.6 Condensing the Code
- 10.7 Blank Lines
- 10.8 Alignment of Assignment Statements
- 10.9 Alignment of Variable Declarations
- 10.10 Placement of Closing Brackets
- 10.11 Formatting Method Parameters
  - 10.11.1 Single Parameter Calls
  - 10.11.2 Line Break Multiple Parameters
  - 10.11.3 Placement of Parameters
  - 10.11.4 Indenting Parameters
  - 10.11.5 Vertical Alignment of Parameter Values
  - 10.11.6 Breaking Calls to a New Line
  - 10.11.7 Indents and Using the Tab Key
  - 10.11.8 Indentation of Inline Declarations
- 10.12 Summary
11 Error Handling
- 11.1 Messages
- 11.2 Return Codes
  - 11.2.1 Exceptions versus Return Codes
  - 11.2.2 Handling Failures
- 11.3 Exceptions
  - 11.3.1 Exceptions Are for Errors
  - 11.3.2 Class-Based Exceptions
  - 11.3.3 CX_STATIC_CHECK
  - 11.3.4 CX_NO_CHECK
  - 11.3.5 CX_DYNAMIC_CHECK
- 11.4 Raising and Catching
  - 11.4.1 Exception Superclass
  - 11.4.2 Raising Exceptions
  - 11.4.3 Catching Exceptions
  - 11.4.4 When to Dump
- 11.5 Summary
12 Unit Testing
- 12.1 Test Classes
  - 12.1.1 Test Class Properties
  - 12.1.2 Test Class Scope
  - 12.1.3 Test Helper Classes
  - 12.1.4 Executing Tests
- 12.2 Test Methods
  - 12.2.1 Test Fixture Methods
  - 12.2.2 Given-When-Then Style
- 12.3 Class under Test
- 12.4 Naming
- 12.5 Assertions
  - 12.5.1 Writing Effective Assertions
  - 12.5.2 Checking Expected Exceptions
  - 12.5.3 Unexpected Static Exceptions
  - 12.5.4 Custom Assertions
  - 12.5.5 Constraints
- 12.6 Test Doubles
  - 12.6.1 Dependency Inversion and Test Doubles
  - 12.6.2 ABAP Object-Oriented Test Double Framework
  - 12.6.3 More ABAP Test Tools
- 12.7 Test Seams
- 12.8 Principles
  - 12.8.1 Test-Driven Development
  - 12.8.2 Clean Test Properties
  - 12.8.3 Test Coverage
- 12.9 Summary
13 Packages
- 13.1 General Package Concepts
  - 13.1.1 Use Cases
  - 13.1.2 Reuse Levels
  - 13.1.3 Cohesion
- 13.2 Package Concepts in ABAP
  - 13.2.1 Package Types
  - 13.2.2 Encapsulated Packages
  - 13.2.3 Package Interfaces
  - 13.2.4 Best Practices
- 13.3 Package Design Options
  - 13.3.1 Side-by-Side Application Hierarchies
  - 13.3.2 Layer-Based Hierarchies
  - 13.3.3 Translation Relevance Split Hierarchies
- 13.4 Package Checks
  - 13.4.1 What Are Package Checks?
  - 13.4.2 Manual Execution of Package Checks
  - 13.4.3 Automated Execution of Package Checks
  - 13.4.4 How to Fix Package Check Errors
  - 13.4.5 Best Practices
- 13.5 Consequences of Poor or No Package Strategy
- 13.6 Summary
14 How to Implement Clean ABAP
- 14.1 Common Understanding among Team Members
- 14.2 Collective Code Ownership
- 14.3 Clean Code Developer Initiative
- 14.4 Tackling the Broken Window Effect
  - 14.4.1 Static Code Check
  - 14.4.2 Metrics
  - 14.4.3 Code Coverage
- 14.5 Code Review and Learning
  - 14.5.1 Code Review Prefix
  - 14.5.2 Style Guide
  - 14.5.3 Make It Visible
  - 14.5.4 Feedback Culture
- 14.6 Clean Code Advisor
- 14.7 Learning Techniques
  - 14.7.1 Kata
  - 14.7.2 Dojo
  - 14.7.3 Code Retreat
  - 14.7.4 Fellowship
  - 14.7.5 Pair Programming
  - 14.7.6 Mob Programming
  - 14.7.7 Habits
- 14.8 Continuous Learning in Cross-Functional Teams
  - 14.8.1 Profile of a Team Member
  - 14.8.2 Cross-Functional Teams
  - 14.8.3 Multipliers: Need for Topic Experts in the Team
  - 14.8.4 Need for Community of Practice
- 14.9 Summary
The Authors
Index

ℹ️ ¿Cómo adquirir este libro?

Este producto tiene un precio especial bajo consulta. Puedes iniciar tu pedido o aclarar cualquier duda en el botón Consultar precio de la página.

También hemos preparado una guía paso a paso para explicarte cómo solicitar tu cotización fácilmente.

Ver paso a paso aquí →

Descargo de responsabilidad

SAP, otros productos SAP y servicios mencionados aquí así como sus respectivos logos son marca registrada de SAP SE (o una compañía afiliada de SAP) en Alemania y otros países. Nuestra compañía no está afiliada con SAP SE ni con ninguna de sus compañías afiliadas incluyendo pero no limitada a: Sybase, Business Objects, Hybris, Ariba y SuccessFactors. Todos los otros nombres, marcas, logos, etc. son marcas o servicios registrados de sus respectivos propietarios.

Garantía

Recibe el producto que esperabas o te devolvemos tu dinero

Envío gratis

Envío gratis a tu cuenta de correo electrónico

¿Desea una muestra de un curso/libro?

Necesita una muestra de un curso/libro, solicítela en el chat de abajo y se la brindamos con gusto.

1 mes de $0.00 sin intereses		Total $0.00
2 meses de $0.00 sin intereses		Total $0.00
3 meses de $0.00 sin intereses		Total $0.00
4 meses de $0.00 sin intereses		Total $0.00
5 meses de $0.00 sin intereses		Total $0.00
6 meses de $0.00 sin intereses		Total $0.00