Answers in this category:
What is the difference between END and CANCEL?
Is there a way to pass login nformation to APPX?
Is there anyway to force the appx client to open in a specific size window?
Graphic resource(s) not being displays (red X)?
What does the check mark on the Java client do?
Checking the APPX registration number.
Is the date/time a user signs in and out of APPX kept?
Pasting data into a text field in APPX.
How do you set up keystroke playback (keyboard scripting)?
How do you turn off dynamic indexing in APPX?
What is dynamic indexing?
What are the maximum file size(s) in APPX?
How to determining who has a file open (Unix OS).
No Beep on Errors and Warnings
What are the command line options?
Diagnose SUBR --- SEND FILE TO CLIENT problems
More information about why the --- SEND FILE TO CLIENT subroutine failed?
Scan hangs!
Am I running Java Client?
What's "appx.exe -f=" mean?
How to recover from record "locked".
How to determine what are my environment variable are?
APPX/Client startup problems
Slow APPX Login Time
Auto-update Java Client version
How are usage locks allocated?
Appx/Client timeout duration
Action Logs don't generate
General AppxODBC recovery
Appx-Client scrambled display on Startup Login
How to turn off full selection (highlighted) of text fields in change mode.
What kind of code does APPX generate?
Is there any "standard" screen size as it relates to the GUI interface?
Is there any way to increase the screen response time using the APPX client.
Several commands which I can RUN successfully on our HP-UX 11.0 system, do not work when invoked on a Redhat Linux 9 system.
Diagnosing Appx/Client problems
home
Performance Issues
Memory corruption after calling an external subroutine.
How do we use the routine --- READ FROM CLIENT CLIPBOARD?
Asql Errors
Would adding "-session" to a command line cause APPX to respond to any input screens with an END?
What does error "Appx startup failed because of the following startup error: 34" mean?
How can i tell from the ILF code what screen size user has?
I can get the PID number from the usage file, but where can I get the port number?
What does -session flag do when added to a command line?
Previous Activity key
Does APPX run on Mac OS X Server?
Performance issues when using a RDBMS
Appx and new Daylight Savings time
What does "Corrupt lfb list" C-Assert mean?
How to uninstall AppxODBC.

END returns to the previous RELATED process level and continues operation. CANCEL returns to the DETACHED process level and continues operation. This may sound very similar but are actually quite different. A simplified answer is that END terminates the current process and goes back one level, while CANCEL terminates the current process and may go back more than one level.

For example, when a report is selected from a menu it may start a job that has several steps. It may contain an input that asks for a date range, a query that will select and sort records based on that date range, a disposition to direct the report to the desired device, and an output that actually creates the report. In this case the menu is the parent of the job, which is considered DETACHED since creating the report is not dependent on any information received from the menu. The input, query, disposition, and output steps of the job are RELATED, since the task depends on successful completion of each step.

If you are on the disposition screen and you decide that you want to terminate the report you must decide whether to press END or CANCEL. If END is pressed, then the disposition is terminated and control is returned to the RELATED level, or the job, and processing continues. In this case the output would then run, creating the report that you thought you were exiting. On the other hand, if CANCEL is selected the disposition is terminated and control is returned to the DETACHED level, or the menu. This skips any remaining RELATED steps of the job, giving the desired results.

A) If you want to run with more Appx screen rows and columns, start the client with the following options:

AppxDesktopClient -rows=28 -cols=110

This will launch the client that has been sized to allow this number of application Rows and Columns. Similar to running a non-24x80 xterm window and running Appx.

B) If you want to launch the client with a different screen font size, that controls the overall size and magnification of the Appx Client screen. You can do that with a different startup option:

AppxDesktopClient -initialFontSize=14 &

This will launch the client using that base font size instead of the default it is currently using. The base font size is used by the client to set the overall Appx client window size and also how to scale all the screens it presents. The screens will be 'zoomed' to fill the Appx screen. Similar to starting to client today and dragging out the border to a different size.

 
                 APPX_DISABLE_DYNAKEYS=1

