Whi is the winner? ALV LIst or ALV Grid OO?

Question

Hi Guys,
Hope you are all well.
My company is still mostly using the ALV List Function Modules when creating reports. Yes, they are using the SLIS pools.
I have written a template program for them to start doing things the OO way. That is to say, using ALV Grid Objects.
We are now thinking of COMPLETELY going over into ALV Grid Objects, but some of us are still arguing which one is best?
The biggest argument is :
Is ALV too "expensive" with regards to using system recources?
Please give me your thoughts as Im all for going for OO, but I would understand if it would make things slower.
Points will be awarded for useful arguments.
tks
Christiaan

Answer 1

SLIS is OLD,  OBSOLETE DINOSAUR technology.
With the new classes you can create new reports really quickly and easily and add all sorts of functionality to them.
There's a small learning curve -- but what ought to appeal to management is that once you get the hang of it you can produce a report in hours (or even minutes) which done in the old way could take a week or more.
These days Human development time is far far more expensive than machine time so there's NO CONTEST. 
The advantages in general of OO are too numerous to list here but if you look at the sample code I've listed here you can see how easy and quicklly you can get an application up and running even if you haven't got my Z_class definition listed in the program (it's a global class now defined with SE24).
With either cl_gui_alv_grid or even easier (if you don't need  edit capability)  the salv_table type class it only takes a few lines to code your program and display the grid.
All you ever now need to do in an alv program is the following.
1) define your data structures
2) use RTTI to generate dynamic field catalog from your data structures
3) create dynamic table
4) populate it
5) display grid.
You should have all the events etc you need such as cell selection etc etc.
Your whole code could be quite small.
For example I've got a generalized Z_cLass for my alv grid.
Now here's a sample program to display program names in the system. When I double click a program SE38 is entered and on exit unlike the standard sap transaction my list is re-displayed where I can choose another program.
Note how small the code is.
You won't be able to copy and run this  program directly as you'll need the Z_class definitions.
In this Z_class there's also functionality for ON  data change, multiple cell selection , toolbar additions etc.
These methods are available to EVERY program calling the class.
If you need the extra functionality using SLIS you have to program it in every time for each individual program.
You can therefore concentrate in your application program on just getting the data and displaying it. All the complicated functionality is in the Z_class.
Incidently using ALV classes can also render the whole idea of classical dynpros with Table controls as also obsolete.
program  zzjimboprogs.
tables : trdirt.
include my_zdata.  "data references to my Z_Class etc.
* Front end to call SE38 Program list
* When you use the search Program facility in SE38
* the system loses the LIST after you choose a program and enter
* transaction SE38
* double click on the Program module you want SE38 to use.
* After exiting SE38 you will return to the list .
types:  begin of s_elements,
  name  type trdirt-name,
  text   type trdirt-text,
end of  s_elements.
data: progname type trdirt-name.
data: wa_elements type s_elements.
selection-screen begin of block one with frame title text-t01.
select-options:  s_prog for trdirt-name obligatory.
selection-screen end of block one.
at selection-screen.
initialization.
   invoker = sy-repid. "Name of calling program for alv class.
start-of-selection.
  create data dref type s_elements.
  assign dref->* to <fs>.
  i_gridtitle = 'Program List'.
  invoker = sy-repid.
  i_zebra = ' '.
  i_edit = 'X'.
  create object z_object
       exporting
                  z_object = z_object
                  cfname = 'CCONTAINER1'.
     assign z_object to <fs1>.
  i_object = <fs1>.
  call method i_object->build_dynamic_structures
  exporting
    my_line = <fs>
    calling_program = invoker
  importing
    dy_table = dy_table
  changing
    it_fldcat = it_fldcat.
perform populate_dynamic_itab
changing dy_table.
perform modify_fldcat.
i_screen = '100'.
i_text = 'Prog List'.
perform display_grid
       using
         i_screen
         i_text
         it_fldcat
         <dyn_table>.
end-of-selection.
form populate_dynamic_itab changing dy_table.
  assign dy_table->* to <dyn_table>.
  create data dy_line like line of <dyn_table>.
  assign dy_line->* to <dyn_wa>.
  select *
        from trdirt
         into  corresponding fields of table <dyn_table>
         where name in s_prog
         and sprsl eq sy-langu.
endform.
form display_grid
using i_screen
     i_text
     field_catalog
     dynamic_table.
call method i_object->display_data
         exporting
           i_gridtitle = i_gridtitle
           i_edit = ' '
           i_zebra = ' '
           i_opt  = ' '
           title_text    = i_text
           program       = invoker
           screen_number = i_screen
           z_object = i_object
            changing
           it_fldcat = field_catalog
           gt_outtab = dynamic_table
           e_ucomm = e_ucomm.
         if e_ucomm  = 'BACK'.
           leave to screen 0.
      else.
        leave program.
      endif.
endform.
form verwerk.
endform.
form refresh.
  call method i_object->refresh_grid.
endform.
form dubbelklik using
        e_row   type lvc_s_row
        e_column type lvc_s_col
        es_row_no type lvc_s_roid.
  read table <dyn_table> index e_row into wa_elements.
progname = wa_elements-name.
    set parameter id 'RID'  field progname.
     call transaction  'SE38'.
  perform refresh.
  row_number-row_id = e_row.
  call method z_object->set_cell
    exporting
            e_column = e_column
            es_row_no = row_number.
endform.
form modify_fldcat.
  col_name it_fldcat 1 'Programe' 25.
  col_name it_fldcat 2 'description' 50.
endform.