Since the TechEd 2008 Las Vegas Hands-On Workshop registration opened up today, I thought it was an excellent opportunity to detail one of the sessions that we have been preparing for the event: COMP277 ABAP Development: Update Your Skills to SAP NetWeaver 7.0.

The core idea of this session remains the same as last year's session by the same title (CD251).  We want to create a hands-on session designed for ABAP developers that already have a pretty good 4.6C level of development skill, but have yet to really begin to take advantage of some of the new techniques and technologies in NetWeaver 7.0.  We do this, not just by covering a series of delta features but also by building an integrated exercise from the data model to the service layer and then finally applying a User Interface to it.

What we struggled with last year was being able to fit everything into the 4 hour time slot, but giving the session again this year provided an interesting opportunity.  First of all, we have recorded eLearning versions of last years CD251 materials:
Update Your ABAP Development Skills to SAP NetWeaver 7.0

This really freed us up this year to streamline the materials and cover a lot of extra ground. We had to make a few sacrifices, so I cut out the chapter on Exception Classes and we turned the two exercises on Central Services Class and Service Classes into Instructor Demos/Walkthroughs only.  However even at trimming out these topics, you can still access them from last year's eLearning.  But this makes room to really expand the Enterprise Services and Web Dynpro ABAP sections of the workshop.

So what are some of the new things we were able to add to the Workshop.  Well first of all the session was able to focus on NetWeaver 7.0 Enhancement Package 1. That means plenty of new functionality around Enterprise Services and Web Dynpro ABAP that you will never have seen before even if you have been working on NetWeaver 7.0.

For the Enterprise Services section of the workshop, you will have the opportunity to use the new SOAMANAGER tool that replaces the old WSADMIN, WSCONFIG and LPCONFIG transactions.

The other exciting new exercises come in the Web Dynpro ABAP section of the workshop.  We kept in the basic WDA exercise for anyone who is still just getting introduced to Web Dynpro ABAP.  However we added some new exercises that showcase some of the new features of WDA in NetWeaver Enhancement Package 1.  We will use an Adobe Flex Component within Web Dynpro by using a Web Dynpro Island.  The Island technology allows Web Dynpro developers to easily integrate technologies from other vendors (like Adobe) without having to learn anything specific  around the other technology.  You will get to see just how easy it is to integrate this animated chart into your Web Dynpro ABAP application.

Finally for Web Dynpro ABAP we will also look at how you can use the Floorplan Manager configuration tool to build complex, real-world Web Dynpro ABAP applications.

The other thing we did with this session, was to leave all the hands-on exercise solutions from last year in the hand-out materials.  So you will get 10 exercises in total, not all of which we will have time to do in the workshop but that gives you something to study when you return home as well. We have a few other surprises in store for this session, but you will have to sign up and attend to learn what they are. 

As someone that has been hanging out in the SAP world for a good number of years now, it has been interesting to see the growth and expansion of the community.  Look at SCN - what was started as a website has grown into a real world community. Nothing provides a better example of that than the explosion of SAP Community Days around the world.

Community Day Australia

This upcomming weekend (Sunday June 15th) I get the opportunity to participate in the latest SAP Community Day.  This one will take place in Australia as part of the Mastering SAP Technologies Conference.  So if you are already planning to attending the conference (which takes place at the Hotel Conrad - Gold Coast, Australia) be sure to join us at the Community Day. If you aren't attending in person, we will still have some opportunities for you to see what took place - but more on that in a minute.

Although Mark Finnnern won't be able to be in attendance for this particular Community Day, we wanted to keep close to the Unconference Spirt that Mark has implanted so well into the TechEd Community Days.  So after a short kick off, we will go right into the Speed Networking that Mark is so famous for.  This will give people a chance to get to know each other and hopefully spark some nice, on the spot Birds of a Feather session ideas.

Birds of a Feather

We also already have 3 Birds of a Feather sessions submitted via the WIKI. Check out the page here for more details. But don't worry, there is room for several more BOF.  If you have an idea please add it to the WIKI.  However we will have a whiteboard at the the Community Day so in the best spirit of Unconference we can add sessions right up until the last minute. 

