NCo 3.0 Logon

One of the new features implemented to combat the malevolent for RFC client attacks is the interface IDestinationConfiguration. This interface contains method IDestinationConfiguration.GetParameters(string destinationName) which allows .NET programmers to provide their own secure method for storing and retrieving logon information, be it encrypted database, encrypted file, or even LDAP.  There is also a corresponding interface and method to secure NCo 3.0 RFC servers.

Additionally, there is updated functionality to support single sign-on (SSO) and X.509 certificates.

Say Goodbye to Data Containers and Generated Code

In SAP Connector 2.0, working with RFCs required the generation of proxy code via the SAP .NET Connector design-time tool.  This tool would convert the IMPORTING, EXPORTING, CHANGING, and TABLES parameters from the RFC you were calling/serving to .NET representations of the same.  With NCo 3.0 there is no longer any kind of generated code.  Instead of one generated proxy method for each function module, there is one single RfcFunction class, whose Invoke() method dynamically executes every given ABAP function module. Additionally, all ABAP parameters will be represented by the class RfcStructure instead of a dedicated generated class for every structure; All tables will be represented by class RfcTable.  So, instead of hard-coding all of the data and variable bindings statically at design time, NCo 3.0 now handles everything dynamically at runtime.

NCo 3.0 uses SAP’s data dictionary to determine the function interface for the called RFCs.  While this data is cached locally for performance reasons, NCo 3.0 is robust enough to detect changes in RFC interface signatures so your code will still execute if you’ve added, deleted, or changed RFC parameters.  If there arises a situation where the dynamic lookup of RFC interface signature is not wanted, there is also an option to hard code the RFC parameter metadata.

The biggest benefit of NCo 3.0′s new dynamic function handling is that NCo 3.0 no longer has a design-time component.  This releases the Visual Studio version restriction that .NET 2.0 had.  Let me rephrase that, NCo 3.0 will work with any version of Visual Studio you like! The only requirement is that at runtime, a .NET Framework version is installed that is compatible with the NCo 3.0 libraries.

Anxiously Waiting

NCo 3.0 figures to be a much-needed update to a vital SAP integration technology.  I, for one, cannot wait for the new functionality to be generally released.  Once NCo 3.0 is released we’ll be posting blogs highlighting the new features.  We’ll also include helpful information regarding a .NET Connector 2.0 to NCo 3.0 upgrade.  In the meantime, if you have any leave any questions or comments you have regarding NCo 3.0 below.  You may also email me directly at cstasila@dataxstream.com if you’d like to set up a detailed conversation.

Too many cooks spoil the broth

The common meaning extracted from this saying is that too many people working on a single task tend to make a mess of it.  But, what happens when you have too many developers working in a single piece of ABAP code?  That’s right, you get a big mess.  This issue is especially difficult to deal with when there are multiple functional requirements leveraging the same custom code object, form-based user-exit, or function-based user-exit.

While current releases of SAP (those built on SAP NetWeaver 2004s and later) have good built-in handling of enhancements and customizations via implicit and explicit enhancement points and BADIs, there still exists many old-school user-exits.

Multiple Developers; One Code Object

I recently worked on a project where three separate developers were creating three separate interfaces based on the outbound delivery IDOC.  While the development for all three interfaces was occurring at the same time, the go-live date for each of the interfaces were different (we’ll discuss that project management glitch at another time).  Each interface required a separate set of custom fields and, therefore, it’s own IDOC extension.  The problem is there is only one appropriate user-exit in IDOC_OUTPUT_DELVRY and three developers needed to be developing in it at the same time!

How did we solve this problem?

An Object To Call One’s Own

To allow each developer his own development object and transport timeline, I decided to implement a custom multiple-use, filtered BADI inside the SAP user-exit function EXIT_SAPLV56K_002.  Actually, you can implement your own BADI almost anywhere you need alternate logic execution–even custom code!

So you might be saying, “Create my own multi-use, filtered BADI definition? Sounds complicated.” Well, it’s easier than you think!

NOTE: This solution was done on an ECC6 system based on SAP NetWeaver 2004s.  The steps to implement this type of solution in ECC5 (SAP NetWeaver 2004) are very similar.

Create A Custom BADI Definition

