To set up Photosmart c4780 All-in-One wireless printer in Ubuntu:

1. Go to the following and follow instructions to install the HPLIP software: http://www.hplip.net/
2. When prompted, reinstall HPLIP.
3. Restart Ubuntu. I find that I can’t connect to the printer immediately after the installation.
4. Execute the following:
   sudo hp-setup

   Follow the steps in the wizard.

HP Device Manager will also added to the system tray.

Fill([wherestring [, bindvalue] . . .]);

Data is read from the database table corresponding to the primary database record of the rowset. It’s also stated in PeopleBooks that:

The Fill method uses a correlation ID of FILL for the table it reads. You must use the correlation ID if you want to refer to the rowset table name as part of the wherestring. You receive a runtime error if you use the table name as a column prefix instead of the correlation ID.

It’s quite common to see wherestrings in the Fill method to reference the FILL correlation ID inside subqueries to limit the resultset. For example, something like the following:

Local Rowset &rs = CreateRowset(Record.RF_INST_PROD);

&rs.Fill("WHERE RBTACCTID = :1 AND EXISTS (SELECT 1 FROM PS_RF_INST_PROD_ST WHERE SETID = FILL.SETID AND INST_PROD_ID = FILL.INST_PROD_ID AND INST_PROD_STATUS = 'INS')", &acctid);

or

&rs.Fill("WHERE RBTACCTID = :1 AND INST_PROD_ID IN (SELECT INST_PROD_ID FROM PS_RF_INST_PROD_ST WHERE SETID = FILL.SETID AND INST_PROD_ID = FILL.INST_PROD_ID AND INST_PROD_STATUS = 'INS')", &acctid);

However, if you observe it closely (ignoring related-language processing), the Fill method would basically just generate a SQL statement in the following manner:

SELECT {list of fields from primary record} FROM %TABLE({primary record}) FILL {wherestring}

and push the resultset to the target rowset.

With this in mind, it’s possible to pull data from a join query instead. For example, the previous Fill call can be rewritten as:

&rs.Fill("INNER JOIN PS_RF_INST_PROD_ST ST ON ST.SETID = FILL.SETID AND ST.INST_PROD_ID = FILL.INST_PROD_ID WHERE FILL.RBTACCTID = :1 AND ST.INST_PROD_STATUS = 'INS')", &acctid);

Interestingly, it also means you could fill a rowset with data not coming from the primary record by using a UNION. For example (notice the fields doesn’t even have to match the primary record):

Local Rowset &rs = CreateRowset(Record.PSOPRCLS); /* Fields: OPRID, OPRCLASS */

&rs.Fill("WHERE 1=0 UNION SELECT OPRID, ROWSECCLASS FROM PS_ABS_DEPT2_VW WHERE EMPLID = :1", &emplid);

This latter example is more for academic discussion, as I can’t vouch for the database efficiency in using this technique. Also, when the fields of the primary record is updated, there is a need to manually adjust the code to match the primary record definition. However, it might be handy for quick prototypes and filling message rowsets with data directly without the need for new SQL Views and CopyTo operation.

Postscript: A quick googling shows that this concept has already been presented by Todd Kummer here.

Local string &TEXTLINE = "Value of " | &fld1name | " is " | &fld1value | ".";

Using MsgGetText, it can be re-written as follows:

Local string &TEXTLINE = MsgGetText(0, 0, "Value of %1 is %2.", &fld1name, &fld1value);

I find that the latter is easier to read and modify compared to the first, especially if there are a lot of values being concatenated.

What about performance? Wouldn’t the MsgGetText code needlessly query the database for message (0, 0)? Fortunately, I think not. Some tests with SQL trace turned on — and the cache freshly cleared — show that a query to the message catalog for message (0, 0) is never performed by the application server. A wonderful optimization.

1. Declaring Local Variables
2. Usage of the %Table() meta-SQL When Writing SQL Statements

I. Declaring Local Variables

Background

Except for Application Package PeopleCode, the PeopleCode compiler/editor does not require that local variables used by programs are declared. Undeclared variables are automatically allocated the type of Any.

Coding Standard

When writing PeopleCode, declare ALL local variables that will be used.

Benefits

1. Declaring the specific type of variable needed improves performance, in contrast with the interpreter always assuming a type of Any. Even if the variable to be declared requires being an Any type, declare it nonetheless (see 4th item below).
2. Compile-time validation.
   • When variables are declared, the PeopleCode editor can check the compatibility of variables used in an operation, or passed as function arguments.
   • For variables pointing to objects, the names of methods and properties can be validated at save time.