How you can join in (without having to fly to Australia)

Now we all obviously can't drop what we are doing and hop down to Australia for the weekend to join into the fun of the Community Day. However we don't want to leave out community members in other parts of the world.  To that end I'm going to try a couple of different things to share the Community Day Australia experience with the world.

First I'm going to take plenty of pictures.  I will get those pictures uploaded to Flickr just as soon as I can.  You will be able to find them in the SDN and BPX Flickr Groups.

Next I will do my best to live blog the event via Twitter. Now given the stability of Twitter lately, the chances that the website will actually be up is not a given. But with a little luck, Twitter will hold out over the weekend.  You can follow my twitter stream here. I will also start an EventTrack item for the Community Day once I arrive.

Finally, I was very impressed by the quality of the SAP Developer Challange Demo Jam 2008 Webcast from the developer challenge demo jam the other night. It has encouraged me to give Ustream a try.  I'm going to bring my camera equipment and will try to setup something that can run unmanned as I will be busy participating in the day and not running the camera. Given the time difference to Australia and the fact that the event takes place on Sunday, I'm not sure how many viewers I will get.  Then again, I'm not sure I can even get the thing running on site. So this avenue is probably the most questionable. If I can get everything setup and the quality of the stream is good, I will post the URL to this blog on Saturday or Sunday morning.  At the least, I can record the video and post it at a later date.

Update: Sunday June 15th.

We will live stream the Community Day on Kyte.tv in the SDN Channel:

http://www.kyte.tv/ch/9638-sap-developer-network

If the title of this blog sounds familiar, then chances are good that you have attended session CD251 at one of the TechEds this year. This session focuses on introducing new development technologies (Persistent Objects, Enterprise Services, Model Classes, Web Dynpro ABAP), but in a connected, practical example. This way the session could touch on cross-technology topics like transactionality, cross-component usage, and model re-use. The session was designed for developers who have a good 4.6C level of ABAP development skills, but who want to update those skills to the SAP NetWeaver 7.0 world.

So "delta training" for ABAP developers has long been an interest of mine.  I have ABAP 46C to 640 Delta Training in the past and wrote something Next Generation ABAP Development Book as well. I also thought it would make a useful TechEd session - leading to the creation of CD251.  Now I would like to extend much of that same content to a wider audience by offering it as an on-line E-Learning.

There are some obvious advantages to attending a session at TechEd.  You get to participate in the hands-on exercises directly and you can ask questions of your lab partner and of the instructors.  However the main disadvantage is the time limit.  So even if you had a chance to attend CD251, I encourage you to have a look at this E-Learning.  Not restricted by the 4 hour time frame, I was able to dig deeper into certain topics.

This series I did was designed to provide different content than the TechEd session it was built upon; however don't forget that many sessions during TechEd were recorded and are available on the Virtual TechEd 07 page within SDN.

Eventually each chapter of this E-Learning will be added to the SDN E-Learning Catalog.  Once the videos are hosted on SDN I will place links to them here as well.  Until that time, I offer them in a downloadable format.

Introduction
75Mb 1 hour 13 minutes
View Link

Chapter 1 - Persistent Objects
62Mb 1 hour 9 minutes
View Link

Chapter 2 - Class Based Exceptions
27Mb 35 minutes
View Link

Chapter 3 - Advanced ABAP
50Mb 59 minutes
View Link

Chapter 4 - Enterprise Services
40Mb 45 minutes
View Link

Chapter 5 - Web Dynpro ABAP
106Mb 1 hour 50 minutes
View Link

Introduction

Last week Alvaro Tejada (Blag) posted a The specified item was not found.. Well I got all caught up in the fun challenge and now here are the results for your downloading pleasure.

What Blag wanted to do was simply flip an existing Bitmap that he was reading out of the BDS (Business Document Store).  The problem that he was facing is that there is no easy method for doing this in ABAP. He tried just reversing the Byte Stream, but quickly found out that this corrupted the image.  A bitmap isn't just stored as a simple data stream - it has header information and a complex structure that must be taken into consideration when doing any manipulations on it.