1. To create a new enhancement spot definition, use transaction SE18.  I named my enhancement spot Z_EXIT_SAPLV56K_002 because the enhancement spot will be used in user-exit function EXIT_SAPLV56K_002.
2. In the ensuing dialog box, enter a description and choose BAdi Definition for the Technology
3. Next, create a new BADI definition.
4. Specify that the new BADI definition will be multiple use and limited to filtered use. Making the BADI definition multiple use means that each developer can create his or her own BADI implementation.  Each BADI is implemented in its own class.  This promotes code separation and the proper reuse of shared development objects. Making the BADI definition limited to filter use ensures that the BADI implementations are separate and cannot affect every interface using the user-exit.
5. Now, create a new filter. BADI filtering in SAP NetWeaver 2004s is much more powerful than in previous versions of SAP.  Read more about BADI filtering here.
6. The BADI we are defining will be used to populate IDOC extensions.  Each IDOC extension has its own message type (e.g. ZMHL_DESADV, ZQTC_DESADV, ZMHL_SHPORD), therefore the message type of the IDOC being processed is a good value to filter on.  I named my BADI filter EDI_MESTYP. SAP allows for the automatic checking of BADI implementation filter values.  The standard domain EDI_MESTYP has a value range of table EDMSG attached to it.  This is exactly the range of values I want as allowable values, so I configure the BADI filter to automatically check the filter values against dictionary object EDI_MESTYP.
7. Next, create the BADI interface that will be inherited by each implementing class
8. The original user-exti function EXIT_SAPLV56K_002 is executed after each segment is added.  Our BADI will do the same.  Create a new public interface method SEGMENT_ADDED.
9. The BADI we are creating is replicating user-exit function EXIT_SAPLV56K_002.  Here is the function interface for EXIT_SAPLV56K_002: Here is the same data being passed via the interface method.
10. Lastly, the BADI has to be called from the existing user-exit.  I will not cover the steps required for implementing user-exit function EXIT_SAPLV56K_002 here, but once you have the user-exit implemented, add the following code.  This code should be the only logic directly inside the user-exit.  Any data processing logic should be implemented via a BADI implementation:

    DATA: GO_BADI TYPE REF TO Z_EXIT_SAPLV56K_002.
    DATA: L_STR TYPE STRING.
    L_STR = MESSAGE_TYPE.
    
    * Get BADI class based on IDOC message type
    GET BADI GO_BADI
       FILTERS EDI_MESTYP = L_STR.
    
    * Execute SEGMENT_ADDED BADI method
    CALL BADI GO_BADI->SEGMENT_ADDED
       EXPORTING
         MESSAGE_TYPE       = MESSAGE_TYPE
         SEGMENT_NAME       = SEGMENT_NAME
         DATA               = DATA
         TAB_IDOC_REDUCTION = TAB_IDOC_REDUCTION
         FLT_VAL            = MESSAGE_TYPE
       CHANGING
         CONTROL_RECORD_OUT = CONTROL_RECORD_OUT
         IDOC_DATA          = IDOC_DATA[].

We’re done with creating the BADI definition!  Save and activate your work. I bet you’re saying to yourself, “Wow, that was easy!”

BADI Implementation

Implementing the BADI you just created in the steps above is just like implementing any other BADI in SAP, so here are the Cliff Notes version of implementation instructions.

1. Using transaction SE19, create a new enhancement spot implementation for Z_EXIT_SAPLV56K_002.
2. Enter the BADI implementation details.  This particular BADI implementation is for RICEF ID MHL-IO-007, so I added that identification to the BADI implementation name and implementing class name.
3. In the BADI definition, we required each BADI implementation to be filtered on message type. This particular BADI implementation is for message type ZMHL_SHPORD.  Create the filter combination for the BADI implementation.
4. This ensures that the other interfaces using this BADI (ZMHL_DESADV, ZQTC_DESADV) will not execute the code implemented with this BADI.
5. The final steps are to add the code to the SEGMENT_ADDED method just like you would in user-exit function EXIT_SAPLV56K_002.  Once you are done, save and activate your changes!

Summary

As you can see, with a few extra steps, it is possible to have your cake and eat it, too, by create a custom BADI definition that can be used by other developers.  All this talk of food is making me hungry.  Is it lunchtime yet?

What a great idea!  Too bad I hate this suggestion… and it’s all SAP’s fault!!

You see, SAP transaction BD53 just does not play well with others.  My full HRMD_A solution used a custom filter object (transactions BD95 and BD59) and a custom outbound IDOC formatting function module to convert change pointers into IDOCs (transaction BD60).  The dirty little secret of transaction BD53 is that every time you save and update the IDOC reduction in transaction BD53, SAP goes and screws up a bunch of configuration  displaying a message that says “Interface changed for message type <your_message_type>:  Settings reset”

Wait! What!?!

What does that message even mean?  Well, that message is telling you in very cryptic language that SAP has gone and reset the settings in BD59 and BD60 to the SAP standard! So, every time the field reductions were updated, kiss your custom filter assignments and custom IDOC processing function goodbye!

Why couldn’t the message say:

Hey Buddy! You know all that custom configuration you did to get your interface working just so? Well, its gone and you’re going to have to redo it all in the following transactions: BD59 BD60 etc.

