Quick recap

Rony led a comprehensive discussion on the Java programming language, its cross-platform compatibility, and the role of the Java Virtual Machine in compiling byte code. He also introduced new short programs to assist students with Java and provided an in-depth overview of the Bean Scripting Framework (BSF) for Oracle. Additionally, he demonstrated the use of the Bsf.Cls package for interacting with Java classes and objects, and discussed the implementation of Rex command handlers in Java through a project called J. Dot Java, 2D.

Next steps

All attendees to run the Bsf for ORex samples that start with number 1 (42 samples in total).

All attendees to create 2 very short samples based on existing ones, with modifications, to practice using Bsf for ORex.

All attendees to review the Bsf for ORex documentation in the information folder.

Peter to use Java 8 for .NET (CLR) samples.

All attendees to avoid trying to understand GUI samples until after tomorrow's session.

All attendees to explore the Jdor (Java 2D for ORex) examples and documentation.

All attendees to review the Bsf.Dialog class usage in samples.

All attendees to familiarize themselves with the Bsf.Clipboard class functionality.

All attendees to study the Java collection iteration examples using ORex constructs.

Rony to provide an email response to Peter's question about .NET.

Summary

Java Programming and Bean Scripting Framework

Rony led a discussion about the current course status, which had reduced to five participants due to absences. He introduced two new short programs to assist students with Java and outlined the course's topic for the day: the Bean Scripting Framework (BSF) for Oracle, a Java framework enabling the integration of programming languages with Java. Rony explained the fundamental concepts of Java programming language, emphasizing its cross-platform compatibility and the Java virtual machine's role in compiling byte code into machine language for faster execution. He also highlighted the extensive libraries and applications available in Java, making it a valuable tool for programmers.

Rony's PSF and BSF Packages Update

Rony discussed the Psf, an external Rex function package he developed 25 years ago for interacting with the Java runtime environment. He highlighted recent additions to the package, including Bsf dot icon V for simplifying Rex programmers' code page translation and Psf dot clipboard for streamlining text and image copy-paste processes. Rony also introduced an external Regs function package, Bsf.cls, which facilitates the use of Java classes and objects in Rex programming. He demonstrated how to use Bsf.cls by creating an instance of a Java class and sending it messages.

Java JDK, LTS Versions, and Evolution

Rony clarified the differences between Java Runtime Environment (JRE) and Java Development Kit (JDK), emphasizing that JDK includes the compiler and tools for application creation. He highlighted the importance of installing the Java Jdk 8 Lts and Java Jdk 21 Lts for long-term support and versioning of Java. Rony also discussed the evolution of Java from a proprietary to an open-source language and its adoption by major tech companies. Reggie showed understanding and interest in further technical discussions about Java.

Java Programming Language Overview

Rony provided a comprehensive overview of the Java programming language. He explained the differences between dynamic and static programming languages, with Java being an example of the latter. He detailed the concept of 'wrapper classes' and the process of 'boxing' and 'unboxing', as well as the structure of a Java class, including fields, methods, and annotations. Rony also discussed the accessibility and visibility of Java classes, fields, and methods, and encouraged the use of the Java API documentation, which is automatically generated using Javadoc. He highlighted the availability of comprehensive documentation for the Java runtime environment, including improved search functionality in newer versions.

Java Class XYZ and BSF Functionality

Rony provided an in-depth explanation of the Java class XYZ, which is a public subclass of Java's Object class with a static counter field and two constructors. He emphasized the importance of Java's strict typing and how private fields can only be accessed through provided get and set methods. Rony also demonstrated the functionality of the Bsf class, which serves as a proxy for Java classes and is used to create instances and send messages. He further discussed the process of writing a Rex program using Bsf, the causes and solutions of errors, such as the 'XYZType' not found error, and how to compile a Java class and generate JavaDocs.

Java Class Clarification and Rejoining