But many other languages have simple processes for working with Bitmaps - what was wrong with ABAP.  Well these other languages just have libraries that have already been created that abstract the actual process of working with the Bitmap.  These libraries directly expose attributes like the bitmap height and width, so that programmers don't have to know the detailed structure of the Bitmap header.  They also usually have methods to allow for basic manipulation of the Bitmap.

To my best knowledge, no one in ABAP had created such a library.  So while it was perfectly possible to manipulate the Bitmap at a low level in ABAP, it was more tedious than necessarily because it didn't have one of these helper libraries.  Historically ABAP has been all about processing business data, so it hasn't been a big issue that you couldn't flip bitmaps or convert them to grey scale.  But with ABAP being used increasingly for forms output and web pages, this is functionality that might be useful from time to time.  So I decided to take the rough solution that I built for Blag and turn it into a reusable bitmap class.

Bitmap Processing

Before we get into the actual solution of the ABAP Bitmap Library, I thought I would cover some basics of the processing that is going on within the library.  If you are interested in how Bitmaps are stored and processed then keep reading this section. If you really couldn't care less and just want to get started using the library, then skip down to the next section (after all the purpose of creating this library was so people wouldn't have to care how a bitmap works internally).

When I started looking into Blag's problem, I had no real experience with how bitmaps are structured.  So I started my investigation via the internet.  I found lots of good articles on Bitmaps, but probably the best summary of information I found was on Wikipedia.

The linked Wikipedia article does an excellent job of describing the inner layout of the Bitmap - how you have a section for the header information and then a separate section for the data.  It also describes for each pixel is stored.  The color of the pixel (in 24 bits per pixel) is stored as three separate integers - one each for Red, Green, and Blue.  It is important to understand that you can't just manipulate data within the Bitmap at the byte level, but instead the pixel level so you can keep from altering the RGB color as you move bytes around.

The second complexity is that bitmaps are not stored top to bottom within the data area.  Instead the first visible row of data on the screen is stored as the list "line" in the bitmap data area.  All the data is also stored together in a single stream. Therefore for easier processing you generally break the stream down by horizontal row. But because processing is easier if divisible by 4, null-bytes are added to the end of the line to pad the file.  All of these aspects are especially important when trying to rotate a bitmap.

The final complexity that I faced in my processing was that much of the data in the bitmap header was stored as either 2 or 4 byte DWORDs. This meant that I couldn't just cast these byte values into ABAP Integers.  Instead I had to create small macros to change the byte order.

The ABAP Bitmap Library

OK, enough of the deep stuff.  Now it is time to see just how easy we can make working with Bitmaps in ABAP.  For that purpose I have created a Class called ZCL_ABAP_BITMAP.

As you can see there are plenty of methods in this class.  Let's start with the Static methods.  You see the class is marked as Private Instantiation only, therefore the static methods are the only way to create an instance of the class.

Each of the static methods is a path to provide the bitmap source and return an instance of the class.  We have the basic create from bitmap methods like CREATE_FROM_BYTESTEAM (type XSTRING) and CREATE_FROM_BYTETABLE (type standard table of line 255 x). These are generic and support reading the bitmap content from outside the library - providing flexibility.

But I also wanted to make it easy to read the bitmap content from the most common locations. Therefore we have the CREATE_FROM_MIME_REPOSITORY, CREATE_FROM_BDS_GRAPHIC, and CREATE_FROM_FRONTEND_UPLOAD methods. These methods contain the necessarily logic to process images from their various sources.  But many of these sources also support graphic formats other than bitmaps.  Internally this class must process everything in bitmaps, but I wanted to support the conversion from other popular formats (like GIFs and JPEGs).  Luckily this functionality already is provided by the IGS and I just reused the existing class, CL_IGS_IMAGE_CONVERTER, to do the processing.