I guess SAP is just far too polite.

So, be very cautious when you pair IDOC reduction with custom filter assignments and custom IDOC formatting function modules and be aware that every time the IDOC reduction is updated, you will need to go back in to reconfigure transactions BD59 and BD60.

For more information, see SAP OSS Note 655321

The reduction at segment level (see also Note 301223) was facilitated in order to be able to copy message type HRMD_A. This involved setting the reduction at field level, which was not taken into account in the code because it is not possible to centrally determine which fields are mandatory and which are dependent for all country versions. In addition, for one info type there may several records for different periods of time, which may also cause a problem when you are reducing fields.

So, in essence, field-level reduction isn’t supported for HRMD_A.  The solution supplied in the OSS note suggests creating user-exit code to filter out the unwanted fields.  I already have implemented BADI HRALE00OUTBOUND_IDOC to add some other processing logic (if you’re lucky I’ll cover that logic in this blog, too), so I have a module in which I can place the code. And while the code to loop through an IDOC and clear out all instances of E1P0002-PERID, E1P0002-GBDAT, and E1P0002-GESCH is very easy, I can’t help but think I can make the code more useful.  You see, I hate unitasking code.  I can see it now.  If I take the shortcut path and wrote the unitasking code to clear those 3 fields, the code won’t be in production for more than a month before the requirements change and now there is another field that needs to be filtered out as well.  With unitasking code, I would have to crack open the code, create a transport, unit test, transport to Q, integration test, wait for a transport window, blah, blah, blah.  Ugh!  What a waste of time for a minor change.  We can do better.

I decided to create a multi-tasking module that will work for HRMD_A message types.  The fields to be cleared will be stored in TVARV in the format <SEGMENT>-<FIELD> (e.g. E1P0002-PERID).  That way, whenever the HR functional team wanted to filter out a new field, all they had to do was to update a TVARV variable.

To implement the solution, I created a new method called CLEAR_IDOC_FIELDS in my class implementation for BADI HRALE00OUTBOUND_IDOC.  CLEAR_IDOC_FIELDS has the same method signature as IF_EX_HRALE00OUTBOUND_IDOC~IDOC_DATA_FOR_RECEIVER_MODIFY:

The code is pretty straight forward.  To allow multiple interfaces to coexist in method CLEAR_IDOC_FIELDS, the TVARV variable that stores the fields to clear is in the format ‘ZHR_CLR_’ concatenated with the IDOC message type.

METHOD CLEAR_IDOC_FIELDS .
*----------------------------------------------------------------------*
* Class:     ZCL_IM_HRALE00OUTBOUNDIDOC                                *
* Method:    CLEAR_IDOC_FIELDS                                         *
* Author:    Craig Stasila                                             *
*----------------------------------------------------------------------*

  TYPES: BEGIN OF TY_FILTER,
           TABNAME   TYPE DFIES-TABNAME,
           FIELDNAME TYPE DFIES-FIELDNAME,
           POSITION  TYPE DFIES-POSITION,
           OFFSET    TYPE DFIES-OFFSET,
           LENG      TYPE DFIES-LENG,
        END OF TY_FILTER.

  DATA: WA_FILTER      TYPE TY_FILTER,
        LT_FILTER      TYPE TABLE OF TY_FILTER,
        LS_TABNAME     TYPE DDOBJNAME,
        LS_SAV_TABNAME TYPE DDOBJNAME.

  DATA: LS_NAME   TYPE TVARV-NAME,
        LT_TVARVC TYPE TABLE OF TVARVC,
        WA_TVARVC TYPE TVARVC.

  DATA: LT_DFIES TYPE TABLE OF DFIES,
        WA_DFIES TYPE DFIES.

  DATA: LR_SEGNAM TYPE RANGE OF EDIDD-SEGNAM,
        WR_SEGNAM LIKE LINE OF LR_SEGNAM.

  FIELD-SYMBOLS: <FS> TYPE LINE OF EDIDD_TT.

* Fields to clear are in variable
  CONCATENATE 'ZHR_CLR_' MESTYP INTO LS_NAME.

* Get list of fields to clear from TVARV
  SELECT * FROM TVARVC
    INTO TABLE LT_TVARVC
   WHERE NAME = LS_NAME
     AND TYPE = 'S'.

  CHECK SY-SUBRC = 0.

* Build list of fields to clear
  LOOP AT LT_TVARVC INTO WA_TVARVC.
    CLEAR WA_FILTER.
    SPLIT WA_TVARVC-LOW AT '-' INTO WA_FILTER-TABNAME WA_FILTER-FIELDNAME.
    CHECK SY-SUBRC = 0.

    COLLECT WA_FILTER INTO LT_FILTER.
  ENDLOOP.

  SORT LT_FILTER BY TABNAME.
  CLASS CL_ABAP_CHAR_UTILITIES DEFINITION LOAD.

