Search icon CANCEL
Arrow left icon
Explore Products
Best Sellers
New Releases
Books
Videos
Audiobooks
Learning Hub
Conferences
Free Learning
Arrow right icon
Mastering SAP ABAP
Mastering SAP ABAP

Mastering SAP ABAP: A complete guide to developing fast, durable, and maintainable ABAP programs in SAP

Arrow left icon
Profile Icon Philipp Deth Profile Icon Paweł Grześkowiak Profile Icon Wojciech Ćwik Profile Icon Wojciech Ciesielski
Arrow right icon
Mex$799.99
Full star icon Full star icon Full star icon Empty star icon Empty star icon 3 (1 Ratings)
Paperback May 2019 548 pages 1st Edition
eBook
Mex$447.98 Mex$639.99
Paperback
Mex$799.99
Subscription
Free Trial
Arrow left icon
Profile Icon Philipp Deth Profile Icon Paweł Grześkowiak Profile Icon Wojciech Ćwik Profile Icon Wojciech Ciesielski
Arrow right icon
Mex$799.99
Full star icon Full star icon Full star icon Empty star icon Empty star icon 3 (1 Ratings)
Paperback May 2019 548 pages 1st Edition
eBook
Mex$447.98 Mex$639.99
Paperback
Mex$799.99
Subscription
Free Trial
eBook
Mex$447.98 Mex$639.99
Paperback
Mex$799.99
Subscription
Free Trial

What do you get with Print?

Product feature icon Instant access to your digital eBook copy whilst your Print order is Shipped
Product feature icon Paperback book shipped to your preferred address
Product feature icon Download this book in EPUB and PDF formats
Product feature icon Access this title in our online reader with advanced features
Product feature icon DRM FREE - Read whenever, wherever and however you want
Product feature icon AI Assistant (beta) to help accelerate your learning
Table of content icon View table of contents Preview book icon Preview Book

Mastering SAP ABAP

Creating Custom Code

The chapter is an introduction to the Systems, Applications, Products (SAP) system. You will learn how to organize their daily work, how to act within SAP systems, how to add custom code, and how to change software features of SAP systems. This chapter presents modern techniques of cooperation within a company. Basic knowledge of these issues is required to work with the SAP system. This chapter is an introduction to the more complex and difficult topics contained in this book.

The following topics will be covered in this chapter: 

  • Making changes
  • Design thinking
  • Big Design Up Front/Little Design Up Front (BDUF/LDUF)
  • Designing for quality and use
  • Designing the User Interface (UI)
  • Designing the services
  • Designing the business logic
  • Designing the database
  • Agile principles
  • DevOps
  • Continuous Delivery

Technical requirements

This chapter does not have complex technical requirements. To check the solutions and examples, it is worth having user access to the SAP system. Other information (for example, agile designing the UI) can be better understood by IT employees. However, it is worthwhile for everyone who's interested in working with SAP systems to read the information contained in this chapter.

All the code used in this chapter can be downloaded from the following GitHub link: https://github.com/PacktPublishing/Mastering-SAP-ABAP/tree/master/Chapter01.

Making changes

There are several ways in SAP to make changes. Some of them are configuration changes, and some are purely programmatical changes.

SAP systems can be enhanced in five ways:

  • Customizing: Specific business and functional process configuration according to the implementation guide. The need to make these changes is predicted by SAP and the procedure of implementation has been developed.
  • Personalization: Setting up global attributes to display certain fields (such as default values or switching off the display of a field).
  • Modification: These are changes SAP Repository objects make at the client side. SAP also can deliver a new version of those objects, and customers need to reflect these changes in the system. Before version 4.0B, customers needed to make this adjustment manually using upgrade utilities. From 4.5A, customers can use the Modification Assistant to automate this procedure.
  • Enhancement: Creating a repository object inside a standard SAP program. More details about enhancement will be in Chapter 10, Modification and Customization Techniques.
  • Custom development: This means creating objects that are unique to the client repository, which is created in the specified namespace, such as Y* or Z*, for all new objects.