Bruce Johnston 15, '04:
You can also create a dynamic index via ILF (at least from 4.1 through 4.2.2).
Given two fields, DGA FDRFEPR FED WASTE PRE and DGA FDRFEPR FED WASTE SUF, if I want to sort by the PRE and then by the SUF, both in ascending order, I use the following...
      PASS     DGA FDRFEPR FED WASTE PRE      FIELD            SHARE? N         
      PASS     DGA FDRFEPR FED WASTE SUF      FIELD            SHARE? N         
      CALL         ,PI_DYNA_BLD               RESIDENT? N  END? N  FAIL 0       
If I wanted to change the default order of any to reverse it I'd simply double up its PASS command as in...
      PASS     DGA FDRFEPR FED WASTE PRE      FIELD            SHARE? N         
      PASS     DGA FDRFEPR FED WASTE SUF      FIELD            SHARE? N         
      PASS     DGA FDRFEPR FED WASTE SUF      FIELD            SHARE? N         
      CALL         ,PI_DYNA_BLD               RESIDENT? N  END? N  FAIL 0       
which gives the records sorted by the PRE in ascending order followed by the SUF
in descending order.

I believe that it was Korry who first told me this.

The maximum file size is dependent on the release of APPX and the operating
system.  The following chart shows the maximum file sizes allowed for each
operating system based on the release level of APPX.

              Maximum file sizes by release

Release   Windows    AIX       Solaris   HP/UX     Linux
=======   ========   =======   =======   =======   =======  
4.2       2 GB       4 GB      4 GB      4 GB      4 GB
4.1.a     2 GB       4 GB      4 GB      4 GB      2 GB
4.1       2 GB       4 GB      4 GB      2 GB      2 GB
prior     1 GB       2 GB      2 GB      2 GB      2 GB

==> The problem was that the AIX operating system wouldn't allow files larger than 1 gig to be written to the file system. An OS parameter needed to be changed: the /etc/security/limits file, fsize parameter was set at 2097151. They changed it to -1 and the problem went away.

Prior to this change, executing the 'ulimit -a' command returned:

 time(seconds) unlimited file(blocks) 2097151 data(kbytes) 131072 stack(kbytes) 32768 memory(kbytes)32768 coredump(blocks) 2048 nofiles(descriptors) unlimited

 time(seconds) unlimited file(blocks) unlimited data(kbytes) 131072 stack(kbytes) 32768 memory(kbytes) 32768 coredump(blocks) 2048 nofiles(descriptors) unlimited

The value for file(blocks) is the limit on the file size in 512k blocks that can be written. After the change the value is unlimited and the size of file that can be written is limited only by the available disk space.

                  Fuser –u /user/appx/data/VV/AAA/Data/Bugvar.dat

                  /user/appx/Data/VV/AAA/Bugvar.dat: 15846(tom)    18211(appx)

1) Check that the Windows Sound Control's "Mute" isn't on, and that mixer volumes (Wave, Synth, Line, CD, etc.) are all set on high.

2) Try deleting Appx/Client cache files (Win2k: C:\Documents and Settings\{yourWindowsID}\.appx\cache\).

3) The "Toolkit.getDefaultToolkit().beep()"code may or may not be what your desktop expects as the default beep. It may be associated with another control. Go to Control Panel > Sounds and Multimedia > Sound Events. Is there a Sound Event named "Default Beep"?

If not, go to Microsoft Knowledge Base Article 300406 http://support.microsoft.com/default.aspx?scid=kb;en-us;300406 titled: "Default Sound Is Unavailable in the Sounds Tool in Control Panel", and follow its instructions.

If there is a "Default Beep" Sound Event, check to see if it has a .wav file associated with it and that the .wav file really exists. If there is not a .wav there, set one and see if that works. If one does exist, try setting a .wav association with the Windows program events that do not have a sound attached until you find the one that works.

4) Try re-installing the Appx/Client.
.

              Toolkit.getDefaultToolkit().beep()

... to the Java VM (rather than fire off a .wav file). The Java VM forwards that request on via the Windows OS to the external speaker, but it's possible it's going thru the Client PC's BIOS => internal speaker to produce a beep. (We can't really tell, as this is internal to the Java VM.)

It's possible something you installed or uninstalled may have changed the sound associated with the event the Toolkit.getDefaultToolkit().beep() is sending.