* Get field offsets
  LOOP AT LT_FILTER INTO WA_FILTER.
    LS_TABNAME = WA_FILTER-TABNAME.

    IF LS_TABNAME NE LS_SAV_TABNAME.

      CALL FUNCTION 'DDIF_NAMETAB_GET'
        EXPORTING
          TABNAME   = LS_TABNAME
        TABLES
          DFIES_TAB = LT_DFIES
        EXCEPTIONS
          NOT_FOUND = 1
          OTHERS    = 2.

      IF SY-SUBRC <> 0.
        CONTINUE.
      ENDIF.

      SORT LT_DFIES BY TABNAME FIELDNAME.

    ENDIF.

    LS_SAV_TABNAME = LS_TABNAME.

    READ TABLE LT_DFIES INTO WA_DFIES
         WITH KEY TABNAME   = WA_FILTER-TABNAME
                  FIELDNAME = WA_FILTER-FIELDNAME
         BINARY SEARCH.

    CHECK SY-SUBRC = 0.

    WA_FILTER-POSITION = WA_DFIES-POSITION.
    WA_FILTER-OFFSET   = WA_DFIES-OFFSET / CL_ABAP_CHAR_UTILITIES=>CHARSIZE.
    WA_FILTER-LENG     = WA_DFIES-LENG.

    MODIFY LT_FILTER FROM WA_FILTER.

* Build segment name range
    IF SY-SUBRC = 0.
      WR_SEGNAM-SIGN   = 'I'.
      WR_SEGNAM-OPTION = 'EQ'.
      WR_SEGNAM-LOW    = WA_FILTER-TABNAME.
      COLLECT WR_SEGNAM INTO LR_SEGNAM.
    ENDIF.
  ENDLOOP.

* Loop at IDOC to clear fields
  LOOP AT IDOC_DATA ASSIGNING <FS>.
    IF <FS>-SEGNAM IN LR_SEGNAM.
      LOOP AT LT_FILTER INTO WA_FILTER WHERE TABNAME = <FS>-SEGNAM.
        CLEAR <FS>-SDATA+WA_FILTER-OFFSET(WA_FILTER-LENG).
      ENDLOOP.
    ENDIF.
  ENDLOOP.
ENDMETHOD.

I also added the following code to IF_EX_HRALE00OUTBOUND_IDOC~IDOC_DATA_FOR_RECEIVER_MODIFY:

* Clear IDOC fields
CALL METHOD ME->CLEAR_IDOC_FIELDS
  EXPORTING
     IDOC_CONTROL = IDOC_CONTROL
     RECEIVER     = RECEIVER
     MESTYP       = IDOC_CONTROL-MESTYP
  CHANGING
     IDOC_DATA    = IDOC_DATA.

Finally, I maintained the following TVARV variable:

That’s all it takes!  Now individual field values can be easily be filtered from outbound HRMD_A IDOCs!.

UPDATE: My colleague informed me that instead of using TVARV, I should continue to use BD53 to manage the IDOC reduction and change my code to look up the field reductions in TBD24.  This would be a great idea, but my full HRMD_A solution uses custom filter objects and a custom IDOC formatting function module.  And BD53 does not play well with these customizations.

To update the runtime cache (called CPA Cache), enter the following URL in your web browser http://<host>:5<sys#>00/CPACache/refresh?mode=full. XI will do the rest of the work for you. After the CPA cache is refreshed, the new RFC meta data reflects the newly added fields.

These other CPA Cache URLs may also be helpful:

CPA Cache Monitoring: http://<host>:5<sys#>00/CPACache
Delta CPA Cache Refresh: http://<host>:5<sys#>00/CPACache/refresh?mode=delta
Full CPA Cache Refresh: http://<host>:5<sys#>00/CPACache/refresh?mode=full

Debugging a web service on the ABAP stack of SAP Web Application Server is a very useful procedure to know.  Here’s how you do it.

Note: This example is for ECC 5.0

1. Locate the web service definition in the HTTP Service Hierarchy.  There are two ways to do this:
   • Option 1: Use transaction WSCONFIG and display the configuration for your web service.  Click on the ICF Details button

   • Option 2: Start transaction SICF. Navigate directly to /sap/bc/srt/rfc/sap for your default host.
2. Regardless of the method used to get to the service definition for your web service enabled function module, you should have it selected as in this example.

3. Next, enable the debugger by selecting the Edit\Debugging\Activate Debugging menu.

   

4. In the ensuing dialog box, confirm the debugging options (the defaults are usually OK).