In your daily work as an ABAP programmer, your most common work is creating custom developments and enhancements. Since we have a chapter on enhancements, we will focus here on custom development.

In custom development, we can create a custom program and dictionary elements. There will be more about creating dictionary elements in Chapter 2, The Basic Structure of ABAP.

As an example, we will show you how to create one of the most basic programs: Hello World.

In the first step, we need to open one of the most commonly used transactions in our daily work—SE80. This transaction is called Object Navigator, and is a transaction where we can create, change, and delete most ABAP objects.

The main window for the SE80 transaction looks like this:

First, to open the SE80 transaction, we need to put the name of the transaction in the search box, as shown in the following screenshot:

 Press enter, or click on .

After opening a transaction, we need to choose the Program option in the drop-down list on the left and enter the name Z_HELLO_WORLD in the window, as shown in the following example, and press Enter:

In the next window, choose Yes:

Confirm the name of a new program in the next window. Click on  or press Enter:

In the next window, define the attributes of the program, and now press Enter or click on :

After this, choose a package. We need to create a program as a local object, so click on :

After this, we get a window like this:

Now change the mode to Change by clicking on the   icon or pressing Ctrl + F1. The background color of the window with the code will change to white. Now we put the code there.

To print Hello world on the screen, we just need to add this:

WRITE 'Hello World'.
Remember! All ABAP custom programs needs REPORT NAME_OF_PROGRAM at the beginning.

The program looks similar to the following screenshot:

The program now needs to be activated. To activate it, click on  or press Ctrl F3. When an object has been activated, a message will be shown: .

To execute the program, click on  or press F8:

The result of the program is shown in the preceding screenshot.

Design thinking

Design thinking is a method of creative problem-solving. This method is designed to deliver innovative solutions by using a specific work method. The motto of this method is doing, not talking, so going over every detail of the project is changed into a multi stage division of tasks in order to extend and refine subsequent tasks.

The process of design thinking is divided into five steps:

  1. Empathy: All of the new solutions are created for people. Therefore, the needs of a given group of people should be known, and this is why empathy is the starting point of all projects created by design thinking. To find the optimal solution, we need to see how this solution will help the common user.
  2. Define the problem: In this stage, we need to define the exact problem to solve. We need to remember not to define problems in too narrow or too wide a range so that the solution will not be limited by rigid frames.
  3. Ideas: This stage consists of creating as many ideas as possible for solutions relating to the previously defined problem. In this step, a brainstorm is very useful. The important thing is not to stick to your own ideas, and not to judge others. These sessions should be ended by choosing a concrete solution, which will be picked from the previously selected ideas.
  1. Prototypes: Creating the prototypes is an indispensable step. Building prototypes should not be a very complicated process. The most important thing is to make a preliminary visualization of the idea, because only in that way can the idea be tested naturally. Every subsequent prototype should be created by thinking of the user and answering concrete questions.
  2. Tests: This step is extremely important. In this step, the product is tested in a real environment, so you can check that it functions correctly. Every prototype can be evaluated by the group (for example, the project group), and the best one will be chosen for further improvements. Testing should be repeated until a satisfactory result is obtained.

BDUF/LDUF

LDUF is the process of modeling a small subsystem before coding, and BDUF is also a process of modeling, but in BDUF, the whole system needs to be modeled before implementation. BDUF can also be an anti-pattern for many reasons, but LDUF (or many occurrences of LDUF within a project) is often helpful.

BDUF occurs in one of two categories:

  • A document of the high-level architecture, which determines the key features of architecture, but the rest of the things are unspecified and/or unclear.
  • General documentation should describe everything from high-level architecture to the smallest detail of the system. These documents are often incoherent as there are no automatic ways to cross-check them.

LDUF can be precise and concise, and many programmers/architects can check/verify LDUF and detect any inconsistencies.

