Overview: The Real-Time Specification for Java (RTSJ) has been in use since 2001, and has been made available for application developers by several vendors since that time. 

The RTSJ was created to extend Java technology for use by embedded systems that are sensitive to event and response timing. Before the RTSJ was developed, the Java language already provided excellent support for many of the critical attributes of these applications, including:

• Machine independence - a Java program can run on any processor for which a Java Virtual Machine is available.
• Language Safety - Java syntax has been carefully designed to ensure that the large majority of programming errors will be caught at compile time rather than being left until execution time as is so often true for C and C++.
• Object Reference Safety - Java object references are always safe. A Java program is incapable of causing error such as a Segmentation Fault (Unix or Linux) or a General Protection Fault (Windows) because the Java language does not permit a program to create a reference that does not point to a correctly typed object nor does it provide any way to delete an object. Java objects are freed only when no references to them remain.
• Inherent Concurrency - The Java language includes the notion of concurrency as a first-class language construct. A Java thread can be created at any time, and can run independently of other Java threads. Priorities allow Java applications to request preference for some threads over others.
• Synchronization Support - Synchronization is an easy-to-use, first-class language construct that is built on the monitor model. The monitor synchronization model lets the language ensure that all uses of mutually exclusive resources will be protected, and is thus vastly safer than the semaphores and mutexes provided by most operating systems in the embedded world.

While these Java attributes are important to embedded Java applications, a number of inherent problems with standard Java exist that were addressed by the RTSJ:

• Unpredictable Delays - the Java language gives programmers no way to delete objects even if they are of no further use. This means that a "garbage collector" must run occasionally to search out all object references, and delete all objects that can no longer be referenced. One problem with garbage collectors is that it is difficult to predict when they will run, or how long they will run. Many garbage collectors can run for hundreds of milliseconds or longer. This can make the latency and response time of the program highly unpredictable.
• Unpredictable Scheduling - While Java supports threads, it has very weak semantics for scheduling control. In standard Java, thread priorities are not required to be honored; it is not necessary for a high priority thread to preempt a low priority thread. Thus, programmers cannot rely on priority, and must use other less appropriate tools to control thread scheduling.
• Unpredictable Synchronization - Java synchronization, while implementing a highly robust monitor model, includes no provision for controlling priority inversion. For example, while a high priority thread is waiting for a low priority thread to complete a synchronized block, the low priority thread may be preempted by any number of intermediate priority threads, resulting in unbounded priority inversion and highly unpredictable application response time, even for high priority threads.
• Unpredictable Event Handling - Standard Java programs cannot be directly triggered by signals or other externally generated events.

This webinar will consider all of these issues, including both the Java language's strengths and the weaknesses that are made manageable by the RTSJ. Specifically, this webinar will start with basic approaches to application design and architecture for time-constrained applications, consider how such designs and architectures can exploit the RTSJ capabilities, and discuss trade-offs among the various possible design approaches. Example snippets of Java code will be shown that deal with each of the issues discussed.

Why should you attend: This webinar will present architectural and design strategies for creating Java applications that can predictably support time-constrained and real-time requirements using the Real-Time Specification for Java (RTSJ). The RTSJ extends the Java language in various ways to support these applications, but it is not generally obvious how the RTSJ capabilities should be used for practical systems. 

This webinar will discuss each of the RTSJ capabilities and how (or whether) they should be used in practical systems. For example, how can a high priority event be handled in time without being impacted by interference such as garbage collection or other activities? How should objects be designed to manage concurrency? What is the best way to construct periodic threads? 

Attendees will understand each of the application design elements involved in time-constrained and real-time applications, how to construct them using the RTSJ, and how to ensure that they can meet both their functional requirements and their timing constraints. They will also understand the role of concurrency in application design and its importance in meeting time constraints. They will further understand the use of the RTSJ's real-time threads and real-time event handling to manage concurrency. 

Areas Covered in the Session:

• Time-Constrained Applications
• Java Benefits for Time-Constrained Applications
• Java Problems for Time-Constrained Applications
• Introduction to the RTSJ
• RTSJ Components
• Time-Constrained Application Architecture and Design
• Key Components of Time-Constrained Architectures and Designs
• How to Create Each Key Component Using the RTSJ
• Conclusions

Who Will Benefit:

• Software Engineers
• Software Architects
• Software Managers

Speaker profile:

Dr. Doug Locke is President and a full-time consultant for LC Systems Services Inc.. He has spent more than 40 years consulting for, and intimately involved with, the specification, architecture, design, and implementation of a wide range of real-time embedded systems (e.g., aerospace, naval systems, telecom, command and control, air traffic control, and industrial control systems). He is a frequent lecturer on architecture (systems and software), distributed real-time systems, software engineering (especially for time-critical applications), object oriented systems architecture, standards, and real-time scheduling theory and practice. He has actively participated in creation of many real-time standards including POSIX, Real-Time CORBA, Ada 95, Real-Time Java, and Safety-Critical Java.

Price List:
Live : $239.00
Corporate live : $479.00
Recorded : $289.00

Contact:
James Richard
Phone: 800-447-9407
Fax: 302-288-6884
Email ID: webinars@eitaglobal.com/ Support@eitaglobal.com

For more info click here