5. To exercise the debugger, test your web service.  For this example, I will use the SAP WAS web service test tool, but the application calling the web service can be anything as long as it connects with the debugger’s user ID.

6. When the web service is executed, the debugger will start in a new SAPGUI session (make sure you are already logged in via the SAPGUI prior to executing the web service).

7. In the debugger, choose Breakpoints\Breakpoint at\Function Module from the menu to create a new breakpoint.

8. Specify the function module that implements your web service.  In the debugger, press F8 to run to your newly created breakpoint. If the debugger doesn’t get to your breakpoint, the most likely culprit is malformed input XML.  Check the payload of the message to ensure that it conforms to the specifications of the web service.

Once the debugger has started, it is just like debugging any other SAP application. If you have any specific tips or tricks regarding debugging web services, please share them in the comments section of this blog.

My colleague, Steve Park, wrote a two part blog explaining how to turn any ABAP function into a web service.  (Find Part 1 here.  Find Part 2 here.)  But, what happens when you change the function module interface as my friend in the above example did?  SAP does not automatically update the web service interface (called the virtual interface).  You have to manually rectify this conflict.  There are two main options to do this.  Both are quite easy.  Which option you choose depends on how the external systems consuming the web service are handling changes.

Note: The examples listed below are for ECC 5.0.

Option 1: Update Virtual Interface

In cases where all systems consuming the web service will be using the new function/web service interface, when the underlying structure of complex data type changes, or when mandatory fields of a function interface are added or removed, it is best to change web service virtual interface.  The consuming application may have to re-import the WSDL to

In transaction SE80, navigate to the virtual interface for the function whose interface has changed.  Right click on the virtual interface and select “Change”.

SAP will compare the virtual interface to the function interface.  If the interfaces are different, SAP will display the following prompt.

Simply select “Yes” and SAP will update the virtual interface to match the function interface.  Once you have activated your changes, you can check the WSDL to ensure that the function interface changes have been successfully migrated to the web service virtual interface.

Option 2: Create new virtual interface version

In cases where optional fields are added to the existing function interface and/or when some of the web service consumers will NOT need to use the new function interface, it is possible to create a new virtual interface version.  This is possible only in cases where the old virtual interface can still execute the function module with the new interface without causing syntax errors.

In transaction SE80, navigate to the virtual interfaces for the function whose interface has changed.  Right click on the virtual interface node and select “Create”.

In the ensuing dialog, create a new virtual interface version with the endpoint mapped to the  function module.

Now that the virtual interface is created, create a new version of the web service.

Conclusion

Changing the web service virtual interface to match changes in the underlying function module interface is easy. Whether you choose to create a new virtual interface version, or if you choose to update the virtual interface to match the new functional interface, the process is quick and easy.

This blog is a recap of the liveblog of the keynote address of the SAP TechEd 09 conference.  To read in chronological order, start from the bottom and work your way up.

• Craig Stasila: 8:57 am on October 13, 2009

  If you missed anything, check back for the full blog posting at http://www.dataxstream.com/category/sap-consultants-blog/

• Craig Stasila: 8:55 am on October 13, 2009

  Well, that’s it. The keynote speeches are over. I hope you enjoyed following along with the DataXstream’s first foray into liveblogging. Make sure you check back tonight at 11pm EDT (8pm PDT) for our liveblog of the Demo Jam.

• Craig Stasila: 8:53 am on October 13, 2009

  Ray’s parting shot: Even life expectancy is growing exponentially.

• Craig Stasila: 8:52 am on October 13, 2009

  2029: An intimate merger $1,000 of computation = 1,000 times the human brain Reverse engineering of the brain complete Computers pass the Turing test!! Skynet goes online (OK, I made this one up)

• Craig Stasila: 8:48 am on October 13, 2009

  There are only about 800 million bytes in the entire genome and it can be compressed into about 50 million bytes. The brain is made up of about 25 million bytes of data.

• Craig Stasila: 8:45 am on October 13, 2009

  

  The brain is getting reverse-engineered.  Individual brain components (e.g. visual cortex, cerebellum, etc.) are getting reverse engineered by researchers.

• Craig Stasila: 8:44 am on October 13, 2009

  Ray is now on Artificial Intelligence (AI). AI is all around us, but we’re too accustomed to it to notice it.