Generating and changing BDUF is often hard and expensive. It requires teams of analysts, consultants, and architects, and support from many layers of management. LDUF is light and informal—often, a programmer can do a mock-up, and if it's checked, it can be checked by a small team.

These are the main aspects of LDUF:

  • Highly informal; it can be made by yourself or with a small team of programmers.
  • Code is created in a small subsystem, which can be as small as even one class, function, or package.
  • Often not prescriptive—the results are to be used as advice, not requirements.

BDUF is prescriptive—the code must be consistent with the paper project; all exceptions require management intervention. Additionally, it is anti-productive for many of the reasons mentioned in the preceding points.

Designing for quality and use

When designing new software, it is not only a matter of creating functional code. The eventual outcome is going to be a product that serves its purpose, but is also possible to improve, is robust, is easily maintained, and can be used for a long time. From the user's perspective, once the product is paid for, it won't require much more cost in terms of funds, man effort, or any other measurable value.

In order to fulfill these goals and achieve user satisfaction, the philosophy of quality engineering was introduced. In principle, it defines product quality as the ratio of the result of efforts and the total cost; however, in detail, it considers various factors, such as reliability, maintainability, continuous improvement, corrective actions, and risk management.

Particularly in software engineering, there is a need to estimate the quality through an end-to-end view. It requires the collaboration of various actors, whose roles are mostly independent—business architects, security officers, project managers, and more.

One of the basic steps in designing for quality is to determine quality objectives that describe the requirements for software quality. The software quality should be considered in two areas:

  • How it complies with functional requirements—whether the developed product is actually doing what it is supposed to do
  • How it meets the non-functional requirements—whether it reaches its goals in the correct way

Once the objectives are defined, they can be measured with help of appropriate models and various methods, such as Goal Question Metric (GQM), Balanced Scoreboard (BS), or Practical Software Measurement (PSM).

There is no universal way to measure and control the value of quality in all environments. From the vast list of factors, several apply to SAP systems, and should always be considered when developing new code:

  • Understandability: Both the code and all the documentation should be readable by peers.
  • Conciseness: Not only should the code be kept small, but it also should not process unnecessary data.
  • Consistency: The software should follow the notation conventions present in the system.
  • Maintainability: It should be well documented and not complex (modularized as needed) to allow for future updates.
  • Testability: The software should be written in a way that allows tests to check its correctness and performance.
  • Reliability: The code should behave properly (non-erroneously) in all conditions.
  • Security: It should always consider preventive measures to avoid unauthorized access to important data.

Depending on the level of interaction with the user, there are several additional factors that should be considered:

  • The intuitiveness of the UI 
  • Ease of use
  • Sensibleness of messages, for example, errors
  • Responsiveness of the interface

Although these terms tend to be subjective and, in general, hard to determine in the design phase, they have a major impact on the quality of the software as seen by the end user, and therefore, cannot be neglected.

Designing the UI

The practical approach of building and implementing user interfaces will be shown in Chapter 7, Building User Interfaces, and Chapter 8, Creating Stunning UI5 Interfaces. There are, however, some ground rules and guidelines that should be followed when designing UIs:

  • Use written words: As a rule, the software should be as self-descriptive as possible. Although graphical interfaces use images or any other means of communication, it is still encouraged to give the user appropriate and relevant information with text.
  • Use the user's language: All messages, field names, and texts should be defined in the user’s language (if possible).
  • Use consistent terminology: The same objects should be named the same way throughout the environment.

Creating a user interface for R/3 transactions requires a few decisions to be taken up front. One of the most important decisions is to determine the basic type of application:

  • With screen changes:
    • None, or a few areas on the page
    • Simple, sequential navigation
  • With multiple areas:
    • Few or no changes to the main screen; several areas with lot of interaction between them
    • Provides stable context