Rony led a discussion that included a break and a subsequent rejoining. Reggie had questions about the Java class "XyzType", which Rony clarified. After resolving Reggie's queries, the team proceeded with the meeting.

Rony Demonstrates Java-Rex Integration

Rony demonstrated how to use the Bsf.Cls package's public routine, Bsf.Import, to import a Java class into Rex, and showed an alternative approach using the Psf.Proxy class. He also explained the functionality of getters and setters in Java, and how they can be used to manipulate attributes as if they were Regs attributes. Rony highlighted the differences between Java and Rex, focusing on issues related to case sensitivity, array handling, and type strictness. He introduced the Psf.cls package that allows the creation of Java arrays using Rex syntax, thereby simplifying the interaction with Java arrays. Reggie confirmed his understanding of the concepts discussed.

External Rexx Function 'BSFCreateRexxProxy

Rony explained the functionality of the external Rexx function 'BSFCreateRexxProxy' which creates a Java object that can contain a Rexx object. This allows the Java program to send messages to the contained Rexx object, and vice versa. Rony further elaborated that all arguments applied to the Java method are forwarded as an Orex message to the Rex proxy contained Rex object. He also mentioned an optional second argument that can be supplied at the time of Rex proxy creation, which can be useful in certain situations.

Java Interface Classes and Rex Proxy Variants

Rony explained the use of Java Interface classes, emphasizing that they define properties, fields, and methods without implementing them, and any Java class can claim to implement such an interface. He discussed a variant of Bsf create Rexproxy that uses Rex objects, packs them into a Java Rex proxy, and claims to implement all methods of a specified Java interface class. Rony also explained the creation and usage of Rex proxy variants in the context of a program that interacts with both Rex and Java. He demonstrated how to use these variants to distinguish whether a method was invoked from a message sent to the Rex object directly or from Java, and how to supply user data values to the Rex proxy.

Java or Rex Bridge and BSF Overview

Rony discussed the functionalities and benefits of the Java or Rex Bridge, emphasizing its complete implementation and the opportunities it presents for exploiting Java features. He then introduced the Bsf, an external Regs function package, and its capabilities, including the ability to interact with Java classes and objects. Rony also touched on potential issues that may arise, such as problems with case or type, and explained the infrastructure implemented to handle these issues. He encouraged the team to familiarize themselves with these concepts and to use the available resources to their advantage.

Addressing Java Method Selection Issues

Rony discussed the issues that can arise when using Java's method selection in conjunction with primitive types. He explained that if there are multiple methods with the same name but different argument types, it can lead to the wrong method being selected. To solve this, Rony suggested using the 'box' and 'unbox' routines from the Bsf.cls library to create a Java object that forces the selection of the method with the compatible signature. He also highlighted the importance of correctly specifying the type and case of arguments when using the 'invoke strict' method.

Psf. Forex Tutorial and Resources Overview

Rony led a tutorial on the installation and usage of Psf. Forex, emphasizing the importance of starting with simpler samples before moving on to more complex ones. He also demonstrated how to access the Bsf. 4 or x 8 50 program and view and run Rex code using the Bsf. For Regs menu's GUI. Rony highlighted the various features and resources available in the Bsf or Regs package, including an information folder with articles, reference cards, and other useful resources, as well as the Samples directory containing numerous examples for different purposes. He advised that the code for these examples be studied after understanding the concepts behind them.

Rex Handlers and Java 2D Graphics

Rony discussed the implementation of Rex command handlers in Java through a project called J. Dot Java, 2D. He demonstrated the use of these handlers for creating bitmaps and images, and highlighted their potential for game development. Rony also discussed the creation of a list of fonts implemented on different operating systems, emphasizing the simplicity of the task when using Java. Furthermore, he provided a detailed walkthrough of various programming concepts, focusing on image manipulation, 2D graphics, and collection iterations. As homework, Rony assigned the task of exploring the provided samples and creating two new ones.

/AI-generated content may be inaccurate or misleading. Always check for accuracy. /