3. Convenience. For built-in buffer classes (Rowset, Row, and Record), shorthand notation is only allowed for declared variables.
4. For programming languages that allow dynamic allocation of variables, it is a common programming error to misspell variable names. However, on the PeopleCode editor, when all variables are consciously declared, it is easy to check for misspelled variable names (see the following illustration). Thus, with this standard in place, this type of coding error would be eliminated.

Illustration

Take a moment to look at the following PeopleCode example:

This code has 2 misspelled variables. How long did it take you to find them?

The code could be modified to enforce the rule that all variables are consciously declared; resulting in the following (changes are highlighted):

Now, when this PeopleCode is saved, or when the Validate Syntax action () is invoked. The following messages would be displayed in the Output window:

Double-clicking these messages would bring you to the offending line in the code.

NOTE: As shown in the example above, it is NOT necessary to always declare the variable at the top of the program. Declaring them on the first time they are used is sufficient to achieve the said benefits.

II. Usage of the %Table() meta-SQL When Writing SQL Statements

Background

When writing SQLExec statements, the common practice is to hard-code table/view names. For example:

SQLExec("Select FIELD1, FIELD2 From PS_RECORD_TBL Where CRITER1 = :1 AND CRITER2 > :2", &IN1, &IN2, &OUT1, &OUT2);

A problem with the above code is that information in the PeopleCode string literals cannot be classified by the compiler and saved into the PeopleTools reference tables.

Coding Standard

Use the meta-SQL %Table() in SQL statements to refer to SQL tables or views.

With a little effort, the above code can be transformed into the following (changes are highlighted):

SQLExec("Select FIELD1, FIELD2 From [b]%Table(:1)[/b] Where CRITER1 = [b]:2[/b] AND CRITER2 > [b]:3[/b]", [b]Record.RECORD_TBL[/b], &IN1, &IN2, &OUT1, &OUT2);

Benefits

The consequence of this change is that Record.RECORD_TBL is saved as a reference in the appropriate PeopleTools reference table (PSPCMNAME). This brings the following maintenance advantages:

1. A Find Definition Reference for RECORD_TBL record will include the above SQLExec line in the results.
2. Renaming RECORD_TBL will automatically propagate to the PeopleCode references (App Designer automation). No coding change is required.
3. For more complex SQL, like ones that need effective-dated logic, you can reference the record name only once. For example, if RECORD_TBL is effective-dated, you could write the following:

   
   SQLExec("Select FIELD1, FIELD2 From %Table(:1) A Where CRITER1 = :2 AND CRITER2 > :3 [b]And EFFDT = (SELECT MAX(EFFDT) FROM %Table(:1) WHERE KEY1 = A.KEY1 AND EFFDT <= %CurrentDateIn)[/b]", Record.RECORD_TBL, &IN1, &IN2, &OUT1, &OUT2);
   

4. At a glance, the number of tables/views being referenced by the SQLExec can be easily identified.

NOTE: Unfortunately, currently the criteria parameter of the Select() method of the rowset class does not properly handle the %Table() meta-SQL, therefore this is one case where you cannot use this standard. Although fortunately, the need to reference a table in the Select() criteria seldom happens.

What are the Problems with AppEngine

• These programs can be complicated – and for a programmer they’re different
• Same logic can be used Batch and Online – Really?
  • Different transactional model
  • Temp table behavior is very different
  • No restartability
• Easy to write a poor performing App Engine Program
  • Since the introduction of PeopleCode, poor performing programs are the norm

Admittedly, I don’t have a lot of experience writing batch programs on Application Engine. But I believe the primary reason it is so easy to write poor-performing AE programs is that AE batch programs are better suited to be programmed using set processing. Set processing requires a different mind set to what procedural programmers are used to. I am new to it as well, so I find that this discussion in ITToolbox, and this followup provides valuable insights on how to perform set processing. Steve’s technique of what he calls partial cartesian joins is quite useful as well, especially for those not running an Oracle database.

Setup

1. Download and install the latest version of PSPad from http://www.pspad.com
2. Save the file PeopleCode.INI below into the Syntax folder inside PSPad install location. By default, this would be C:\Program Files\PSPad editor\Syntax\.
3. Launch PSPad and from the menu select Settings > Highlighters Settings…
   
4. On the left pane, select and put a checkmark on the first <not assigned> item.
   
5. Then on the User Highlighters list on the right pane, select PeopleCode.
   