Both types have pros and cons, and the choice depends on several criteria—length of processing, the amount of detail required, the user type (such as casual or expert), and the data type (such as a flat structure or volume).

The main goal of the design is to facilitate the user's focus on the current task, while more or less ignoring irrelevant details. In order to do so, use expand and collapse areas and splitters.

When designing R/3 screens in detail, there are several effects—psychological principles—that should be considered to improve the perception of information:

  • The effect of proximity: Items that are close together tend to be grouped in our perception.
  • The effect of similarity: Items of the same size, shape, or quality are likely to be viewed as a group or pattern.
  • The effect of closure: Lines that enclose areas are perceived as units.
  • The effect of continuity: Items arranged into a unified layout are perceived as a unit.

Designing services

Services, in principle, are meant to be consumed by some other part of the system, or even by an external system. It is required to keep in mind that the service may not, and most likely will not, be able to determine where and when it is used. This is why this type of development needs to be particularly robust and reliable, as various areas of the system may depend on its correct functioning.

When designing the services, aside from their scenario-specific implementation needs, there are several things that should be considered in order to minimize upgrade and maintenance costs:

  • Keep services singular-task oriented: Even if the service is supposed to perform many actions on the system, one entry point should perform one consistent end-to-end task (for example, creating a business object, or deleting one). Avoid mixing multiple tasks in a single service call.
  • Avoid direct database manipulation in services: Delegate all logic to the business logic layer.
  • Expect, but check: Do not assume that all the required data is provided by the caller, and always verify its consistency.
  • Provide consistent and explanatory responses, especially when errors occur, so the caller can react accordingly.
  • Keep the service well documented, so it is clear from the consumer's perspective what to expect when calling a particular part of it.
  • If possible, keep the service's interface unchanged: Even small changes to the interface will require adjustments in the consumer's implementation. Utilize optional parameters to keep backward compatibility.

Designing the business logic

The business logic layer is meant to handle business objects and the interaction between them. Decouple it from the service and database layers—it should know as little about the database access or user interaction as possible, yet exchange information with them as needed using a level of abstraction, such as interfaces or base classes. The business logic should focus on transforming and calculating data, leaving other tasks to other layers.

Minimize the complexity of the business logic itself by separating concerns into different areas. Keep the processing, workflow, and business entities separated and loosely coupled. The separation will make the implementation easier to follow, whereas loose coupling will allow modification with a relatively low cost. Then, make sure you avoid the duplication of functionalities in different areas by reusing common parts of business logic.

Identify the consumers of the business layer so that the data can be exposed in the desired way. This will prevent the additional effort of converting data from one format to another. Having consumers in mind, make sure you have prepared not only the functional logic, but also various auxiliary aspects, such as security requirements, validations, exception management, and concurrency—keep them consistent and manage them centrally if possible.

Do not forget about unexpected situations and audits—use logs to store the history of critical changes or errors, yet without business-sensitive data. Ensure that errors in the logging process itself do not affect the normal functionality of the system—keep it as a separate logical unit. Make sure that the logged information is sufficient to track the root causes of any problems.

Designing the database

Designing the database is an essential part of the company's organization. This is a definition that covers data organization according to the model adopted. Designing the database prepares how data is to be linked in tables. It is also necessary to specify which data should be stored. Designing the database provides easier design, expansion, and maintenance of the SAP system. The correct design of the database greatly influences the optimization and quality of the system.

Creating logical and physical models of the database system is the target in designing databases. It is a complicated and complex process due to the use of relational databases in SAP systems. This architecture has its own great advantages, and a proper design simplifies the implementation of the ABAP language.

The logical model contains information on data storage, but there is no information on how it will be stored. This model makes it easier to analyze the structure of an information system that's unrelated to a specific database implementation. A physical data model enables us to analyze the tables, views, and other objects in a database. The physical data design model includes changing the logical database design to a physical layer. The designer uses software systems for this purpose, such as database management systems (DBMSes). A DBMS is system software for creating and managing databases. 