Command Line Options

-application=(APPX server Application ID) Instructs the server to startup in a particular application ID. (not implemented)

-bg=(color) Background color (See -fg for color list).

-bmode=(tile|expand) default=tile Defaults how background tiles are painted in the Java window. The “tile” setting uses the tile image over and over again to fill the window. The “expand” setting resizes the image to just fill the space inside the window. Used with the –splash= setting.

-boldFg=(color) Set the default text foreground text color for bold text (See –fg for color list).

-cols=(window size in columns) default=80 Defaults the initial screen size in columns.

-database=(APPX server Database ID) Instructs the server to start in a particular database. (not implemented)

-editBg=(color) Set the default text foreground text color for edit fields (See –fg for color list).

-fg=(color) Valid colors are black, blue, cyan, darkGray, gray, green, lightGray, magenta, orange, pink, red, white, yellow, or any valid #rrggbb number. Set the default text foreground color. Defaults to black.

-font=fixed Turns off the proportional font normally used by the Java client. If you are having problems with the text on your application screens not lining up the way you want, try this setting.

-hideMenu (not implemented)

-hideToolbar (not implemented)

-host=(server hostname) Defaults the remote host field on the remote login pane of the login dialog box. It is also used when the login dialog box is skipped.

-look=(java|windows|motif) default=windows Defaults the look and feel setting on the “options” pane of the login dialog box. It is also used when skipping the login box.

-mode=(local|remote|both) default=both Controls which login panels are shown and also determines which type of login to do if the login in dialog box is skipped.