6. Go to the Colors tab. Here the color preferences to be used for syntax highlighting is set. To match the way the PeopleCode editor does highlighting, choose green for the comment; blue for Key, Key words 2, Key words 3 and Reserved Word; and red for String.
   

Usage

1. Create a new document, from the menu File > New file… or using the following button:
   
2. Paste the PeopleCode to the document:
   
3. Select the text you want to copy. From the menu select File > Export > Export to Clipboard as RTF:
   
4. Now, you can paste to an Office document and the formatting would be preserved.

Files

PeopleCode.INI

For SQR users, here’s a SQR.INI syntax file for PSPad.

I find this useful when I need to search for keywords that are not specifically related to PeopleSoft. Following is an example result when searching for “excel”:

I still have trouble filtering out RSS from the results, if anyone can help me with that.

Now, if you’re browsing my site using Firefox 2, you may also notice the following auto-discovered PeopleSoft Search item on your search bar:

Following is how the auto-discovered search would like it IE7:

This plugin is packaged using the OpenSearch standard, as described in this Mozilla article.

The plugin can also be installed by clicking the following link:

Install PeopleSoft Search

… suppose you want to provide a more generic sort, with comparison function at the end of it. You want to use the array class Sort method, but your process has to be generic: you aren’t certain if you’re comparing two records or two strings. You could define a class that had as its main method a comparison, and return a -1, 0, or 1. Then write your personalized sort, extending the array class method Sort.

I find this statement very vague and lacking in details, that I am doubtful about its accuracy.

The statement seems to somewhat describe how one would define the ordering of objects in Java’s array and collection classes by creating an implementation of java.util.Comparator interface. However, according to PeopleBooks, the Sort method of the Array class does not have any optional parameters where such a comparator object may be provided.

I couldn’t find anything else in PeopleBooks where it describes the implementation of array sorting in the manner described in the statement above. Can anyone shed some light into this, and if possible, provide additional details? Does the PeopleCode Array class Sort method have an undocumented feature similar Java Arrays’ sort method?

If you declare an instance variable as private you can still access it as a private property in another instance of the same class. For example, given the following declaration:

class Example
  private
     instance number &Num;
end-class;

A method of Example could reference another Example instance’s &Num instance variable as follows:

   &X = &SomeOtherExample.Num;

To experiment with this, I created this simple application class:

class Example
   method CreateNewInstance();
   method IncrementNewInstanceNum() Returns number;
   method IncrementThisInstanceNum() Returns number;
   method IncrementPassedNum(&passed As Example);
   property number ThisInstanceNum get;
private
   instance Example &newInstance;
   instance number &Num;
end-class;

method CreateNewInstance
   &newInstance = create Example();
end-method;

method IncrementNewInstanceNum
   /+ Returns Number +/
   &newInstance.Num = &newInstance.Num + 1;
   Return &newInstance.Num;
end-method;

method IncrementThisInstanceNum
   /+ Returns Number +/
   &Num = &Num + 1;
   Return &Num;
end-method;

method IncrementPassedNum
   /+ &passed as CJ:Example +/
   &passed.Num = &passed.Num + 1;
end-method;

get ThisInstanceNum
   /+ Returns Number +/
   Return &Num;
end-get;

Then referenced the class in the following manner:

Local Example &test1 = create Example();
&test1.CreateNewInstance();

MessageBox(0, "", 0, 0, "IncrementNewInstanceNum() returns %1", &test1.IncrementNewInstanceNum());
MessageBox(0, "", 0, 0, "ThisInstanceNum returns %1", &test1.ThisInstanceNum);
MessageBox(0, "", 0, 0, "IncrementThisInstanceNum() returns %1", &test1.IncrementThisInstanceNum());
MessageBox(0, "", 0, 0, "IncrementNewInstanceNum() returns %1", &test1.IncrementNewInstanceNum());

Local Example &test2 = create Example();
MessageBox(0, "", 0, 0, "&test2.ThisInstanceNum returns %1", &test2.ThisInstanceNum);
&test1.IncrementPassedNum(&test2);
MessageBox(0, "", 0, 0, "&test2.ThisInstanceNum returns %1", &test2.ThisInstanceNum);

This yields the following result:

IncrementNewInstanceNum() returns 1
ThisInstanceNum returns 0
IncrementThisInstanceNum() returns 1
IncrementNewInstanceNum() returns 2
&test2.ThisInstanceNum returns 0
&test2.ThisInstanceNum returns 1

This shows that indeed, an object has unrestricted access to the private instance variables of another instance of the same class. However, one thing that I am not quite sure of is why is this allowed? When is this needed? Do any other programming languages out there has the same characteristic as this?