In the SAP system, it is possible to graphically show connections using foreign keys. Using this tool is extremely simple. The user enters the table, for example, through SE11 transactions.


After clicking on the button shown in the following screenshot, the SAP system will display the tool in a separate window:

An example of how to connect to the SFLIGHT table is shown in the following screenshot:

This allows the user to view all the tables that are associated with a foreign key. A double-click on one of the related tables moves the user to this table. Information on the types of relationship between tables is also included here.

Agile principles

In 2001, the Manifesto for Agile Software Development was created. This is an alternative to the cascaded way of generating software. The manifesto describes agile as a philosophy for carrying out various projects, including IT projects. 

The basis of the Agile Manifesto includes four basic principles:

  • Individuals and interactions over processes and tools
  • Working software over comprehensive documentation
  • Customer collaboration over contract negotiation
  • Responding to change over following a plan

The manifesto means that the values described on the left are more important than the ones on the right. It's no coincidence that people are placed first. The success of each project depends on them. If the team has the right skills and a lot of commitment, there is a good chance that each project will be successfully completed. Interactions between team members speed up the work and allow the use of maximally positive aspects of teamwork.

The second point indicates what is most important from the point of view of the software recipient. Even the best documentation cannot replace properly working software. The working end product is the basis for considering whether the project has been successful.

A quick response to changes causes the team to be able to deliver the ideal product to the recipient. It builds a sense of professionalism and can contribute to the expansion of business cooperation with the current investor. Agile is a great project management tool that helps to eliminate the likelihood of an IT project failure.

Work based on agile methodologies takes advantage of an iterative and incremental approach. This means that the team of programmers is focused on the fast, cyclic, and orderly delivery of product elements. The result of this is greater flexibility. This is very important due to the high frequency of changes, along with building solutions. Agile methodologies of software development do not have rigid conditions and assumptions regarding every aspect of the project.

DevOps

DevOps is an organizational culture whose assumption is to combine the work of software development teams and operations teams. DevOps is an innovative approach to software development. The benefits of using this approach are, among others, as follows:

  • Time and cost savings
  • Shortening the time of product implementation
  • Quick changes in products
  • Better-fitting functionalities
  • More accurate verification of correctness
  • Advantage over competitors
  • Better team cooperation

DevOps uses iterative work growth in accordance with agile methodologies. This gives the product recipient the opportunity to quickly read the results of the work. DevOps characterizes a fast and visible change in the company's operations. Teams carry out projects that are more suited to the needs of users.

DevOps assumes smooth communication between technical teams and, at the same time, assumes the following:

  • The product is built from the perspective of the whole.
  • Accurate testing from the initial functionality.
  • Relying on reliable data.
  • Reducing the time of software development.

Continuous delivery

Continuous delivery is a concept of software development. It is based on the assumption that software is created in short intervals of time. This approach allows you to create solutions tailored to the current business needs of recipients. A very important feature of this method of sharing the finished product is the need to accept the possibility of running the software on the main (production) system. The remaining elements of the implementation process are automated. The process is also characterized by a repetitive delivery cycle.

Continuous delivery is similar to the method of continuous implementation, in which software is also produced in short cycles, but with the help of an automatic process in terms of production transfer.

Summary

This chapter describes how the user can organize their daily work and operate in a broader context. We've looked at some ideas for becoming a more attentive developer or architect. At an advanced level, readers will be able to organize several topics within complex projects, including managing stakeholders. At a basic level, the user should be familiar with the daily activities of a project manager or architect and has learned how to integrate with the complex configuration of the project.  

The next chapter will describe the world of modern SAP systems, with a basic outline of the ABAP language and gives you a view on older syntactic data and their equivalents, which are used in modern ABAP systems.

Questions