-optkey=(character) Resets the key used as the option key. The default is the single back quote character (`, left of the 1 on the QWERTY keyboard. To set the option key to the ~ character, use –optkey=~

-password="(server OS password)" Defaults the password on the remote login pane of the dialog box. It is also used when skipping the login box.

-pathname=(path & filename of the local appx.exe file) Defaults the location and name of the APPX server when running APPX locally. This is also used when skipping the login dialog box and the –mode=local is set.

-port=(server port number) default=8060 Defaults the remote server port number on the login dialog and also used when doing a remote login with the login dialog box skipped.

-process=(APPX server process name) Set startup process name.

-ptype=(menu|job|input|output|...etc...) Sets the startup process type.

-rows=(window size in rows) default=21 Defaults the initial screen size in rows.

-shell=(command line to start a document) Overrides the default command line used to ‘start’ a document. Starting a document is telling Windows to open a document and having Windows use the association for that document type to decide which program to use. This defaults to start (document), which might not work on NT. NT may require this to be set to start the command shell like “cmd.exe /c start”.

-smode=(tile|expand) default=expand Defines how the splash image is painted on the Java window. The “tile” setting uses the tile image over and over again to fill the window. The “expand” setting resizes the image to just fill the space inside the window. Used with the –splash= setting.

-splash=(url to an image) Used as a background image in the main client window during the login process. How it is painted is determined by the –bmode= setting.

-tile#=(url to an image) Defines an array of images that the client will use to fill window backgrounds. –tile1= defines the base wallpaper image. –tile2= defines the wallpaper for all one up from the base window. –tile3= sets the pattern for all windows two up from the base window, etc. You can define as many or as few as you like. The client will cycle back to the first image if you have more windows layered on the screen for which it has tile images. Used with the –bmode= setting.

-title="(text/information to display)" Replaces the default text in the title bar of the client with the text and optional data specified in this parameter. Supports the following options; $(host) displays the host id, either name or IP as entered in login $(user) displays the user login id $(pathname) displays the engine path $(pid) displays the server task id $(port) displays the port the connection is attached through Example: -title=”Host is $(host), PID is $(pid), on server port $(port)”

-user=(server OS userID) Defaults the userid on the remote login pane of the dialog box. It is also used when skipping the login box.

home

This should also provide useful information if you're having problems with:

        SUBR --- LOAD URL ON CLIENT.

See also: How do I send a file to a client PC and open the file with a client side App? (i.e. Excel)
_

In APPX 4.1 and higher, you can use the following code:

        SUBR --- CHECK GUI CLIENT     SUBPROCESS  END? N
        IF   --- RETURN CODE             EQ    1
  T     it's the java client
  F     it's not

When the server is spawned, it inherits a bunch of file descriptors from winappxd. One of these file descriptors is the TCP/IP connection from the client. The "-f=" flag tells the server which file descriptor is connected to the client.

After completing the spawn, winappxd closes it's copy of the client file descriptor and the server starts talking to the client on the indicated descriptor.

The APPX session is probably still running on the server, and that's what's holding the record.

You need to do one of the following:

- Have a look at the registration usage to see if there is an orphaned session for that user. If you can find it, KILL it from the console.

- Use NTHandle on the server and find the PID that has the file. Then kill it. At the heart of it, NTHandle digs out the PIDs and the open files. You still have to parse through NTHandle, once you have it from www.sysinternals.com

- Ask everyone to log off, stop the WinAppxD and License servers, and kill any remaining APPX sessions on the server. If there are background jobs running, it might be tricky to identify the background jobs from the ghost task.

- Identify the process id's of all currently connected clients (look in the title bar if P/M client, or under the 'About' menu if Java) and kill everything but those. Again, watch out for background jobs, if you use them at your site. Also, you might want to stop the WinAppxD service while you do this to prevent new users from logging on while you try to find the ghost process.

- Download and install the BJutils package. This is Bruce Johnston's APPX utility package, and one of the utilities allows you to see who has what files open and also allows you to kill APPX sessions. This would help you identify which APPX session is holding the record. You can get this from www.cansyswest.com, under Free Stuff. You also need the NT Resource Kit to make these work.

- Reboot the server (simple, but drastic)

In addition, key file corruption can cause locking problems. It is not unlikely that externally killing an APPX process may cause key file corruption.

So you should run a 13)Verify 1)Integrity on any files that may be open when you have a record locking problem, for which you end up either killing processes, or re-IPL'ing with APPX processes still running.

If you're having record locking problems, it might also be prudent to run 13)Verify 1)Integrity on a regular schedule, perhaps monthly.

To determine your environment variables under Unix, perform:

       RUN          set > /tmp/env.txt

To determine your environment variables under APPX for Windows:

       RUN          cmd /c set >C:\tmp.txt
       RUN          wordpad.exe C:\tmp.txt

 (Under Windows 9x, use command.com rather than cmd.exe.)

If you're running APPX/Client, have the first RUN redirect standard out to a  
file in a client-accessible directory, then run an editor on that file.

To get the environment variable using ILF, try;

      SET      --- TEMP 80          =      cd /tmp;
      APPEND   --- TEMP 80          1      set > env.tmp;
      APPEND   --- TEMP 80          1      grep APPX env.tmp >
      APPEND   --- TEMP 80          1                env.txt   ;
      APPEND   --- TEMP 80          1      rm env.tmp
      RUN      --- TEMP 80

Set the environment variables APPX_NET_LOG and APPX_NET_MASK to have APPX create a log file of why the client is not being started.

If that doesn't work, perform:

   1) Download a fresh copy of the APPX Java Client ('javacli.exe').

   2) Create a new directory (renaming or deleting the old one if necessary).
      Run this 'javacli.exe', installing it into this new directory.

   3) Reboot the client PC.

   4) Try to run 'appxjava.exe' from the new directory.

   5) If it fails, from a DOS window, do a "set" command.  Email the value
      of IBMHPJ_OPTS to us at techsupp@appx.com, along with the location of the
      directory into which you installed the Client.

Over the past 6 months, our APPX login times have steadily lengthened. 


Normally this symptom is due to a growing USAGE file.  Other likely events;


- network traffic in general has increased on your network

- more users in APPX

- more PC’s on your network

- do you have the APPX client stored on a local disk on each client PC, or
  are  you retrieving it from the network any time someone logs in?  (See the
  WinAppxD FAQ, ftp.appx.com/pub/documents/winappxd-faq.txt, section 2.12: 
              "Automatically update Presentation Client".)

- It's also possible that you have a DNS or WINS issue 

Example of a batch file that can start APPX and automatically update the 
APPX/Client to the most recent version prior to logon:

rem  AppxJAVA.bat
rem  Batch file to launch Appx Java Client and keep it updated.
xcopy x:\Appx\StartUp\Images\splash.jpg c:\"Program Files"\AppxClient\
                        themes\default\ /d
xcopy x:\Appx\StartUp\login.ini c:\"Program Files"\AppxClient\ /d
xcopy x:\Appx\StartUp\JavaClientUpdate\AppxClient.exe c:\"Program Files"\
                        AppxClient\ /d
xcopy x:\Appx\StartUp\JavaClientUpdate\Appx.jar c:\"Program Files"\
                        AppxClient\ /d

"C:\Program Files\AppxClient\AppxClient.exe" -cols=80 -rows=25
                 -title="Appx -$(user) on $(host):$(port), PID $(pid)
exit

The following batch file does the same for the Appx Windows Client.

rem AppxWin3.bat
rem 09/03/99 PAK
rem
rem Batch file ran on each client at startup of Appx
rem i.e., the Appx Desktop shortcut should point to this file
rem
rem XCOPY switches:
rem /d - Copies only those files whose source time is newer than
rem      the destination file.
rem /i - If destination does not exist and copying more than one file,
rem      assumes that the destination must be a directory.
rem /u - Copies only files that already exist in destination
rem
rem Copies the Latest Version of Appx to your computer!
rem
xcopy x:\appx\appx.exe c:\Appx\Win32\ /d

md c:\Appx\Win32\data
xcopy x:\appx\startup\winprint.exe c:\Appx\Win32\data\ /d

rem for WinNT, HOSTS file is in: Winnt\system32\drivers\etc\
xcopy x:\Appx\Startup\Hosts.* c:\Winnt\system32\drivers\etc\ /d /i
xcopy x:\Appx\Startup\Hosts   c:\Winnt\system32\drivers\etc\ /d
start c:\Appx\Win32\Appx.exe -c

When you run the first process in a locked application, Appx acquires a USAGE (this means that you are using 1 user right from that product registration). When you run the second, third, fourth, etc. processes in that application, you don't count as 2, 3, 4, etc. users - just a single user.

When you end ALL processes in the locked application, it decrements the usage count for the appropriate lock. If the usage count for a lock goes to zero, the lock is forfeited, and therefore the overall user count for that lock is decremented. (You are no longer counting against the user rights for that product registration)

If the user gives us a host name (as opposed to a numeric IP address), we have to convert that to an IP address, using the TCP/IP stack on the client machine. If the server's name is in the hosts file (/etc/hosts or %WINDIR%\System32\drivers\etc\hosts), the conversion should be nearly instantaneous.

If the server's name is not in the hosts file (or if file-based lookup Has been disabled), the conversion requires a network conversation with a DNS name server - that can take quite a while.

If the name cannot be resolved, you'll get an "Invalid Host Name" error after a while.

If the host is not reachable, the IP protocol specifies some number of retries (and some waiting period in between retries) before the TCP/IP stack gives up and tells Appx that the host is unreachable.

We run a job for a post and the action log normally behaves correctly, 
but on occasion no log is produced.  But in a subsequent job for 
another group, the action log contains items (usually Warnings) for 
this post, as well Warnings from the first post.

You'll have more control over the format of your Logfile, and you can use DISPOSITION functions to direct them. You could also use ILF to update an ancillary error tracking file, if you want a more permanent record of errors encountered, by whom, and when.

 1) In Control Panel > Administrative Tools > Data Sources(ODBC) > 
          System DSN tab => Remove the AppxODBC record. 1) Uninstall AppxODBC.
 2) If 'C:\appx.env' exists, delete or rename it.
 3) Delete appxodbc directory tree (which contains the 'appx.dbs' tree).
 4) Search for and delete appxodbc.dll and appxsetp.dll.
 5) Reboot.
 6) Reinstall AppxODBC from a downloaded AppxODBC installation package.

         http://board.appx.com/faq/cache/232.html 

Right Click on your Windows Client Desktop > Properties > Settings Tab > Advanced... > Troubleshooting Tab > Hardware Acceleration slider. Click it to the left, perhaps all the way to "None". That should straighten out the display. If it doesn't, call Appx Support.

So we don't really generate code in the way that some tools do. We don't generate C code that then gets compiled into a program. Appx is a compiler, interpreter, and VM all rolled into a single package.

I use 28x100 because it creates a nice sized and readable screen on a 17” monitor when using a resolution of 1024x768. It fills the screen nicely, but has a font that is large enough to easily read.

My personal preference is 28x110. This size fits nicely on 17" monitors with a resolution of 1024x768.

We chose to set the standard at 21 X 97. This will fill a screen when the resolution is set at 800 X 600. It gives us some extra screen real estate, particularly in the width where its most useful, but doesn't strain the eyes of our older employees.

0 = Paint every screen 1 = Skip some intermediate screen repaints 2 = Skip all intermediate screen repaints

Screen painting is the most intensive thing the client can do.

--- TEMP 132 is loaded with:

ln -s -f /ft/mv90/test.PRN/home/appx/data/TST/UBS/Data/MV9IRPRN.dat

RUN --- TEMP 132

You can rule out the first problem by including the complete path to the /bin/ln program.

To check on the second problem. RUN the command "id > /tmp/myid", then look at /tmp/myid. You'll probably see that you are running as user appx rather than yourself s you might expect.

Make sure that the destination directory is modifiable by $(cat /tmp/myid)

home

Note: appxlog.txt is initialized when a user starts a new session, so you must capture it before the user starts a new session.

See also Diagnose SUBR --- SEND FILE TO CLIENT problems and Where is Java/Client cache?.
`

Unix & Linux:

   $HOME/.appx/

   C:\Documents and Settings\{yourWindowsID}\.appx\

   C:\WINNT\.appx\

Files are created in Tmpdata for large sorts and for temporary disk files created by application(s). Under ideal circumstances, APPX removes all temporary files at the end of the job that created them. However, if a job is interrupted, the temporary files are not automatically removed and, over time, they can accumulate. So, the system administrator should routinely remove them when performing system maintenance to keep them from accumulating.

APPX has to choose a unique file name when creating a temporary file. Determining a unique file name can take some time if there are a lot of files in the Tmpdata directory.

If users are actively in Appx, you should not blindly remove the contents of the tempdata directory. But if all users are out, then it is perfectly fine to remove the contents.

-Reorganize active files

"Active" data files should periodically be "reorganized" whether or not they are APPXIO, C-ISAM, Oracle, or whatever.

Files and disk drives should be defragmented periodically.

-Orphan APPX sessions

Check for "orphaned" APPX sessions on the server that might be consuming system resources.

-Network errors

Check for "high" error counts on your network that might be causing slow response or "orphaned" APPX sessions on the server.

-Logging

Check your enviromental variables to see if you are creating any dianostic log files that are not needed.

      PASS     Rq: Buffer                     FIELD            SHARE? Y

      PASS     Op: Total Chars in Clipbrd     FIELD            SHARE? Y

      PASS     Op: Max Num Chars to Read      FIELD            SHARE? N

      GOSUB    --- READ FROM CLIENT CLIPBOARD                           

The first field is a field to receive the clipboard data.
The second field will be filled in by the routine telling you how many bytes were in the clipboard.
The third field is optional and if used you set it to the max number of bytes you want to read. It will default to 32767 if not set.

It depends on the platform. If you're running a Linux or Unix server, the operating system, background jobs will pretend like the user pressed the END key whenever a process gets to a point where it would normally wait for user input.

On Windows servers, the OS doesn't really provide anything that differentiates between a foreground and background process - there isn't a notion of a "background process" on Windows (except for a Windows service, which is something else entirely). Instead, when you spawn an Appx background job on a Windows server, we just start another copy of Appx (minimized). Try running Appx on a Windows server without running in client/server mode - run a background job that needs to wait for user input. When you spawn the job, you should see another copy of Appx show up in your task bar. Open that window and you'll see the background job running. You can interact with it using the keyboard and mouse. It's just a second Appx session that starts in the right place, has a copy of all of the parent session's important data, and starts minimized. Just like the specification says: separate task allowed? Very handy for debugging background jobs.

However, that's an old feature that was written before we had a client/server configuration. If you connect to appxdsvc or winappxd, the broker creates an invisible desktop for the engine sessions - that means that you can't get to any background sessions. We should probably modify the Windows engine so that it notices that you're running in client/server mode and behaves more like Unix/Linux of you are.

      PASS     --- RI                         FIELD            SHARE? Y
      PASS     --- CI                         FIELD            SHARE? Y
      GOSUB    --- GET SCREEN SIZE 

QUERY <some query name> JOB DISPOSITION - consists of one INPUT process OUTPUT <some output name>

When the user is at the INPUT process of the nested job, and they press F4 to go back, it continues to the OUTPUT. Why does it do this? Can I get it to return to the previous job step?

Yes, you can get it to return to the previous job step. Make sure that your JOB DISPOSITION step is invoked as a Subprocess, not as "related", and make sure that "Separate task" box is not checked. That should do the trick.

There are 3 things that controls if you can or can not return to the previous activity:
1. NEXT CHILD ID - it controls job steps and is shared at the subprocess level. Normally it's set to "+", which means "move forward"
2. Separate task set to "Y"
3. There is a hidden filed on a CHILD file called "Prev Img Ok" - not 100% sure what exactly sets in ON or OFF, but i think it's ON by default now.

1) commit frequency
2) Length of data read/written
3) Read with hold
4) # of database I/O's
5) communication protocol and settings