The method CREATE_FROM_EXT_FORMAT provides the logic to interact with the IGS and perform the conversion.  It supports conversions to/from JPEG, TIFF, PNG, GIF, and of course Bitmap. There is one common static method than can be used inside the class and by calling programs named CHECK_IGS_SETUP to test to see if the IGS is present, configured and of a late enough release level to support image conversion.  That way if there is any problem with the IGS setup, exceptions can be thrown gracefully and the alternative image types simply aren't supported.

There are also similar methods for outputting the bitmap image - including outbound format conversion and Zip compression- GET_CONTENT_ZIP_BYTESTREAM, GET_CONTENT_BYTESTREAM, GET_CONTENT_EXT_FORMAT, and GET_CONTENT_BYTETABLE.

Next are the methods that help to display the bitmap in different environments.  First is the method DISPLAY_IN_SAPGUI.  This is designed for Classic Dynpro. You can pass in the hosting container element - or if you want the ZCL_ABAP_BITMAP to control the image, it can provide its own Dialog Container Control.  This was very helpful for debugging, because it makes it possible to test the class and display the results without any wrapper program. 

The other display helper method is the PUSH_CONTENT_INTO_ICM_CACHE.  This places the content for the image into the ICM content cache for the specified amount of time and returns the unique URL to this cached object.  This is a great way to manipulate the image, and then display it in an image element using BSP or Web Dynpro ABAP without ever having to permanently store the image.

We have one method, GET_HEADER_INFORMATION, that reads the Bitmap header and returns all the most important information (like width, height, color depth, etc). 

Finally we have the really fun methods: the transformations. These are the methods that directly manipulate the Bitmap Content.  The names of the methods do a rather good job of describing exactly what they do to the image: TRANSFORM_ROTATE_CLOCKWISE, TRANSFORM_ROTATE_COUNTER_CLOCK, TRANSFORM_FLIP, TRANSFORM_MIRROR, TRANSFORM_INVERSION, TRANSFORM_GREYSCALE.

Test Applications

No library would really be complete without some nice test and demo applications. For this purpose I built two different test suites.  The first is classic dynpro based.  The application lets you load images from the Frontend.  It displays the results using the DISPLAY_IN_SAPGUI method and has buttons to activate the Transformations.

Just to demonstrate how (hopefully) easy this class is to use, here is the source code of the classic dynpro test application:

REPORT zabap_bitmap_test.

DATA bitmap TYPE REF TO zcl_abap_bitmap.
DATA custom_container TYPE REF TO cl_gui_custom_container.
DATA okcode TYPE syucomm.

START-OF-SELECTION.

CALL SCREEN 100.
*&---------------------------------------------------------------------*
*& Module STATUS_0100 OUTPUT
*&---------------------------------------------------------------------*
* text
*----------------------------------------------------------------------*
MODULE status_0100 OUTPUT.
SET PF-STATUS 'MAIN'.
SET TITLEBAR '100'.
IF custom_container IS INITIAL.
CREATE OBJECT custom_container
EXPORTING
container_name = 'CUSTOM_CONTAINER'.
ENDIF.

IF bitmap IS INITIAL.
TRY.
bitmap = zcl_abap_bitmap=>create_from_frontend_upload( ).
bitmap->display_in_sapgui(
i_container = custom_container ).
CATCH zcx_abap_bitmap .
ENDTRY.
ENDIF.
ENDMODULE. " STATUS_0100 OUTPUT
*&---------------------------------------------------------------------*
*& Module USER_COMMAND_0100 INPUT
*&---------------------------------------------------------------------*
* text
*----------------------------------------------------------------------*
MODULE user_command_0100 INPUT.
TRY.
CASE okcode.
WHEN 'BACK' OR 'CANCEL' OR 'EXIT'.
LEAVE PROGRAM.
WHEN 'NEW'.
bitmap->free( ).
CLEAR bitmap.
WHEN 'CLOCK'.
bitmap->transform_rotate_clockwise( ).
bitmap->refresh_sapgui_display( ).
WHEN 'COUNTER'.
bitmap->transform_rotate_counter_clock( ).
bitmap->refresh_sapgui_display( ).
WHEN 'GRAY'.
bitmap->transform_greyscale( ).
bitmap->refresh_sapgui_display( ).
WHEN 'INVERSE'.
bitmap->transform_inversion( ).
bitmap->refresh_sapgui_display( ).
WHEN 'MIRROR'.
bitmap->transform_mirror( ).
bitmap->refresh_sapgui_display( ).
WHEN 'FLIP'.
bitmap->transform_flip( ).
bitmap->refresh_sapgui_display( ).
ENDCASE.
CATCH zcx_abap_bitmap .
CLEAR okcode.
ENDTRY.
CLEAR okcode.
ENDMODULE. " USER_COMMAND_0100 INPUT