The following questions will allow you to consolidate the information contained in this chapter:

  1. What are the positive aspects of using agile methods?
  2. What are the principles of the agile manifesto?
  3. What is the difference between a logical model and a physical model when designing a database?
  4. List the possible programming changes in SAP.
  5. What is the motto of design thinking, and why is it coherent with the design thinking methodology?
  6. In which categories does BDUF occur?
  7. What aspects of development impact the quality of the design?
  8. Why should business logic be loosely coupled?
Left arrow icon Right arrow icon
Download code icon Download Code

Key benefits

  • Become adept at building interfaces and explore ABAP tools and techniques
  • Discover the modern functionalities available in the latest version of ABAP
  • Learn the process of creating stunning HTML5 applications using SAPUI5

Description

Advanced Business Application Programming (ABAP) is an established and complex programming language in the IT industry. This book is designed to help you use the latest ABAP techniques and apply legacy constructions using practical examples. You'll start with a quick refresher on language and database concepts, followed by agile techniques for adding custom code to a modern ABAP system. After this, you will get up to speed with the complete ABAP toolset for importing data to and from different environments. Next, you'll learn how to print forms and work with the different ABAP tools for Extensible Markup Language (XML) manipulation. While covering further chapters, you'll gain insights into building stunning UI5 interfaces, in addition to learning how to develop simple apps using the Business Object Processing Framework (BOPF). You will also pick up the technique of handling exceptions and performing testing in ABAP. In the concluding chapters, you can look forward to grasping various techniques for optimizing the performance of programs using a variety of performance analysis tools. By the end of this book, you will have the expertise you need to confidently build maintainable programs in Systems, Applications, and Products (SAP).

Who is this book for?

This book is for developers who want to learn and use ABAP skills to become an industry expert. Familiarity with object-oriented programming concepts is expected.

What you will learn

  • Create stable and error-free ABAP programs
  • Leverage new ABAP concepts including object-oriented programming(OOP) and Model-View-Controller (MVC)
  • Learn to add custom code to your existing SAP program
  • Speed up your ABAP programs by spotting bottlenecks
  • Understand techniques such as performance tuning and optimization
  • Develop modern and beautiful user interfaces (UIs) in an ABAP environment
  • Build multiple classes with any nesting level
Estimated delivery fee Deliver to Mexico

Standard delivery 10 - 13 business days

Mex$149.95

Premium delivery 3 - 6 business days

Mex$299.95
(Includes tracking information)

Product Details

Country selected
Publication date, Length, Edition, Language, ISBN-13
Publication date : May 31, 2019
Length: 548 pages
Edition : 1st
Language : English
ISBN-13 : 9781787288942
Vendor :
SAP
Category :
Languages :
Tools :

What do you get with Print?

Product feature icon Instant access to your digital eBook copy whilst your Print order is Shipped
Product feature icon Paperback book shipped to your preferred address
Product feature icon Download this book in EPUB and PDF formats
Product feature icon Access this title in our online reader with advanced features
Product feature icon DRM FREE - Read whenever, wherever and however you want
Product feature icon AI Assistant (beta) to help accelerate your learning
Estimated delivery fee Deliver to Mexico

Standard delivery 10 - 13 business days

Mex$149.95

Premium delivery 3 - 6 business days

Mex$299.95
(Includes tracking information)

Product Details

Publication date : May 31, 2019
Length: 548 pages
Edition : 1st
Language : English
ISBN-13 : 9781787288942
Vendor :
SAP
Category :
Languages :
Tools :

Packt Subscriptions