I'll briefly discuss each.

1) commit frequency (Commit Mode, Process Additional Attributes).

We have determined that a commit is very "expensive" in terms of performance. If you can reduce the number of commits, then performance will almost always increase, sometimes significantly. Deferring commits to the End of Process probably maximizes performance for this factor but may increase the size of the rollback logs and will certainly increase the number of rows in the database which are "locked" to other users while updates are pending.

2) Length of data read/written

This may be the most significant factor which impacts performance. As the length of the data being read or written increases, the run time increases, sometimes dramatically. This is why we added the Partial Record I/O feature. If possible, you should avoid reading the entire record if the record is large. How large? I seem to remember that each increment of about 800 bytes caused a significant incremental loss of performance. Even if you must read the entire record, then try to avoid a rewrite of the entire record. If you are only updating a single field, then do a rewrite of just that field. If you are rewriting several fields, wrap them in a group and rewrite the group. If necessary, you can add a "group" of synonyms to the end of the record to accomplish this.

3) Read with hold

Don't read with hold unless you need to. If you are only going to actually update a small percentage of the records read, read each record first without a hold and then, after you determine that an update is needed, read it with hold. A read with hold is very "expense" in terms of performance. Keep in mind that an output or update process will automatically read the PCF with hold if a REWRITE or DELETE statement is detected. If only a small percentage of records will actually be updated, it might be much more efficient to write a Subroutine process as an alternative to an update process.