But the more full featured test application is actually the Web Dynpro ABAP version.  It has all the same functionality to load existing images, display them, and perform transformations:

However it also has functionality to export the manipulated image in several formats (as well as zip compression):

Downloads

Now for the downloads.  I have broken them out into separate parts and pieces so people can grab just what they need.

• Just the Class (and support exception class) in SAPLink format
• The Dynpro Test application in SAPLink format
• The Web Dynpro ABAP Test application in SAPLink format
• All the objects together in SAPLink format
• All the objects together in a Transport file (good for importing the entire package- ZBITMAP_SERVICES - into a NSP system).

I bet Rich Heilman didn’t know what he was getting himself into.  You see, writing a book is a crazy amount of work; all of which takes place after you finish your normal work day. It has a negative effect on your family, your health and your general well being. I, on the other hand, have absolutely no excuse.  I had been down this path once before and I knew exactly what I was getting into.  So the question you might be asking is, “Why an ABAP Book?” 

There are already many good ABAP books offered by SAP Press.  Our decision to add to this collection is by no means a statement against the quality of the work of those that came before us.  Just to be included in the same small group of authors as the likes of Horst Keller is a great honor.    The story surrounding the birth of this book and the reasons for both Rich and myself to undertake this endeavor are central to the very reason of why most readers of this blog should even care that another ABAP book is available.

The Incubation Process

The story of how this book got started dates back two years to June of 2005.  I was still working at an SAP customer – Kimball International.  We were in the middle of our ERP system upgrade from R/3 4.6C to SAP ERP 2004 (NetWeaver 2004).  The central concern on my mind was how to help update the team’s development skills in order to take advantage of all the new capabilities in NetWeaver.  ABAP is amazingly backwards compatible.  That is both one of its greatest blessings and curses.  This is so important to ABAP’s continued existence because it allows companies, not the least of which being SAP itself, to continue to leverage its existing investments in business applications.  No one talks about massive rewrites to update existing applications so that they can simply survive an upgrade.  As ABAP developers we have come to expect a high degree of backwards compatibility.   

SAP has only been able to make major changes to ABAP syntax at critical points, like the introduction of Object Orientation or conversion to Unicode.  For the most part, developers working on the latest releases can continue to code exactly as they have always done utilizing syntax and techniques that date back to a time before most currently popular programming languages even existed.. They can still create List based output in dialog modules.  They never have to write a single line of OO code.  However in doing so, they cut themselves off from so many of the possibilities that the new ABAP tools offer and limit the value they bring to their employer.  This isn’t even about just making the shift to ABAP Objects – this is about thinking about application design and structure in new ways.  This is about better separation of layers of your application so that they are easier to maintain.  This is about making sure that the code you write today can be service enabled. 

So these were the thoughts that were keeping me awake late at night.  How best could I teach existing ABAP developers the new development tools as well as the new design approaches?   It just so happens that at the time that this problem was keeping me awake at night, I was also in the processing of working with Brian McKellar on the SAP Press book, Advanced BSP Programming.  I was excited about that project and already thinking ahead to future projects.  So it was late one night that the two thoughts crossed paths.  I lay in bed and envisioned a book that would be rooted in a rich, real-world example – a single example project that would run through the entire book.  This way in addition to explaining new technologies, like persistent objects and Web Dynpro, in a vacuum, readers could also see how the planning and design phases of a project have evolved as well. 