See our plans and pricing
Modal Close icon
$19.99 billed monthly
Feature tick icon Unlimited access to Packt's library of 7,000+ practical books and videos
Feature tick icon Constantly refreshed with 50+ new titles a month
Feature tick icon Exclusive Early access to books as they're written
Feature tick icon Solve problems while you work with advanced search and reference features
Feature tick icon Offline reading on the mobile app
Feature tick icon Simple pricing, no contract
$199.99 billed annually
Feature tick icon Unlimited access to Packt's library of 7,000+ practical books and videos
Feature tick icon Constantly refreshed with 50+ new titles a month
Feature tick icon Exclusive Early access to books as they're written
Feature tick icon Solve problems while you work with advanced search and reference features
Feature tick icon Offline reading on the mobile app
Feature tick icon Choose a DRM-free eBook or Video every month to keep
Feature tick icon PLUS own as many other DRM-free eBooks or Videos as you like for just Mex$85 each
Feature tick icon Exclusive print discounts
$279.99 billed in 18 months
Feature tick icon Unlimited access to Packt's library of 7,000+ practical books and videos
Feature tick icon Constantly refreshed with 50+ new titles a month
Feature tick icon Exclusive Early access to books as they're written
Feature tick icon Solve problems while you work with advanced search and reference features
Feature tick icon Offline reading on the mobile app
Feature tick icon Choose a DRM-free eBook or Video every month to keep
Feature tick icon PLUS own as many other DRM-free eBooks or Videos as you like for just Mex$85 each
Feature tick icon Exclusive print discounts

Frequently bought together


Stars icon
Total Mex$ 2,728.97
SAP ABAP Advanced Cookbook
Mex$1128.99
SAP Business Intelligence Quick Start Guide
Mex$799.99
Mastering SAP ABAP
Mex$799.99
Total Mex$ 2,728.97 Stars icon

Table of Contents

18 Chapters
Creating Custom Code Chevron down icon Chevron up icon
The Basic Structure of ABAP Chevron down icon Chevron up icon
Database Access in ABAP Chevron down icon Chevron up icon
Import and Export to Document Formats Chevron down icon Chevron up icon
Exposing Data to Print Forms Chevron down icon Chevron up icon
ABAP and XML Chevron down icon Chevron up icon
Building User Interfaces Chevron down icon Chevron up icon
Creating Stunning UI5 Interfaces Chevron down icon Chevron up icon
Business Object Processing Framework Chevron down icon Chevron up icon
Modification and Customization Techniques Chevron down icon Chevron up icon
Handling Exceptions in ABAP Chevron down icon Chevron up icon
Testing ABAP programs Chevron down icon Chevron up icon
Advanced Techniques in ABAP Objects Chevron down icon Chevron up icon
Integrating SAP with Third-Party Systems Chevron down icon Chevron up icon
The Background Processing of ABAP Programs Chevron down icon Chevron up icon
Performance and Optimization of ABAP Code Chevron down icon Chevron up icon
Assessments Chevron down icon Chevron up icon
Another Book You May Enjoy Chevron down icon Chevron up icon

Customer reviews

Rating distribution
Full star icon Full star icon Full star icon Empty star icon Empty star icon 3
(1 Ratings)
5 star 0%
4 star 0%
3 star 100%
2 star 0%
1 star 0%
Idiot Sep 19, 2021
Full star icon Full star icon Full star icon Empty star icon Empty star icon 3
On the positive side the book is very direct with none of the usual waffle you get in many technical books. Hence you can make progress quickly. This though makes the book a very stilted read with frequent need to groan out loud. E.g. "Creating a domain is very quick and easy. We don't need specialist knowledge." I am a Darlek!This also leads to telling you v, s and t are variable types, and then on the next line defines types of variable as elementary, references, user defined etc. So is a variable type v, s or t or not?It also has the following classic:Type STRING: Like type CType XSTRING: Like type XC is defined earlier but X isn't leaving you searching back to where X might be defined only to find the author has plain forgotten to mention what X is. They also have a chapter called "Database Access in ABAP" which dives straight into your boring old SELECT COL1 FROM TAB1, but totally omits to tell you how connect to the database or what tool to use to connect with!Despite having to decipher much of the book I will skim read as it does contain much that is worth knowing and is one of those books which forces you work things out for yourselves. I find the lack of articulation is appalling but strangely does make you focus on the facts.
Amazon Verified review Amazon