• Craig Stasila: 8:42 am on October 13, 2009

  They already had this technology in the 80s. I saw Innerspace (http://www.imdb.com/title/tt0093260/usercomments)

• Craig Stasila: 8:41 am on October 13, 2009

  Someday you will have millions or billions of nano-engineered devices coursing through your body keeping you healthy.

• Craig Stasila: 8:40 am on October 13, 2009

  Miniaturization is another exponential trend. “What used to fit in a building now fits in my pocket. What fits in my pocket now will fit inside a cell in a few years”

• Craig Stasila: 8:39 am on October 13, 2009

  Ray is now going over how the exponential growth in technology power is also mirrored by exponential decrease in price. RAM, processing power, human genome decoding, wireless devices. All adhere to the exponential growth curve.

• Craig Stasila: 8:38 am on October 13, 2009

  

  Ray thinks we’re due for a new paradigm shift away from flat integrated circuits.  He’s been talking to Intel about their development of 3D processors.  I’ve not heard of this before, but it sounds very cool.

• Craig Stasila: 8:34 am on October 13, 2009

  

• Craig Stasila: 8:32 am on October 13, 2009

  Some critics say that exponential growth can’t go on forever. Ray counters that by saying that there can be periods of relatively slow advancements, but over time, progress will catch up.

• Craig Stasila: 8:29 am on October 13, 2009

  You may think that he only picked events that matched his theory. But, now he’s showing another graph comparing his viewpoints with 15 others. There is a very high correlation.

• Craig Stasila: 8:27 am on October 13, 2009

  

  From life to now, this chart shows how life and technological advancements have followed a constant, exponential growth.  Both axes are logarithmic.  Very cool, indeed.

• Craig Stasila: 8:24 am on October 13, 2009

  

  As big as a washing machine.  Stevie Wonder bought one.  In 2002, it was still a desktop device.  Now, it is a cell-phone based app.

• Craig Stasila: 8:21 am on October 13, 2009

  It took 10 years to bet the first billion phones in the market. Now 2/3 of the world’s population has them!

• Craig Stasila: 8:20 am on October 13, 2009

  “The tools of disruptive change are in everybody’s hands”

• Craig Stasila: 8:20 am on October 13, 2009

  Technology is a democratizing force. Back in the day, you had to be a recording studio or movie studio to create content. Now a couple of hundred dollars can be used to create great content.

  • Craig Stasila: 8:18 am on October 13, 2009

    Back in the 70s, Ray projected that the two-thousand user ARPAnet would grow into a million user internet in the 90s. Umm. Yeah. I saw that coming, too!

  • Craig Stasila: 8:17 am on October 13, 2009

    Exponential growth even applies to solar energy. Solar energy may be a fringe player now, but Ray sees it growing.

  • Craig Stasila: 8:16 am on October 13, 2009

    This exponential growth is unaffected by any financial or other external pressures.

  • Craig Stasila: 8:15 am on October 13, 2009

    There are many underlaying properties of technology (MIPS, # of bits, # of genomes typed). Regardless of the property, technology follows a smooth exponential growth.

  • Craig Stasila: 8:13 am on October 13, 2009

    Not many pictures right now. Ray is just standing in one place and talking.

  • Craig Stasila: 8:12 am on October 13, 2009

    Only 10 years ago, people barely used search engines.  Now we can’t live without them.

    I’m always amazed how true genius can point out the obvious and make it sound profound.

  • Craig Stasila: 8:10 am on October 13, 2009

    Using the human genome project as an example of exponential growth in technology.

  • Craig Stasila: 8:09 am on October 13, 2009

    And progress is getting faster…

  • Craig Stasila: 8:09 am on October 13, 2009

    Your phone in your pocket is a thousand times more powerful and million times cheaper than a computer from 40 years ago. “What fit in a building 40 years ago, fits in your pocket today”

  • Craig Stasila: 8:08 am on October 13, 2009

    Ray thinks genes are software written in COBOL.

  • Craig Stasila: 8:08 am on October 13, 2009

    Oh Ray! Retalling the story of how Viagra was developed and discovered. Got a few chuckles from the crowd.

  • Craig Stasila: 8:06 am on October 13, 2009

    Ladies & Gentlemen, Ray Kurzweil

  • Craig Stasila: 8:06 am on October 13, 2009

    Vishal is done. Last parting shot: “Timeless Software”

  • Craig Stasila: 8:05 am on October 13, 2009

    

    Vishal’s only slide.  All the rest were just pretty pictures.  Notice the public clouds in the lower right.  SAP is looking to be able to be run on public clouds in the future.  Currently there are development and test systems on public clouds.  Getting production systems on public clouds is coming.

  • Craig Stasila: 8:03 am on October 13, 2009

    

  • Craig Stasila: 8:03 am on October 13, 2009

    “Change is the fundamental dimension in which we all live”

  • Craig Stasila: 8:02 am on October 13, 2009

    Cestbon “listens” for business content on your computer and links to it. You can hop straight from Cestbon to the data in SAP.

  • Craig Stasila: 8:01 am on October 13, 2009

    The presenter is British and doesn’t like the frenchies. Demoing Cestbon–An Outlook integration example.

  • Craig Stasila: 7:59 am on October 13, 2009

    Example #4: Ambient, Real-Time Systems

  • Craig Stasila: 7:59 am on October 13, 2009

    Six blade servers = 1 Nehalem processor.

  • Craig Stasila: 7:58 am on October 13, 2009

    Vishal is talking about optimization across all layers. This relates to hardware manufacturers (memory, processors, blade servers). Modularity is making optimization happen.

  • Craig Stasila: 7:57 am on October 13, 2009

    All the demos were very cool. As a geek, I would love to check out the technology involved in each one.

  • Craig Stasila: 7:57 am on October 13, 2009

    Excel integration now being demoed. The 166 million records can’t be loaded to Excel (for memory reasons). The solution allows the end-user to drill down and get the data from SAP as needed.

  • Craig Stasila: 7:55 am on October 13, 2009

    Business Objects Explorer being demoed. Crunching through 166 million records. The example is trying to be green by reducing paper and electricity.

  • Craig Stasila: 7:55 am on October 13, 2009

    

  • Craig Stasila: 7:53 am on October 13, 2009

    A Dilbert Example! Wow, the pop-culture touchpoints never end!

  • Craig Stasila: 7:52 am on October 13, 2009

    Example #3: Coherent Visualization of Massive Information. Looking at Coherent Modularization.

  • Craig Stasila: 7:50 am on October 13, 2009

    Containers need not only modularity, but also locality of design.

  • Craig Stasila: 7:49 am on October 13, 2009

    Now talking about SOA and its growth. Using it as a basis of modularity and coherence.

  • Craig Stasila: 7:49 am on October 13, 2009

    

    Too many tools on the stage… (ahem)

  • Craig Stasila: 7:47 am on October 13, 2009

    

  • Craig Stasila: 7:46 am on October 13, 2009

    Live tracking of tools being checked in and out of the tool crib.

  • Craig Stasila: 7:45 am on October 13, 2009

    Aircraft mechanics were using SAP, but equipment check-in check-out took too long via SAP GUI.

  • Craig Stasila: 7:43 am on October 13, 2009

    Example #2: Extending Information into Physical Systems. SAP runs on aircraft carriers. I hope they bring one in…

  • Craig Stasila: 7:42 am on October 13, 2009

    

    Google Wave and SAP!  So happy together.

  • Craig Stasila: 7:42 am on October 13, 2009

    Cutting edge technology BCE edition: Rosetta stone. Using the analogy to show that we need to be able to work with others

  • Craig Stasila: 7:38 am on October 13, 2009

    They’re pulling out all the stops!!! Google Wave! Google Wave isn’t complying with the demo. “Thank god that’s Google software and not SAP!” Big crowd laughs.

  • Craig Stasila: 7:37 am on October 13, 2009

    The example is now showing our good-ole familiar SAP GUI showing the timesheet approval process for the contractor timesheet application

  • Craig Stasila: 7:36 am on October 13, 2009

    Containers need to be extended. Either to SAP applications or to other Web 2.0 applications.

  • Craig Stasila: 7:35 am on October 13, 2009

    Another ooh-ahh moment! iPhone timesheet app.

• Craig Stasila: 7:34 am on October 13, 2009

  

  Content separated from applicatons

• Craig Stasila: 7:34 am on October 13, 2009

  Oh Snap!!! Cloud computing!! The example is running through a container. The backend is on Amazon S3

• Craig Stasila: 7:32 am on October 13, 2009

  Example uses managers, contractors, and purchasing department.

• Craig Stasila: 7:32 am on October 13, 2009

  Examples of design thinking, and separation of intent and optimization.

• Craig Stasila: 7:31 am on October 13, 2009

  An example of intent being separated from optimization: A painter does not need a scaffolding to paint a building, the scaffolding optimizes the process.

• Craig Stasila: 7:29 am on October 13, 2009

  

• Craig Stasila: 7:29 am on October 13, 2009

  Next, the intent needs to be separated from the optimization.

• Craig Stasila: 7:28 am on October 13, 2009

  Techies need to start with “design thinking”. Start with end-user in mind. “Start from the screen and work backwords”

• Craig Stasila: 7:27 am on October 13, 2009

  

• Craig Stasila: 7:25 am on October 13, 2009

  Content is independent of containers in long-lived systems

• Craig Stasila: 7:24 am on October 13, 2009

  Looking back at the IT industry, a new, major language emerges about every ten years. While Java will be around for a long time, we’re due for a new major language. SAP thinks that Ruby is the future. Ruby reached 1 million developers faster than any other programming language in history.

• Craig Stasila: 7:22 am on October 13, 2009

  Vishal is teasing Ray Kurzweil’s speach on how the rate of change is increasing. Moore’s law gets a shout out.

• Craig Stasila: 7:22 am on October 13, 2009

  There are hundreds of SAP customers that have been using the software for over 30 years. None have left SAP. Vishal is highlighting the change that the companies underwent and how SAP changed with their customers.

• Craig Stasila: 7:20 am on October 13, 2009

  SAP has been around for 37 years. Have worked with over 85,000 customers, tens of thousands of partners, and tens of millions of users.

• Craig Stasila: 7:19 am on October 13, 2009

  Vishal isn’t going to be focusing on the technology. He’ll be focusing on… “change”. Do you sense a theme?

• Craig Stasila: 7:18 am on October 13, 2009

  Dr. Vishal Sikka, CTO SAP is now on the stage. He is the first of two keynote speakers.

• Craig Stasila: 7:18 am on October 13, 2009

  

  “Welcome to TechEd 2009. You are the star of the show”

• Craig Stasila: 7:16 am on October 13, 2009

  Zia is really pumping up “the community”. The SAP user community is almost 2 million strong now.

• Craig Stasila: 7:16 am on October 13, 2009

  “After the PowerPoints, it’s time for action” SAP wants the BPEs to make it happen! I already feel pumped. Let’s go out there an do this!!!! Oh wait, the Keynote hasn’t even started yet.

• Craig Stasila: 7:14 am on October 13, 2009

  

  • To enter a new market, business process have to change. SAP’s emphasis on Business Process Expert community will pay dividends.

  • Craig Stasila: 7:12 am on October 13, 2009

    Zia is giving an example using Dunder Mifflin as a “well-run company”. Perhaps he hasn’t seen The Office…

  • Craig Stasila: 7:11 am on October 13, 2009

    Zia is telling the conference attendees that we are the agents of change–A very person-centric focus.

  • Craig Stasila: 7:11 am on October 13, 2009

    

  • Craig Stasila: 7:10 am on October 13, 2009

    The world is changing. SAP is changing.

  • Craig Stasila: 7:09 am on October 13, 2009

    Change is constant. Michael Jackson gets a shout-out!

  • Craig Stasila: 7:09 am on October 13, 2009

    On the stage now: Zia Yusuf, Executive Vice President, Global Ecosystem & Partner Group, SAP

  • Craig Stasila: 7:08 am on October 13, 2009

    Inspirational Video: “Clarity is a necessity”.

    and

    SAP: “It’s time for a clear new world”

  • Craig Stasila: 7:06 am on October 13, 2009

    And away we go. Lights down. Check. Ominous Music. Check. Inspiring Opening Video. Check. Can you feel the excitement?

  • Craig Stasila: 7:05 am on October 13, 2009

    

    The crowd is filling in nicely.  Sorry guy-behind-me for accidentally flashing the camera in your face TWICE before I snapped one without the flash.

  • Craig Stasila: 7:03 am on October 13, 2009

    

    Uploaded from backup backup plan.  This is from my iPhone.  Doug, Adam, Tim say “hi”

  • Craig Stasila: 7:00 am on October 13, 2009

    Cell phones off, y’all!

  • Craig Stasila: 6:59 am on October 13, 2009

    

    Pictures will be slow, but here is a teaser

  • Craig Stasila: 6:57 am on October 13, 2009

    Five minutes to go. With me are Tim Cooper, Doug Foss, and our good friend Adam Blum from Grom & Associates

  • Craig Stasila: 6:55 am on October 13, 2009

    

    Here we go!

  • Craig Stasila: 6:49 am on October 13, 2009

    We had an awesome setup to capture pictures from the event, but it relied on the conference WiFi. We’re working on a backup solution now.

  • Craig Stasila: 6:48 am on October 13, 2009

    The conference public WiFi isn’t working. I have to be working on backup off of my Verizon Aircard, so posts may be a little slower.

  • Craig Stasila: 6:47 am on October 13, 2009

    First take from the keynote address. The welcoming music is horrible, but we’ll survive

  • Craig Stasila: 6:45 am on October 13, 2009

    Welcome to the DataXstream Liveblog of the SAP TechEd 09 Conference Keynote address

Head over to live.dataxstream.com on Tuesday, October 13, 2009 to get up to second updates from the show.  We will be getting our liveblog on starting at 8am PDT (that’s 11am for you right-coasters) for the general keynote session.  We’ll also be liveblogging from SAP TechEd 09 Demo Jam at 8pm PDT on Tuesday.  The Demo Jam promises to be a great time, so plan to join us online after you put the kiddies to bed!

This is our first foray into liveblogging.  Hopefully it will go off without too many technical glitches.  We hope you’ll enjoy following the events with us!