Readers could explore the thought processes that go into building around the ideas of Model View Controller and planning ahead for Enterprise Services instead of tacking them onto existing developments.  They would also see how different technologies interact with one another.   I was so excited by the idea that I got out of bed at 3:00AM and scratched down a rough table of contents on a piece of paper.  But as fate would have it, I didn’t immediately jump into this project and that piece of paper remained untouched on my desk for sometime.

SDN Days

Fast forward one year to August of 2006. My focused had shifted quite a bit.  I now worked for SAP as a NetWeaver Product Manager.  I still was kept up late at night by thoughts of how best to help update ABAP developer’s skills sets.  Now, thought, instead of worrying about how to help 3 or 4 developers make the transition I was concerned about the entire ABAP development community.  I hadn’t had time to even work on the original idea that spawned the table of contents up to this point.   SDN days, the community sponsored day of sessions at the beginning of TechEd, was approaching and I really wanted to use this opportunity to return to that idea.   I wanted to create a session that would spark discussion around these very topics.  I also didn’t want to present this session alone.  I wanted it to be firmly rooted in real world experiences – but not just my experiences. 

So I created a blog, explained my proposal and asked the community if anyone was interested in co-presenting such a session with me.   First to come forward was Rich Heilman.  Anyone who claims to spend any time on SDN and doesn’t know Rich obviously isn’t telling you the truth.  This was wonderful.  Rich is Mr. ABAP and although I didn’t personally know him all that well I assumed (correctly) that anyone that active on SDN must be a good person to work with.  Now a 45 minute presentation isn’t really enough time to cover all the topics that I jotted down that night in my table of contents and that Rich had added to the mix..  Even so, we were able to cover a lot of good material in our short session.  Just as important however might be one other thing that we were able to reuse from my original sleepless night – the session title.  We called our session – Next Generation ABAP Development.   

A few weeks after TechEd, Rich was approached by SAP Press.  They had seen the abstracts from SDN Days and they were particularly attracted to the session titled – Next Generation ABAP Development.  They asked Rich if he was interested in turning the session into a book.  Rich came to me and since we had collaborated on the SDN Days session, he wanted to know if I was interested in turning the session into a book.  I was delighted that the original idea had come full circle. 

Book Content

So what we ended up with was something amazingly close to the original table of contents. We adjusted it some to include some of the very good ideas that Rich had brought to the table during our work on the SDN Days session.    But more important than the technical topics covered, Rich and I really wanted to take our 20+ years of combined ABAP development experience from a customer’s standpoint and bottle it up in an easy to digest format.    The structure of this book reflects the workflow of a development project. The first half of the book focuses on creating the data and application logic layers and then service-enabling them. The second half of the book focuses on creating the user interface layers.

Chapter 1: Workbench Tools and Package Hierarchy Before we begin our project, we will review some of the changes and enhancements to the ABAP Workbench. In this chapter, we will look at the new ABAP Editor, the Refactoring Assistant, the new development tools perspectives in transaction SE80, and the new debugger. Lastly, we will create the packages and package hierarchies for the project.

Chapter 2: Data Dictionary Objects In this chapter, we will model the data relationships and build the corresponding Data Dictionary objects. We’ll study the tools for generating table maintenance, creating lock objects, and utilizing foreign keys. We’ll also explore the new technology of strings and binary strings within transparent tables.

Chapter 3: Data Persistence Layer In this chapter, we’ll build the logic that controls the persistence of application data. We’ll start by generating persistent object classes for the underlying data dictionary tables created in Chapter 2. Then, we’ll build a set of business object classes to hide the inner technical details of the Persistent Objects. In addition to the new technology of Persistent Objects, we’ll show you how to use ZIP compression on large strings.

Chapter 4: Consuming a Web Service Not all project data will originate from one centralized system. For example, in the sample application, some data will be stored in a legacy system and accessed remotely via Web Services. In this chapter, we will examine the process for generating a Web Service proxy object and integrating this proxy into the data persistence layer.

Chapter 5: Shared Memory Objects After some analysis, it will become apparent that the sample application has some static data that will be accessed repeatedly. In this chapter, we will describe how you can provide the best performance by structuring the data access for this type of data into an ABAP Shared Memory Object.