4) # of database I/O's

Use the new file cache capability to load read-only "code" files into memory where they can be very efficiently read. Accessing of code files in a database is much slower than accessing the same code files from memory.

5) communication protocol and settings

If possible, install the Oracle database and APPX on the same machine so that you can avoid database I/O across a network. If they are both on the same machine, configure Oracle to use "pipes" for communication instead of TCP/IP. Define the ORACLE_SID environment variable instead of specifying the database name in the FMS group. APPX will then use the local communications protocol which will probably be pipes. Pipes are much more efficient than TCP/IP.

If you are using TCP/IP make sure that the packet size is large. I'm not sure how large you can define the packet size to be, but 10K or more might be desirable if you are reading/writing large rows.

Is Appx going to be affected by the new Daylight Savings Time?

APPX does not keep time – it simply reads what the operating system provides. 
As long as you have patched your OS properly, there will be no issues as far as 
APPX is concerned.

It means that Appx found an unexpected entry in a "scope list".  
When you open a file, Appx creates a "logical file block" (LFB) to keep track
of that file.  Every file is opened at some particular scope - when that scope
ends, the file is closed and the LFB is discarded (a scope is something like
"the most recently invoked related process", "the current event point", or
something like that).  The LFB is linked into a list of all LFB's belong to a
given scope.  This message means that Appx was processing a scope list and
found an LFB that should have been linked into a different list (because it
has the wrong scope).

It could be related to FLEP bug.