Quick recap
Rony led a comprehensive discussion on the history, functionality, and compatibility of Open Office
and LibreOffice, including their development, data types, interface classes, and programming
possibilities. He also provided a detailed walkthrough on various features such as accessing
documentation, understanding the 'load component from URL' method, using the spreadsheet module, and
manipulating drawing module data. Lastly, he shared his experiences and solutions regarding the Open
Office library, introduced the Uno Runtime Environment, and encouraged the team to review sample
programs for better understanding.
Next steps
Peter to install 64-bit LibreOffice on his Windows machine.
All attendees to review the nutshell examples in the BSF for ooRexx samples directory
(subdirectories "ahammer" and "bulga").
All attendees to run the nutshell examples in sequence and study their source code to gain
familiarity with OpenOffice/LibreOffice programming.
All attendees to practice using the online OpenOffice/LibreOffice API documentation.
All attendees to experiment with creating and manipulating word processor documents using the
demonstrated techniques.
All attendees to practice creating and formatting spreadsheets using the shown examples.
All attendees to try creating business graphics in spreadsheets using the provided code.
All attendees to explore the drawing module capabilities using the given example.
All attendees to experiment with creating presentations and adding bullet points using the
demonstrated methods.
All attendees to investigate the spell-checking capabilities of the UNO runtime environment outside
of the GUI.
Rony to send this week's meeting summaries to the attendees.
Summary
History and Functionality of Open Office and Libra Office Software Packages
Rony led a comprehensive discussion about the history and functionality of the Open Office and Libra
office software packages. He explained the origins of Libra Office, its acquisition by Sun, and
subsequent transformation under Oracle, emphasizing the importance of Java in its development. Rony
also highlighted the compatibility between OpenOffice and LibreOffice, and their common goal of
Microsoft Office compatibility. Additionally, he shared his experience with using Zoom's summary
feature and advised Peter, who uses Microsoft Office, to install the 64-bit Libra Office for a
better experience.
UNO Model and Open Office Architecture
Rony discussed the advantages and functionality of the Universal Network Object (UNO) model
developed by the Germans, highlighting its efficiency and the use of a text file format for class
definitions. He also explained the modular structure of Open Office and Libre Office, emphasizing
the reuse of tested codes and the role of service classes and managers. Rony further elaborated on
the naming conventions for classes and interfaces, the compatibility of various programming
languages, and the importance of using the query interface to access methods from interface classes.
C++, Java, and Uno Programming Overview
Rony provided an in-depth overview of the basic data types in C++ and Java, and their significance
in understanding and navigating code, particularly in relation to Open Office and LibreOffice. He
also discussed the various classes in the Uno programming language, the concept of Uno modules, and
the importance of the Uno Singleton class. Rony further highlighted the extensive class library for
OpenOffice and LibreOffice, and the resources available on the Open Office Libra Office website,
including Java classes for interaction. Lastly, he detailed the installation and support process for
OpenOffice and LibreOffice, and shared a link to a well-received student utility related to open
office and business programming settings.
Interface Classes and Programming Possibilities
Rony discussed the interface classes within a system, highlighting the importance of documentation
and natural examples for understanding the functionality of the 1,422 interface classes out of
2,694. He demonstrated the process of querying an interface in Java, using the Uno class dispatch
helper, and suggested ways to simplify the service object. Rony also discussed programming
possibilities with Open Office and Libra Office, including the use of a module called 'uno dot cls'
and the creation of a 'X desktop' object. He further explained the system's capability to load and
save documents from various sources and its potential for interaction and change.
Technical Issue and Recording Session
Rony and Reggie discussed a technical issue related to displaying documents. Rony explained the use
of underscore blank to indicate a new window should be opened for the document. Reggie confirmed his
understanding of this. Rony also mentioned that he would be away for 10 minutes and would return at
11 local Vienna time. Upon returning, Rony initiated a new recording session.
Open Office Libra Documentation and Functionality
Rony provided a detailed walkthrough on how to access and understand the documentation for the 'load
component from URL' method in Open Office Libra. He also explained the functionalities of the Open
Office Libre Office web processor module, including its three services and the use of the X text
document interface. Rony demonstrated how to create and modify a document, use cursors for text
changes, and adjust paragraphs using different styles. Reggie confirmed the availability of the
required information on the internet.
Adjusting Paragraphs and Zoom Troubleshooting
Rony experienced technical difficulties with his Zoom session due to his machine being overloaded
with software. After resolving the issue, he led a discussion on adjusting paragraphs in a word
processor, using the Open Office application as an example. The team also discussed the potential
need for a system reboot to stabilize resources. The session concluded with a demonstration of
adjusting paragraphs, and a brief break was taken before the next meeting.
OpenOffice Spreadsheet Module Tutorial
Rony led a tutorial on the spreadsheet module in OpenOffice, focusing on its various functionalities
and how to interact with it. He explained the concept of tables, the use of the Excel range
interface, and how to address cells using different schemes. Rony also demonstrated the creation of
a spreadsheet, inserting charts and drawings, and changing the height of a line. He emphasized the
importance of using the correct file URI format when storing documents and warned against forgetting
passwords. Reggie and Peter were present and contributed to the discussion.
Spreadsheet Data Manipulation and Graphics
Rony demonstrated how to use the X Column Row Range interface to manipulate spreadsheet data,
including how to access and modify cell heights and widths. He emphasized the importance of using
the integer wrapper class for effective row and column updates. Rony also showed how to use the
'Unota set cell' routine from the 'Uno dot cls' file in Rex to manipulate a spreadsheet, set cell
values, format text, and change font weights. Additionally, he explained the process of creating
business graphics from data using a natural example, and the challenges he faced in understanding
and utilizing the number format system in Open Office LibreOffice.
OpenOffice LibreOffice Drawing Module Overview
Rony presented an in-depth overview of the drawing module available in OpenOffice LibreOffice,
demonstrating its usage in creating document collections of draw pages and its reapplication in the
presentation module, S. Impress. He emphasized the importance of using the service manager to create
instances for the drawings and showed how to set the string value for a rectangle shape and insert a
carriage return character for proper line breaks. Rony also discussed the process of creating a
presentation with two slides using the 'As Impress' document type, detailing the process of
accessing and setting properties of the layout and shapes, and how to insert new pages into the
collection. He concluded by mentioning an issue with the formatting of a slide, noting that it was
missing the bullets.
Open Office Library Experiences and Solutions
Rony shared his experiences and solutions regarding the Open Office library, including the
challenges he faced and how he was aided by a chance encounter with a professional Open Office
developer, Christophe. He explained various functionalities such as using the 'add item' function, a
utility routine for debugging, and how to enumerate objects in Open Office. Rony also introduced the
Uno Runtime Environment (URE) and demonstrated its use, including accessing the spell checker
service through the lingo service manager. He encouraged the team to review the sample programs in
the Examples directory for better understanding. Reggie sought guidance on finding these samples,
which Rony provided.
/AI-generated content may be inaccurate or misleading. Always check for accuracy. /
--
--
__________________________________________________________________________________
Prof. Dr. Rony G. Flatscher
Department Wirtschaftsinformatik und Operations Management
Institut für Wirtschaftsinformatik und Gesellschaft
D2c 2.086
WU Wien
Welthandelsplatz 1
A-1020 Wien/Vienna, Austria/Europe
http://www.wu.ac.at
__________________________________________________________________________________
Quick recap
Rony discussed the use of Java for creating graphical user interfaces and the challenges faced in
developing GUI classes that work across all operating systems. He also provided a comprehensive
introduction to Java programming, demonstrated the implementation of Rexx event handling in Java,
and discussed the functionalities of the Java socket class in client-server programming. Lastly, he
highlighted the importance of data encryption for secure data transport and encouraged further study
of Java socket programming.
Next steps
Participants to review Java socket programming concepts covered in the session.
Participants to study the Java documentation for socket and SSL/TLS classes.
Participants to practice transcribing Java socket programming examples to Object REXX.
Participants to experiment with creating simple client-server programs using sockets in Object REXX.
Participants to explore using SSL/TLS for secure socket communication in their programs.
Participants to write and submit two small example programs based on the session content.
Participants to review the Echo Server and Echo Client examples provided.
Participants to practice using the keytool utility to generate certificates for SSL/TLS.
Participants to explore wrapping Java streams into readers/writers for character-based communication.
Participants to experiment with buffered readers/writers in their socket programs.
Participants to review the differences between server and client property names for SSL/TLS setup.
Participants to practice error handling in socket programs using signal on syntax.
Participants to explore Java tutorials on socket programming for further learning.
Participants to prepare questions on socket programming for the next session.
Rony to prepare materials for the next session on Friday.
Summary
Java GUI Development and Challenges
Rony discussed the use of Java for creating graphical user interfaces (GUIs), highlighting its
benefits such as operating system independence. He detailed the challenges Java programmers faced in
developing GUI classes that could work across all operating systems and how they overcame these
hurdles. Rony also explained the technical aspects of GUIs, including the representation of pixels,
the increase in screen resolution over time, and the role of specialized graphical processors in
modern personal computers.
Java GUI Classes and Programming
Rony provided an in-depth explanation of Java's GUI classes and their components, emphasizing the
importance of understanding their functionalities and hierarchical structure. He discussed the
evolution of these classes, from the original Greek classes to the introduction of Swing, and
highlighted the benefits and drawbacks of each generation. Rony also touched on the concept of
events in Java GUI components, the use of event listeners, and the challenges of maintaining the
positions of GUI components during window resizing. Lastly, he demonstrated a simple Java program
using GUI components and compared it to a similar program in Recs, aiming to show that such programs
could be created without extensive Java programming skills.
Java Programming Introduction and Challenges
Rony provided a comprehensive introduction to Java programming, covering topics such as the import
statement, class definition, and the main method. He also explained the concept of a GUI and
demonstrated the creation of a simple GUI frame. Rony further discussed the origin and symbolism of
the Java programming language and demonstrated how to compile and run a simple Java program. He also
identified an issue with the program's closure, which remained an open question for the team.
Java Event Handling and GUI Programming
Rony explained the concept of event handling in Java, emphasizing the importance of implementing all
event methods and the use of event adapter classes to save coding time. He also discussed the
principles of GUI programming in Java, including the creation and handling of events, and the role
of the AWT thread in maintaining the GUI. A problem with the current Rex program that uses the Java
GUI system was identified, where the GUI shuts down immediately when the program ends. Rony proposed
a solution to synchronize the main Rex program with the state of the GUI and stressed the importance
of understanding the problem before implementing the solution.
Rexx Event Handling and Java GUI Implementation
Rony discussed the implementation of Rexx event handling in Java and the creation of a simple GUI
using Java's Abstract Window Toolkit (AWT) classes. He emphasized the importance of defining proper
orex classes for event handling, using adapter classes to handle multiple event methods efficiently,
and the consideration of selecting appropriate AWT classes and identifying events of interest. Rony
also demonstrated the compiled program and its reactions to user input, and highlighted the
necessity of defining Rec classes for each use and the need to synchronize the main Rex program with
the GUI part. He further discussed the implementation of various Rex classes in a Java program, the
functionality of the Regs class, and its methods.
Rexx Programs and Java Integration
Rony discussed the functionality and benefits of a program that runs unchanged on various operating
systems, including Windows, Apple, and Linux. He emphasized that the program, written in Rexx, does
not require knowledge of Java syntax and can be used to implement Java methods. Rony also
highlighted that the program's GUI behaves like a Java solution and that it's possible to create
Rexx objects that implement Java interface classes. He provided some helpful links for further
technical details and encouraged the attendees to explore the GUI examples.
Socket Programming and IP Addresses
Rony explained the fundamental concept of socket programming, using the analogy of a switchboard to
illustrate how programs communicate with each other. He detailed the function of TCP/IP sockets as a
switchboard with 65,536 ports, each numbered from 0 to 65,535, and highlighted the significance of
each computer having a unique IP address. Rony also introduced IP version 6 addresses, which offer a
much larger number range than IP version 4 addresses due to their 128-bit values.
Java Sockets and Domain Names Discussion
Rony discussed the use of Java for client-server programming via sockets, focusing on the concepts
of Internet addresses and domain names. He explained the limitations of Internet addresses and
introduced the name service program that allows computers to be identified using human-memorable
names. Rony also delved into the development of domain names, their commercialization, and their
role in locating computers. He demonstrated a Java program, 'Gethostinfo', which uses the Java class
to fetch an Internet address based on user input and emphasized the importance of the 'try-catch'
block for handling exceptions. Lastly, he introduced the 'java.net.Socket' class for connecting to a
computer via the Internet, requiring the IP address, host name, and port number.
Java Socket Class and Client-Server Programs
Rony explained the functionalities of the Java socket class and its role in establishing connections
between computers. He detailed the processes involved in creating a client-server program,
emphasizing the importance of clear communication protocols and the use of port numbers. Rony also
demonstrated the implementation of a simple server and client program using Java and Rexx,
illustrating how data is exchanged using byte arrays and specific Java classes. The program was run
live to show its efficiency.
Java Socket Server and Rex Client Communication
Rony demonstrated the communication capabilities between a Java socket server and a Rex client,
confirming that they could function independently of each other's programming language. He
emphasized the importance of data encryption to prevent eavesdropping, explaining that the standard
solution is to use the Transport Layer Security (TLS) protocol. Rony also highlighted that Java
offers built-in TLS support, which is not available in Rex. He advised the team to be aware of
potential security risks when using socket connections and to consider the implementation of TLS for
secure data transport.
Secure Encryption Infrastructure With Java
Rony discussed the implementation of a secure encryption infrastructure using Java's factory
classes, emphasizing the importance of using long-term support versions of Java for security
updates. He demonstrated how to set up system properties in Java to provide the certificate file's
location to the Java program, and how to use SSL/TLS in a secure manner. Rony also explained the use
of Java utility classes to wrap up streams into readers and writers, and to buffer data for exchange
between sockets. He concluded by encouraging further study of Java socket programming and the
available documentation, and reminded participants to submit their small examples via email.
/AI-generated content may be inaccurate or misleading. Always check for accuracy. /
--
--
__________________________________________________________________________________
Prof. Dr. Rony G. Flatscher
Department Wirtschaftsinformatik und Operations Management
Institut für Wirtschaftsinformatik und Gesellschaft
D2c 2.086
WU Wien
Welthandelsplatz 1
A-1020 Wien/Vienna, Austria/Europe
http://www.wu.ac.at
__________________________________________________________________________________
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. /
--
--
__________________________________________________________________________________
Prof. Dr. Rony G. Flatscher
Department Wirtschaftsinformatik und Operations Management
Institut für Wirtschaftsinformatik und Gesellschaft
D2c 2.086
WU Wien
Welthandelsplatz 1
A-1020 Wien/Vienna, Austria/Europe
http://www.wu.ac.at
__________________________________________________________________________________
Quick recap
The team discussed various projects, with Giorgia.Rosini presenting her ideas and Reggie presenting
a three-part project on creating mailing labels. Rony led a detailed discussion on the history,
applications, and syntax of Visual Basic and Rexx, as well as the use of the trace keyword,
function, and environment symbols. The team also addressed issues related to code pages, character
encodings, and the installation of Bsf for all Rex, with Rony providing guidance for troubleshooting
and installation.
Next steps
Georgia to send the 2 programs she demonstrated with a short description and Rex code to the email list.
Charlotte and Reggie to communicate and come up with 3 small project ideas using 2 Windows programs
controlled by a Rex program.
Charlotte and Reggie to try to demonstrate one of their project ideas in the next session if possible.
Prisca to check in with Rhoda on her status and catch up on missed content.
Peter to potentially work on a project to sort his movie directory and cast files to his TV.
All participants to complete 2 small homework examples based on the day's content (trace,
environment symbols, or BSF features if installed).
Reggie to complete installation of BSF for ORex following Rony's instructions.
All participants to review the code pages and Unicode content, especially if working with
non-English text.
All participants to be aware there is no class on Thursday due to a public holiday.
All participants to prepare for the next session focusing on Java integration with ORex.
Summary
Giorgia.Rosini's Projects and Team Experiences
Rony welcomed the team, including newcomer Reggie, and informed that Milos was unable to attend due
to illness. The main discussion revolved around three projects that Giorgia.Rosini and Milos had
been working on. Giorgia. Rosini presented her ideas to the team, which included creating
inspirational messages, utilizing data from a website to create an Excel chart and a pop-up
document, and connecting her email account and Outlook calendar to avoid missing appointments. Rony
appreciated Giorgia.Rosini's initiative and creativity, and Giorgia.Rosini agreed to send Rony the
programs and a description of what they do, along with the code, at a later date. The team also
discussed their experiences with the previous week's content, with Peter expressing his satisfaction
with the team's output.
Project Discussion and Visual Basic Transcription
Peter informed Rony that Kim's attendance was uncertain due to illness and caring for a new puppy.
Reggie then presented a three-part project aimed at creating mailing labels, which involved creating
a CSV file from the MS Outlook contact items, importing the CSV file into MS Access to create a
contacts database, and extracting the contact items from the database to print out the address
labels. Rony emphasized the value of Reggie's approach to breaking down the problem into three parts
and combining them with piping. Rony also suggested the use of a certain class that could help read
CSV files, which Reggie acknowledged and agreed to use. They discussed the reliance on internet
research for programming solutions, with Rony expressing caution about the reliability of
AI-supported systems. Rony encouraged Reggie to share his solutions online for others to benefit
from, provided he encountered no issues. Rony led a discussion on the potential of transcribing
Visual Basic code to Object Rexx (OoRexx), given the vast amount of Visual Basic solutions available
online. He emphasized the importance of understanding Visual Basic code and its benefits, such as
facilitating debugging and code page translation.
Visual Basic History and Applications
Rony discussed the history and applications of Microsoft's Visual Basic programming language. He
explained that Visual Basic was initially developed for the IBM PC and later became popular due to
its use in Microsoft Office applications. Rony also clarified the differences between various
versions of Visual Basic, including Visual Basic Script, Visual Basic for Applications, and Visual
Basic .NET. He further discussed the compatibility issues between these versions and warned against
using incompatible versions. Lastly, he touched on the development of an open-source .NET
implementation called Mono and its limitations compared to the Microsoft .NET.
Visual Basic and Rexx Syntax Comparison
Rony discussed the syntax and usage of Visual Basic and Rexx, highlighting their similarities and
differences. He explained the use of message operators, string concatenation, and the differences in
variable definitions. He also discussed the complexities of function invocation in Visual Basic and
the creation of Visual Basic macro code in applications like Excel, Word, or Outlook. Lastly, he
touched on the 'with' statement in Visual Basic, its potential for errors, and the benefits of
translating between the two languages.
Rony's Presentation and Slide Sharing
Rony led a break before resuming the meeting. Reggie confirmed receiving the slides from Georgia via
chat. Rony then uploaded additional slides about the environment and requested all participants to
keep their cameras on. The meeting continued with Rony sharing his screen for the discussion.
Exploring Trace Keyword and Function
Rony discussed the use of the trace keyword and function in the Rex programming language,
emphasizing its utility in understanding code execution and identifying errors. He also demonstrated
the use of the built-in random function in Python, illustrating how it can generate different
program outputs. Furthermore, he introduced the trace function, which provides detailed information
about the program's execution, and explained how to use it effectively, including how to turn on and
off intermediate tracing and how to reset it. He underscored the importance of the trace function in
understanding the results of a program.
Orx Runtime Environment and Symbol Resolution
Rony provided a detailed explanation of the Orx runtime environment and its symbol resolution
system. He discussed the role of the interpreter in managing the state of every program package, the
use of environment symbols to access entries in the environment directories, and how these symbols
can be used to check object existence and retrieve values. Rony also explained the Regs system,
which resolves environment symbols by looking for values in various directories, and emphasized the
importance of following a specific naming convention to avoid symbol conflicts. He concluded by
demonstrating how to use environment symbols to store and retrieve values.
Data Storage Protocol and Code Pages
Rony and Peter discussed the recommended protocol for data storage in Rex programs. Rony advised
Peter to use the local package directory for sharing data among different routines in the same
program and the environment for global data sharing across different interpreters. Rony then shifted
the discussion towards the historical background and current usage of code pages, explaining the
concept of the 7-bit ASCII code page and its limitations in representing non-English characters. He
also detailed the shift to 8-bit code pages in the PC world and its inability to fully represent all
the world's languages and characters.
8-Bit Code Page Issues and Solutions
Rony discussed the issues related to the variation of 8-bit code pages used in the DOS and Windows
worlds. He explained the potential problems that arise when text, encoded with one code page, is
read using a different one, leading to distorted and incorrect display of characters. Rony
emphasized the importance of understanding and correctly using the appropriate code page when
working with text, particularly in the context of the Unicode standard and its various encodings. He
also demonstrated the Rex program that showcases these issues and how to change the active codepage
using the 'chcp' command in a terminal window.
Rony Demonstrates Rex Program for Encoding Issues
Rony demonstrated a Rex program that highlighted the issue of code page problems in Microsoft Word,
specifically the incorrect display of characters due to incorrect encoding. He emphasized the
importance of correct encoding and introduced the Bsf.iconv() function for converting between code
pages. Rony also showed how to use the Bsf.Clipboard class from the Bsf.Tls package to automate
conversion and copy strings into the system clipboard. He clarified the UTF-8 encoding for certain
characters, such as the Smiley and Frowny, and confirmed that a Unicode UTF-8 encoded string
containing both a Smiley and Frowny was discussed.
Code Pages, Encodings, and Reflections
Rony discussed the importance of understanding code pages and character encodings, particularly
UTF-8, and the benefits of using the Java bridge for text handling. He also addressed Peter's
question about the Windows clipboard class's limitations and suggested using his Bsf dot clipboard
class as a solution. Rony clarified the public holiday schedule and encouraged participants to
master the new concepts presented. Additionally, Rony and Peter had a discussion about recent
terrorist attacks, the ongoing refugee crisis, and the complexities of the Israeli-Palestinian conflict.
Troubleshooting BSF Installation for Rex
Reggie had trouble installing Bsf for all Rex, but was successfully guided through troubleshooting
steps by Rony. The process involved unblocking the installation package, deleting the uncit
directory, and manually removing the directory with all its subdirectories. Rony also provided
instructions on how to access and install the Bsforex Zip Archive, including unblocking and
unzipping the archive, and navigating to the Bsf or Regs directory. Rony warned Reggie that the
installation process would alter the environment variable path and advised him to open a new
terminal window for the changes to take effect. If Reggie encountered any issues, he was to email
Rony for further assistance.
/AI-generated content may be inaccurate or misleading. Always check for accuracy. /
--
--
__________________________________________________________________________________
Prof. Dr. Rony G. Flatscher
Department Wirtschaftsinformatik und Operations Management
Institut für Wirtschaftsinformatik und Gesellschaft
D2c 2.086
WU Wien
Welthandelsplatz 1
A-1020 Wien/Vienna, Austria/Europe
http://www.wu.ac.at
__________________________________________________________________________________
Hi there,
here the link of today's recording:
* 240_AutoJava_AOO_LO_V04, Scripting Apache OpenOffice (AOO) and LibreOffice (LO)
using Universal Network Objects (UNO):
o Part 1 (ending at Windows problem):
<https://zoom.us/rec/share/IX9kS4a1mcCgmsHje4s9-0rguJC3JemeGT086KCTI0Y243Y52…>
o Part 2 (continuing from the above Windows problem):
<https://zoom.us/rec/share/IX9kS4a1mcCgmsHje4s9-0rguJC3JemeGT086KCTI0Y243Y52…>
Cheers
---rony
--
--
__________________________________________________________________________________
Prof. Dr. Rony G. Flatscher
Department Wirtschaftsinformatik und Operations Management
Institut für Wirtschaftsinformatik und Gesellschaft
D2c 2.086
WU Wien
Welthandelsplatz 1
A-1020 Wien/Vienna, Austria/Europe
http://www.wu.ac.at
__________________________________________________________________________________
Hi there,
here the link of today's recording:
* 220_AutoJava_gui, Portable GUIs for ooRexx Using BSF4ooRexx:
<https://zoom.us/rec/share/T0mUQt1gsVQN8A2Rhz1ZlOxK4a0HqH4kUPldg-2jzJOGiFTFw…>
* 230_AutoJava_Sockets, Sockets ("java.net", "javax.net"), SSL/TLS ("javax.net.ssl"):
<https://zoom.us/rec/share/T0mUQt1gsVQN8A2Rhz1ZlOxK4a0HqH4kUPldg-2jzJOGiFTFw…>
Cheers
---rony
--
--
__________________________________________________________________________________
Prof. Dr. Rony G. Flatscher
Department Wirtschaftsinformatik und Operations Management
Institut für Wirtschaftsinformatik und Gesellschaft
D2c 2.086
WU Wien
Welthandelsplatz 1
A-1020 Wien/Vienna, Austria/Europe
http://www.wu.ac.at
__________________________________________________________________________________
Hi there,
here the link of today's recording:
* 210_AutoJava_BSF4ooRexx, "BSF4ooRexx - The Bean Scripting Framework for ooRexx":
<https://zoom.us/rec/share/hUuXHnzkmIPTvA7r20ry0v3oLwpG0b594_s834iT4AAyw0NtG…>
Cheers
---rony
--
--
__________________________________________________________________________________
Prof. Dr. Rony G. Flatscher
Department Wirtschaftsinformatik und Operations Management
Institut für Wirtschaftsinformatik und Gesellschaft
D2c 2.086
WU Wien
Welthandelsplatz 1
A-1020 Wien/Vienna, Austria/Europe
http://www.wu.ac.at
__________________________________________________________________________________