Chapter 6: Model Class In this chapter, we will begin to implement the core application logic, which is implemented as a Model Class. This same class will later be used as the business logic layer of all the UI technology examples. This chapter focuses primarily on object-oriented design patterns while introducing techniques for sending email and manipulating XML.

Chapter 7: ABAP and SAP NetWeaver Master Data Management This is the first of our “What-If” chapters. Here, we look at an alternative approach to the project where our master data is modeled and stored in SAP NetWeaver Master Data Management (SAP NetWeaver MDM), instead of the local Data Dictionary. This chapter will focus on how we would alter the data persistence layer to read this data via the SAP NetWeaver MDM ABAP application programming interface (API) instead of directly from the local database.

Chapter 8: ABAP Unit Before building any additional objects on top of the existing application logic, this is a good point in the project to unit test what has been completed. In this chapter, we’ll look at the built-in unit test tool, ABAP Unit, and examine how unit test classes can be integrated directly into the model class.

Chapter 9: Exposing a Model as a Web Service Not all the logic from the sample model class will be exposed via a user interface. Instead, some of the data was designed to be exposed as a Web Service so that it can be accessible to external systems as well. In this chapter, we’ll examine the Inside-Out approach for generating Web Services.

Chapter 10: Exposing a Model as a Web Service Using SAP Net-Weaver Process Integration This is the second of the two “What-If” chapters. In the previous chapter, we looked at the Inside-Out approach of generating Web Services via remote enabled function modules. In this chapter, we’ll look at the world of Enterprise Service Modeling. We’ll show you how the same logic could be modeled in SAP NetWeaver Process Integration (SAP NetWeaver PI) and then implemented as a server proxy in ABAP using the Outside-In approach. 

Chapter 11: Classic Dynpro UI/ALV Object Model In this chapter, we turn our attention to user interface logic. In the sample application requirements, there are a group of internal users who are full time SAP GUI users and who need powerful reporting tools. Therefore, we’ll learn how to build a classic Dynpro screen on top of the Model View Controller (MVC), which uses the ALV Object Model for its reporting output.

Chapter 12: Web Dynpro ABAP Since most of the sample application’s users are not SAP GUI users, we’ll look at how you can build a Web Dynpro user interface for these users. This chapter will focus on real world Web Dynpro applications that contain multiple component usages, ALV integration, and table popins.

Chapter 13: Business Server Pages The next user interface use case is for an Internet-facing application. This user interface needs to be highly customized and stateless for scalability. Therefore, in this chapter, we will use Business Server Pages (BSP) in order to show the flexibility they provide for highly customized style sheets and AJAX integration.

Chapter 14: Adobe Forms Adobe Forms technology offers an interesting paper-like alternative user interface. In this chapter, we’ll look at each of the major types of Adobe Forms—print forms, online interactive forms, and offline interactive forms.

Chapter 15: SAP NetWeaver Portal Although we have focused on ABAP as the primary development environment until now, it is also important to see how some of the SAP NetWeaver Portal technologies can be used with the best aspects of ABAP. In this chapter, we’ll explore how to wrap each of our user interface examples in iViews within the SAP NetWeaver Portal and how portal eventing can be used for cross iView communication. We’ll also look at how we can use SAP NetWeaver Visual Composer to build code-free applications that consume ABAP services.

Chapter 16: RSS Feed Using an ICF Service Node In this chapter, we’ll examine how Internet Communication Framework (ICF) Service Nodes can be combined with XML processing in ABAP to produce interesting Web 2.0 type projects. As the final example of the book, we’ll implement an RSS Feed using these technologies.

Chapter 17: The Closing In the final chapter we will look back on the completed project and re-view the most important points of what has been discussed.

Closing

After months of work and a journey of nearly two years, our little project is finally ready to go out into the world on its own.  We hope that we have created a book that ABAP developers will find useful as well as easily approachable.  Rich and I are both very passionate about ABAP in general and we have poured that passion into this book. We hope you enjoy.