Exception Handling and Binary Mode

Exception Handling

• Exception: A problem requiring immediate attention to resolve, without which the program cannot continue.

• Exceptions in Java: Objects thrown upon problem detection, needing to be caught to prevent program crashes.

• Refer to: https://docs.oracle.com/javase/tutorial/essential/exceptions/

• As Koenig & Stroustrup stated in “Exception Handling for C++,” 1989:

  • Library authors can detect errors but may not know how to handle them.

  • Library users might know how to cope with errors but cannot detect them.

• Koenig & Stroustrup (1989) describe exception handling as a mechanism for one part of a program to inform another about detected exceptional circumstances.

• Exceptional Control Flow:

  • Exception thrown when a problem is detected.

  • Exceptions are caught using try-catch blocks.

  • Execution stack unwinds to find a handler.

Try-Catch

• Basic structure:
  java try { // risky code } catch (Exception e) { // respond to exception }

Kinds of Exceptions in Java

• Unchecked exceptions (aka errors):

  • The compiler does not enforce handling.

  • Generally indicate severe issues that crash the program.

  • Examples: OutOfMemoryError, StackOverflowError, NullPointerException

• Checked exceptions:

  • Methods must declare any checked exceptions they might throw.

  • Common in file IO or network interactions.

• All exceptions in Java are organized via inheritance.

Exception Hierarchy

The exception hierarchy includes Error, VirtualMachineError, OutOfMemoryError, Throwable, Exception, RuntimeException, IOException, NullPointerException, ArithmeticException, and IndexOutOfBoundsException.

Try-Catch-Finally

• try block: Contains risky code.

• catch block: Responds to exceptions.

• finally block: Code that runs at the end, regardless of exceptions.

• Multiple catch blocks can handle different exception types.

• Example:
  java try { // risky code } catch (IOException e) { // respond to exception } catch (Exception e) { // respond to exception }

Stack Unwinding

• If an exception is thrown but not caught in a scope:

  • The method terminates, and local variables are lost.

  • Control returns to the caller to find a catch block.

  • This repeats until caught or the main method terminates.

File IO and Exceptions

• File IO methods often throw IOExceptions, requiring try-catch blocks.

• All file access should be within a try/catch block to handle exceptions.

Try-With-Resources

• Java provides try-with-resources for automatic resource management.

• Resources declared next to try are automatically closed.

• Example:
  java try (FileWriter fw = new FileWriter(“myFile.txt”)) { // write data to file } catch (Exception e) { // respond to any exception }

Demos

• Mismatch.java: Generates InputMismatchException, ArithmeticException, and demonstrates try/catch.

• ReliableNextInt.java: Uses exception handling to retry until successfully reading an integer.

• Unwinding.java: Shows “stack unwinding”.

• OrderMatters.java: Demonstrates the importance of the order in which exceptions are caught.

• MyExceptionTest.java: Creating, throwing, and catching a custom exception.

Exceptions - Summary

• Exceptions represent “exceptional” problems needing immediate attention.

• Exceptions are thrown when a problem is detected.

• Exceptions are caught using try-catch blocks.

• The stack is unwound to find a handler.

Flow of Control

• Includes sequential, conditional, loop, call/return, and throw/catch (non-local) control flows.

IO Streams

Concept: Streams

• All IO in Java is derived from Byte Streams (sequences of 8-bit values).

• Base classes: InputStream and OutputStream.

• File-specific subclasses: FileInputStream and FileOutputStream.

• These classes provide low-level operations, often requiring more featured alternatives.

java.io.FileInputStream/FileOutputStream

• Classes for reading/writing byte streams.

• Methods include read(), reset(), skip(), close(), write().

• Can read individual bytes or arrays.

• More info: https://docs.oracle.com/en/java/javase/11/docs/api/ java.base/java/io/FileInputStream.html

Reading Streams

• The Scanner() class can read from the InputStream base class.

• Example: FileInputStream iStream = new FileInputStream("file.txt"); Scanner scnr = new Scanner(iStream);

Writing Streams

• FileOutputStream(): Base class for writing a byte stream to a file.

• PrintWriter(): Encapsulates the above for easier string usage (provides print(), println(), and format() methods).

Writing Text Files

• Example with writer:
  java FileWriter fw = new FileWriter("file.txt"); PrintWriter oWriter = new PrintWriter(oStream); oWriter.print("Hello, world!");

• Example with streams:
  java FileOutputStream oStream = new FileOutputStream("file.txt"); PrintWriter oWriter = new PrintWriter(oStream); oWriter.print("Hello, world!");

Binary Streams

• Binary mode streams can be more efficient than character mode in time and space.

• Example: The number 3.141592653589793:

  • As a double: 8 bytes

  • As characters: 17 characters * 2 bytes (unicode) = 34 bytes

• Reading as a character stream requires conversion from String to double, which takes more time.

Data Streams

• DataOutputStream and DataInputStream can write/read primitive values or Strings to a file using binary representation.

• Binary representation lacks lines, spaces, or tokens, necessitating a serialization strategy.

• More info: https://docs.oracle.com/javase/tutorial/essential/io/datastreams.html

Extended Example: Word Embeddings

• Represent words as vectors in high-dimensional space for natural language processing.

Vectors

• Sequential data structures like arrays.

• Represent coordinates in 2D, 3D, or N-dimensional space.

• Example:

  • $u = [3.5, 4.5]$$$u = [3.5, 4.5]$$

  • $v = [5.5, 2.0]$$$v = [5.5, 2.0]$$

  • $u + v = [9.0, 6.5]$$$u + v = [9.0, 6.5]$$

Dot Product

• Vector operation that returns a scalar.

• Formula: $$u \cdot v = u1v1 + u2v2 + \ldots + uDvD$$

• If:

  • $u = [3.5, 4.5]$$$u = [3.5, 4.5]$$

  • $v = [5.5, 2.0]$$$v = [5.5, 2.0]$$

• Then:

  • $u \cdot v = 3.5 * 5.5 + 4.5 * 2.0 = 28.25$$$u \cdot v = 3.5 * 5.5 + 4.5 * 2.0 = 28.25$$

• Length of vector:

  • $|u| = \sqrt{u \cdot u}$$$|u| = \sqrt{u \cdot u}$$

Similarity

• The dot product measures similarity between vectors:

  • $Cos(\theta) = \frac{u \cdot v}{|u| |v|}$$$Cos(\theta) = \frac{u \cdot v}{|u| |v|}$$

Distance

• The dot product measures distance between vectors:

  • $$|u - v| = \sqrt{(u1 - v1)^2 + \ldots + (un - vn)^2}$$

Example Embeddings

• Examples of word embeddings are shown in a 2D graph.

For More Info

• See the original paper: https://nlp.stanford.edu/projects/glove/

Example: Embeddings V1 (Text)

• File Size: 163MB

• Load Time (sec): 67.251

Example: Embeddings V2 (Text)

• File Size: 163MB

• Load Time (sec): 3.413

Example: Embeddings V3 (DataStream)

• File Size: 80MB

• Load Time (sec): 0.934

Example: Embeddings V4 (ObjectStream)

• File Size: 80MB

• Load Time (sec): 0.927

• 400,000 words, 50 floats per word (= 20 million floats).

Summary

• Exception Handling:

  • Control flow for unexpected conditions.

  • Handled with try/catch/finally, and throw.

• File IO:

  • Files contain streams of characters/bytes.

  • Large set of classes for different views.

  • Binary mode IO can be faster and more efficient.

Wrapping Up

• File IO isn't much more complex than regular IO (at least with plain text).

• Exceptions provide a new form of flow control for handling errors and exceptions.