CONTENTS

• General
• Java Standard Edition (SE)
• Java Enterprise Edition (EE)
• JBoss/Tomcat
• Java Virtual Machine (JVM)
• Software Development Process
• HTML
• Patterns
• Object Orientation
• UML
• WSDL
• JSPs/Servlets
• Databases
• XML
• Open Source Java Libraries and Frameworks
• Security
• Performance
• Operating Systems
• Links

• Abbreviations
  • R.S.S. Really Simple Syndication (used for subscribing to feeds from popular Web sites, e.g. news)

• Java Standard Edition (SE)
  • Object
    • The ultimate base class for all Java classes (i.e. the root of all Java class hierarchies)
    • Its finalize method is called by the garbage collector when it determines that there are no more references to an instance; overriding this method provides an opportunity to release resources (such as file descriptors or operating system graphic contexts) that might not be managed directly by the Java runtime; however, this method should not be used to perform essential activities since a Java program can terminate normally without garbage collection being invoked on a specific class instance
    • Object Equality
      • The check objRefA == objRefB will return true if both variables (objRefA and objRefB) reference the same object and false otherwise
      • The Object class provides an equals method for performing a deep comparison between objects, i.e. to determine object equality based on the contents of the two objects; the default equals behavior in the Object class is the same as the one described above, i.e. it returns true if the two variables reference the same object and false otherwise
      • However, specific subclasses implement their own equals behavior; for example, the String class implements equals such that string1.equals(string2) will return true even if the two variables point to distinct String objects as long as the two strings contain exactly the same sequence of characters
      • The Object class also provides a hashCode method used to specify a value that uniquely identifies an object; any class that provides its own implementation of equals should also provide its own implementation of hashCode so that certain Collection classes that use hashCode to determine object equality will behave as desired
  • Access Modifiers (in increasing order of visibility)
    • private: visible only inside the class
    • none/default: visible to classes in the same package
    • protected: visible to classes in the same package and subclasses in any package
    • public: visible to all classes (in any package)
  • General Modifiers
    • static
      • A field or method that is shared by all instances of the class
      • Static variables are, therefore, also known as class variables (as opposed to instance variables)
      • A static method can be used without instantiating the class and should, therefore, not use any non-static fields (i.e. instance fields)
    • final
      • In the context of a field, a constant
      • In the context of a class, a class that cannot be subclassed
    • abstract
      • A class that cannot be instantiated
      • An abstract class's methods may or may not be declared as abstract; abstract methods must be implemented by subclasses
      • Object references may be specified to be of an abstract type, in which case they must be bound to either null or a non-abstract object that extends the abstract type
      • Like an interface except that:
        • it can participate in a class hierarchy (an interface can participate only in an interface hierarchy, not in a class hierarchy)
        • it can provide a partial implementation
        • it can define non-abstract methods (all methods of an interface are implicitly abstract)
        • it can define methods with any level of access (all methods of an interface are implicitly public)
        • it can not participate in multiple inheritance (a class can subclass only one class but it can implement multiple interfaces)
        • it can declare and use fields (an interface can only declare static final constants)
        • it can define constructors
      • Typically defines the core ability of a class that extends it
    • interface
      • An abstract type that cannot be instantiated
      • Can define method signatures and/or fields (methods are assumed to be abstract; fields are assumed to be static final)
      • Object references may be specified to be of an interface type, in which case they must be bound to either null or an object that implements the interface
      • Like an abstract class except that:
        • it can not participate in a class hierarchy (an interface can participate only in an interface hierarchy, not in a class hierarchy)
        • it can not provide a partial implementation
        • it can not define non-abstract methods (all methods of an interface are implicitly abstract)
        • it can not define methods with any level of access (all methods of an interface are implicitly public)
        • it can participate in multiple inheritance (a class can subclass only one class but it can implement multiple interfaces)
        • it can not declare and use fields (an interface can only declare static final constants)
        • it can not define constructors
      • A class that implements an interface but fails to implement all the methods specified by the interface must be declared as abstract
      • Typically defines a peripheral ability of a class that implements it
    • synchronized
      • A method or block that is defined as synchronized will acquire a lock (exclusive access to the monitor) for the object (or class, in case the method is defined as static)
    • transient
      • Instance fields that are not automatically serializable
    • volatile
      • Informs the compiler that several threads might be simultaneously accessing this field (the data, therefore, always needs to be refreshed from memory rather than cached in a register)
    • native
      • Implies that the method is implemented elsewhere as platform-dependent code
    • strictfp
      • Implies that double and float expressions will be evaluated using FP-strict rules whereby intermediate results must be valid per IEEE standards
  • Passing Method Arguments
    • Objects are passed by reference; however, object references are passed by value
    • In other words, what is passed into methods are copies of references to objects, not copies of the objects themselves
    • Consider the following code:

      			Obj obj = new Obj();
      			do(obj);
      
      			void do(Obj objArg) {
      				...
      			}
      			

    • The object reference named objArg is a copy of the object reference named obj
    • However, obj and objArg both point to the same instance of Obj
    • Therefore, the reference is being passed into the method by value but, effectively, the object is being passed by reference
    • If the method do() causes objArg to point to a different instance of Obj, that change is not visible outside the do() method; i.e. obj continues to point to the original object
    • However, a modification made to the object referenced by objArg within the do() method is visible outside the do() method and is equivalent to making the same modification to the object referenced by the variable obj
    • Since primitives are not objects, they are simply passed by value
  • I/O
    • Streams are for byte-based I/O
    • Readers/Writers are for character-based I/O (i.e. multi-byte, formatted)
  • Exceptions
    • The hierarchy is as follows: Object(Throwable(Error, Exception(RuntimeException, CheckedException)))
    • The Java facility to allow for the handling of unwanted error conditions such that the program has an opportunity to cope/recover (take distinct corrective action, manage flow of control, log the error, and/or inform the user) and continue execution; (see also the assert facility which allows for the program to end execution upon the detection of a serious inconsistency such as an incorrect checksum; the assert checking can be turned on or off at runtime and is useful for debugging)
    • Managed via a try-catch-finally construct wherein the try block contains the program code (which might generate an exception), the catch block contains the code that will handle any exception that might be generated, and the finally block that can contain any cleanup code that might need to be executed prior to exiting the construct (this block will be executed regardless, even if some code prior to the finally block executes a return)
    • Java has two primary types of exceptions
      • Checked exceptions; subclasses of Exception; not preventable; represent conditions outside the control of the program; for example, bad user data input, database down, or network down (SQLException); when a method can throw an Exception (e.g. if it contains code that tries to execute some SQL), the exception must either be caught in the body of the method via a try-catch block or declared in the throws clause of the method declaration causing the exception handling to bubble up through the call stack (i.e. any method calling this method will need to either catch or throw the exception); termed checked exceptions because the compiler checks the code to ensure that these exceptions are being caught/thrown per the required rules; also known as user-defined exceptions
      • Unchecked exceptions; subclasses of RuntimeException; preventable; represent program defects, logic errors, or bugs; for example, IllegalArgumentException, NullPointerException, or IllegalStateException; termed runtime because they are thrown by the Java runtime, not by the program code
    • java.lang.ClassNotFoundException
      • Thrown when the classloader is unable to find the reported class, typically because the class is missing from the CLASSPATH
    • java.lang.NoClassDefFoundError
      • Thrown when the classloader is unable to find a class being accessed by the reported class within a static block or static member
  • Collections
    • There are nine collection interfaces
    • The base interface is Collection
    • Five interfaces extend Collection: Set, List, SortedSet, Queue, and BlockingQueue
    • Three other interfaces behave like collections but do not extend Collection: Map, SortedMap, and ConcurrentMap
    • Set (no duplicates) is implemented by HashSet (hash table), TreeSet (balanced tree), and LinkedHashSet (linked list and hash table)
    • List (ordered/sequenced, duplicates allowed) is implemented by ArrayList (resizable array), LinkedList (linked list), Vector, and Stack
    • Map (name-value pairs) is implemented by HashMap (hash table), TreeMap (balanced tree), and LinkedHashMap (linked list and hash table)
    • Use wrappers to add behavior such as synchronization
    • All collection iterators exhibit fail-fast behavior in the case of illegal concurrent modification
    • Skeletal implementations are provided by AbstractCollection, AbstractSet, AbstractList, AbstractSequentialList, and AbstractMap
  • The Java language supports four kinds of types: interfaces, classes, arrays, and primitives; the first three are known as reference types; class instances and arrays are objects, primitive values are not; a class's members consist of its fields, methods, member classes, and member interfaces; a method's signature consists of its name and the types of its formal parameters; the signature does not include the method's return type
    • Each primitive has a corresponding class type also known as a wrapper object; these primitive wrapper objectsare useful for various reasons such as storing constants such as the biggest and smallest values for each type, providing utility methods to convert to and from String types; additionally, some collections (e.g. java.util.SortedSet) operate only on the primitive wrappers, not on the primitives themselves
  • main()
    • The entry point into a program (i.e. a set of classes)
    • When Java is asked to execute class X, it will execute the main() method defined by class X
    • If class X does not define a main() method, then class X cannot be executed directly by Java
    • A main() method may not be declared to throw an exception since it is called directly by the Java virtual machine and there is no application Java method below it in the call stack that could handle the exception
  • Concurrency
    • There are two ways to create a thread:
      • Create a class that subclasses the class Thread and overrides the run() method; then instantiate this class and call its start() method
      • If the above is not possible because your thread class is already subclassing another class, then have your thread class implement the Runnable interface; this will force your thread class to implement the run() method; to start the thread, instantiate your thread class and pass it as an argument using code similar to the following: new Thread(instanceOfYourThreadClass).start();
    • The start() method creates the system resources necessary to run the thread, schedules the thread to run, and calls the thread's run() method; at this point the thread is in the "Runnable" state; this state is called "Runnable" rather than "Running" because the thread might not actually be running when it is in this state; many computers have a single processor, making it impossible to run all "Runnable" threads at the same time
    • A thread enters the "Not Runnable" state when one of these four events occurs:
      • Someone invokes its sleep() method
      • Someone invokes its suspend() method
      • The thread uses its wait() method to wait on a condition variable
      • The thread is blocking on I/O
    • A thread exits the "Not Runnable" state when one of these four events occurs:
      • If the thread had been put to sleep, then the specified number of milliseconds must elapse
      • If the thread had been suspended, then someone must call its resume() method
      • If the thread was waiting on a condition variable, then whatever object owns the variable must relinquish it by calling either notify() or notifyAll()
      • If the thread was blocked on I/O, then the I/O must complete
    • A thread dies when one of these two events occurs:
      • The run() method completes
      • Someone invokes its stop() method
    • The Java runtime supports a very simple, deterministic scheduling algorithm known as fixed priority scheduling; this algorithm schedules threads based on their priority relative to other "Runnable" threads
    • By default, a new thread inherits the priority of its parent thread; this priority can be modified at any time after its creation using the setPriority() method
    • Thread priorities are integers ranging between Thread.MIN_PRIORITY (1) and Thread.MAX_PRIORITY (10); the default is Thread.NORM_PRIORITY (5)
    • The Java thread scheduler uses a round-robin approach to choose between two equal priority "Runnable" threads
    • The chosen thread will run until one of the following five events occurs:
      • A higher priority thread becomes "Runnable" (preemptive thread scheduling)
      • The chosen thread dies
      • The chosen thread becomes "Not Runnable"
      • Someone invokes the chosen thread's yield() method and there are one or more "Runnable" threads of the same priority as the chosen thread (otherwise, yield() is ignored)
      • On systems that support time-slicing, the chosen thread's time allotment expires (the Java thread scheduler itself does not time-slice)
    • Although the above is standard, the thread scheduler may choose to run a lower priority thread to prevent starvation
    • A daemon is a special kind of thread that runs continuously, typically to execute a low priority background task or provide a service for other threads running in the same process; daemon threads exit when there are no non-daemon threads running in the process; the setDaemon(true) method is used to mark a thread as a daemon before it is started; an example is the garbage collector thread
    • Locks
      • A lock is also known as a mutex, semaphore (more accurately a binary semaphore), or monitor; there is no universal agreement on terminology
      • Multi-threaded applications require locks to ensure that non-reentrant code is executed by one thread at a time
      • Locks are implemented by using the "synchronized" keyword to mark blocks of code or entire methods representing non-reentrant code
      • There are two types of locks: a class-level lock and an object-level lock; all static synchronized methods share a single class-level lock; all non-static synchronized blocks and methods share a single object-level lock (i.e. one shared lock per class instance); a lock is ON if a thread is executing code managed by the lock and OFF otherwise
      • A lock is acquired upon entry into synchronized code and released upon exit, even if the exit occurs due to an exception
      • A lock on the "this" object is implictly obtained via synchronized blocks and methods; a lock on an arbitrary class C may explicitly be obtained via the construct synchronized(C.class)
      • A synchronized method can call itself recursively because the executing thread has already acquired the required lock; in other words, the lock is per-thread, not per-method-execution
      • In the case of block synchronization, the target object is supplied as an argument; the most common argument is "this", e.g. synchronized(this); method synchronization assumes that the target object is the object that owns the method (i.e. "this")
      • The synchronized modifier on a method is not considered part of the method signature and is, therefore, not automatically inherited when subclasses override methods from the superclass; accordingly, interface methods cannot be declared as synchronized; also, constructors cannot be qualified as synchronized although block synchronization can be used within constructors
      • A wait/notify scheme is used by multiple synchronized blocks in an object to coordinate thread execution
      • The object lock is turned ON once a thread starts to execute one of its synchronized blocks; others threads trying to access one of the object's synchronized blocks will be placed in a wait/suspended state
      • When a resource (or condition) required to complete a synchronized block is unavailable, the synchronized block uses the wait() method to place the currently executing thread on the wait list and release the lock
      • When resources become available, synchronized blocks use the notify() or notifyAll() methods to allow an arbitrary thread on the wait list to acquire the lock and proceed on with its work; notify() wakes one arbitrary thread on the wait list; notifyAll() wakes all threads on the wait list; regardless, only one thread can acquire the lock; the remaining threads must return to the wait list
      • There is an overloaded form of wait() that timesout after the specified time period has elapsed instead of waiting for notify() or notifyAll()
      • Although it might seem more efficient to use notify(), especially if all threads can be assumed to waiting on the same set of conditions, it is generally safer to use notifyAll()
      • In the following example, the put() and get() methods are synchronized in order to ensure that put() and get() take turns and that a get() always follows a put(); therefore, the value returned by get() will always be the same as the argument most recently used to call put(); this structure models a message queue of type int with a capacity of exactly one; i.e., nothing can be added to the queue via a put() until the currently stored item has been retrieved via a get(); the alternative to this scheme would be what is called a race condition, wherein threads would call get() and put() in an indeterminate order

        				public class IntMessageQueueOfCapacityOne {
        					private int contents;
        					private boolean available = false;
        
        					public synchronized int get() {
        						while (available == false) {
        							try {
        								wait();
        							} catch (InterruptedException e) { }
        						}
        						available = false;
        						notifyAll();
        						return contents;
        					}
        
        					public synchronized void put(int value) {
        						while (available == true) {
        							try {
        								wait();
        							} catch (InterruptedException e) { }
        						}
        						contents = value;
        						available = true;
        						notifyAll();
        					}
        				}
        				

      • The join() method can be used to detect when a thread dies and whether it dies normally or abnormally
    • The java.util.concurrent package implements a set of best practices, design patterns, and utilities analogous to the java.util.collections package
      • The Executor interface forms the basis for frameworks to enable thread pooling, scheduled and periodic task execution, returning results, and long-running threads that can be queried for completion and cancelled
      • The ConcurrentLinkedQueue, which is also part of the Java Collections Framework, enables multiple threads to share access to a common collection
      • Classes that implement common synchronization idioms, such as a counting semaphore
      • The java.util.concurrent.BlockingQueue class is based on a concept similar to IntMessageQueueOfCapacityOne described above
    • The dining philosopher problem is the classic illustration of thread starvation proposed by Edsger Dijkstra in 1971; five philosophers (threads) are sitting around a dinner table; there are five chopsticks, one between each pair of adjacent philosophers such that each philosopher has a chopstick to his left and a chopstick to his right; in order to eat, a philosopher must pick up both chopsticks, but can only pick up one chopstick at a time; if each philosopher picks up the chopstick to his left, all five philosophers will perpetually wait for the chopstick to their right to become available, thereby resulting in starvation (pun intended)

• Java Enterprise Edition (EE)
  • Web Applications
    • The directory structure of a web application (*.war)
      • WEB-INF: required; contains meta-information; its resources are available to the application but not to clients of the application
        • classes: loose classes; application servlets and utility classes; the application class loader loads these classes before it loads the JARs located in the lib folder; therefore, this is a good place to put modified classes during development in order to override the versions contained in the application JARs
        • lib: third-party and application JARs
        • web.xml: deployment descriptor
      • other folders such as jsp or those representing application components
    • Each web application deployed in a container has a single unique ServletContext (one per JVM in the distributed case)
    • The web.xml file defines:
      • Servlets
      • Servlet url pattern mappings
      • A welcome file list of default resources (useful if the default is different from the container defaults of index.html and index.htm)
      • Error pages for specific HTML error codes such as 404 (Not Found) and 500 (Internal Server Error)
      • Custom JSP tag libraries
      • Login configurations
      • Security roles
  • Java Persistence API (JPA)
    • A spin-off from the EJB 3.0 effort, this API attempts to bring together the best of Enterprise JavaBeans (EJB), Hibernate, TopLink, and Java Data Objects (JDO)
    • POJO-based
    • Uses source code annotations and/or XML descriptors
    • The query language is an extension of EJB QL
  • Web Services Technologies
    • SOAP with Attachments API for Java (SAAJ)
    • Java Architecture for XML Binding (JAXB)
  • Java Transaction API (JTA)
    • Best fit when your transactions span multiple resources/databases, overkill otherwise
  • Java Connector Architecture (JCA)
    • Standard framework for connecting J2EE application servers to enterprise information systems (EIS), typically a relational database management system (RDBMS)
  • Java Secure Socket Extension (JSSE)
    • SSL packages
    • javax.net.ssl
  • Java Message Service (JMS)
    • Channel: A destination for messages
    • Point-to-Point (P2P) Channel: A channel that can have only one consumer; also known as a queue
    • Publish-Subscribe (Pub-Sub) Channel: A channel that can have multiple consumers; also known as a topic
    • Hub and spoke architecture
  • Java Database Connectivity (JDBC)
    • Driver Types (in order of increasing platform independence and performance and decreasing deployment administration)
      • 1: JDBC-ODBC Bridge
      • 2: Native API, partly Java
      • 3: Net protocol, all Java
      • 4: Native protocol, all Java
    • Statement.addBatch(), Statement.executeBatch()
      • Improve performance by reducing the overhead of network latency
      • Each batched statement must have an int return type (i.e. cannot include select)
      • Results are in the form of an array of int
    • PreparedStatement ps = Connection.prepareStatement(String)
      • Parameterized statements
      • Improves performance for statements called repeatedly with slightly different parameters
    • CallableStatement
      • Used to execute stored procedures
      • Improves performance
      • Two forms of syntax
        • one that includes a result parameter: {?= call <procedure-name> [<arg1>,<arg2>,...]}
        • one that does not: {call <procedure-name> [<arg1>,<arg2>,...]}
      • The types of all result (output) parameters must be registered prior to statement execution
      • Parameter index starts at 1
      • Other paramters can be used for input, output, or both
    • Transactions
      • Local
        • For transactions spanning a single database
        • Connection.setAutoCommit(boolean)
        • Connection.commit()
        • Connection.rollback()
      • Distributed (XA)
        • For transactions spanning multiple databases
        • Uses the two phase commit (2PC) protocol
          • Commit phase one of the transaction
          • Wait for all databases to report a successful commit
          • If all databases report a successful commit, then commit phase two of the transaction; otherwise rollback
  • Enterprise JavaBeans 3.0
    • Adopts many of the best practices from Hibernate and TopLink

• JBoss/Tomcat
  • run -c <server-name>
  • Catalina: servlet engine

• Java Virtual Machine (JVM)
  • Java applications are delivered as binaries representing an intermediate, platform-independent format known as bytecode
  • Platform-specific JVMs are responsible for hosting Java applications and interfacing directly with the platform hardware
  • JVMs translate Java application bytecode into machine code specific to the relevant hardware platform
  • A JVM and the hosted Java application are generally launched together via a command-line per the following syntax:

    		java [-options] class [arguments]
    
    		or
    
    		java [-options] -jar jarfile [arguments]
    		

  • The above examples assume:
    • An instance of java.exe is either in the current directory or the path to an instance of java.exe is included somewhere in the system's environment variable called PATH
    • The class or jarfile to be launched is either in the current directory or the path to it is included in the system's environment variable called CLASSPATH
      • In the case of a class, the PATH must include an entry that points to the folder containing the class, e.g. c:\projects\bin
      • In the case of a jarfile, the PATH must include an entry that points to the folder and the jarfile, e.g. c:\projects\lib\myjar.jar
    • The class to be launched is fully-qualified (i.e. with package prefix, e.g. com.inventica.classname) and contains a main() method
    • The jarfile to be launched contains an application entry point defined as a fully-qualified classname with a main() method via the following construct in the Manifest.mf file included in the jarfile:

      			Main-Class: classname
      			

  • Some Java applications, e.g. Servlet containers, are designed to host other Java applications; container-hosted Java applications are not required to have a main() method since they are not launched directly by the JVM
  • JVM behavior can be modified via various available command-line options including the following:
    • Type "java" to view the complete list of standard options (prefixed with a hyphen)
      • client: meant to be used during development to achieve faster startup (resulting from fewer permanent bytecode to machine code compilations) at the expense of poorer runtime performance
      • server: meant to be used in production to achieve better runtime performance at the expense of slower startup (resulting from more extensive permanent bytecode to machine code compilations)
      • verbose:gc: log garbage collection activity; the format of the logged information is x->y(z), where x is the pre-collection used space, y is the post-collection used space, and z is the total space
    • Type "java -X" to view the complete list of non-standard options (prefixed with a -X)
      • bootclasspath: specifies the path to
      • noclassgc: disable garbage collection of class bytecode (as opposed to class intance objects) loaded into the JVM permanent memory space; it is generally better to disable class garbage collection since there is no way to know whether a singleton class, which might be holding application state, will be used again during the life of the application
      • mn<size>: size of the heap's young generation portion
      • loggc:<file>: location for the garbage collection log
      • incgc: enable incremental garbage collection; also known as the train algorithm; minimizes the pause time for each individual garbage collection cycle at the expense of overall garbage collection time
      • ms256m: minimum heap size
      • mx256m: maximum heap size
    • Advanced non-standard options (prefixed with a -XX:) comprise by far the majority fraction of total options but are poorly documented
      • Boolean options are turned on with -XX:+<option> and turned off with -XX:-<option>
      • Numeric and string options are set with -XX:<option>=<value>
      • UseConcMarkSweepGC: enable concurrent garbage collection for old generation
      • UseParNewGC: enable concurrent garbage collection for new generation
      • NewSize=128m: minimum young generation size
      • MaxNewSize=256m: maximum young generation size
      • SurvivorRatio=8: the ratio of the sizes of the Eden and Survivor generation areas
      • PermSize=64m: minimum permanent area size
      • MaxPermSize=128m: maximum permanent area size
    • JVM Options
  • The JVM's memory is partitioned as follows:
    • Permanent space used, among other things, for loading class bytecode (as opposed to class instances or objects)
    • Heap
      • The Sun JVM is generational; it organizes the heap into the following generations, ordered here by increasing age
        • Young Generation
          • Eden
          • Survivor 0 (also known as the from-space)
          • Survivor 1 (also known as the to-space)
        • Old Generation
          • Tenured
      • All objects are created in Eden
      • During "minor collection" objects are moved from younger to older generations as they survive each cycle of garbage collection
      • Premised on the idea that most objects die young, generational garbage collectors focus most of their activities on younger generations of the heap
      • During "major collection" the entire heap is processed using a mark-and-sweep approach; this is also known as a stop-the-world collection because all threads are suspended
      • The IBM JVM is non-generational
    • Stack, a LIFO data structure (one per thread) used for storing method calls and local variables
  • JVMs support various garbage collection algorithms
    • One or more of the following attributes (not mutually exclusive) can apply to each algorithm:
      • Stop-the-world: all threads are suspended during garbage collection
      • Concurrent: all threads are executing during garbage collection
      • Parallel: multiple threads are working on garbage collection
    • The following are the major algorithms with relevant attributes in brackets
      • Copying (stop-the-world): uses two semi-space storage areas; one is labelled the from-space, the other is labelled the to-space; each cycle copies live objects from the from-space to the to-space; then the from and to roles are reversed and the cycle continues; memory in the to-space is automatically compacted as a result of the copy; dead objects are not deleted, they are simply overwritten by new objects
      • Mark and Compact (stop-the-world): also known as mark-compact; takes two passes, one to mark objects as live or dead and another to move live objects to a new area
      • Mark and Sweep: takes only one pass to mark dead objects and add the space they occupy to free list; this algorithm tends to leave memory fragmented over time because it doesn't benefit from the compacting that results from copying
      • Incremental: also known as train; divides the heap into fixed-size blocks and processes one block per garbage collection cycle; low pause
      • Generational: see above; copying is preferred in the new generation area; mark-compact or mark-sweep is preferred in the old generation area
      • Modern JVMs use a combination of the above algorithms, e.g. concurrent-incremental-mark-sweep for the older generation areas and copying for the new generation areas
        • Low Pause
          • Parallel Copying (stop-the-world): similar to copying; defaults to one thread per CPU; configured via the JVM option -XX:ParallelGCThreads=4
          • Concurrent: all threads are running during garbage collection
        • Throughput: designed to maximize the size of the young generation area
          • Parallel Scavenge (stop-the-world): multiple threads work on garbage collection; enabled using the JVM option -XX:+UseParallelGC; should generally be used in conjunction with the JVM option -XX:+UseAdaptiveSizePolicy
          • Mark Compact
  • More on garbage collection
    • When a Java program is unable to initialize an object due to shortage of memory, the garbage collector will dispose all unreferenced objects in order to free memory
    • Java allows for the definition of weak references to objects; these references allow for objects to be garbage collected when memory is running low; weak references are a useful, for example, for building caches that can be flushed if memory gets low; actually, Java has three levels references - in order of decreasing strength - soft, weak, and phantom; the mechanics involves putting the object inside a java.lang.ref.Reference class (or subclass) instead of referencing the object directly using a variable; e.g. Reference myRef = new WeakReference (new MyClass());

• Software Development Process
  • Unified Software Development Process
    • A generic, non-proprietary version of RUP
  • Agile Software Development
  • Rational Unified Process (RUP)
    • A specific and detailed instance of the more generic Unified Software Development Process
    • Not a single concrete prescriptive process, but rather an adaptable iterative process framework, intended to be tailored by organizations and teams that select elements of the process that are appropriate for their needs
    • A framework is defined as a micro-architecture that provides an incomplete template for applications within a specific domain
    • Rooted in the spiral model proposed by Barry Boehm
    • Use-case-driven
    • Not to be followed blindly
    • Covers the entire software development lifecycle (SDLC)
    • Not frozen; alive and continuously evolving
    • Six Commercial Best Practices
      • Develop software iteratively
        • How do you eat an elephant? One bite at a time!
        • Helps to identify risk early in the software development lifecycle (SDLC)
        • Continuous integration; integration is generally the only time that risks are discovered and/or addressed
        • Meant to address a weakness in the waterfall methodology that pushes risk forward
        • Allows teams to account for changing requirements
        • At the time of delivery, the system has been running longer
      • Manage requirements
      • Use component-based architectures
        • A software component can be defined as a nontrivial, nearly independent, and replaceable piece of software; a module, a package, or a subsystem that fulfills a clear function, has a clear boundary, and can be integrated into a well-defined architecture; the physical realization of a set of interfaces
      • Visually model software
        • A model is a symantically closed abstraction of a system; it is a simplification of reality that completely describes a system from a particular perspective
        • We build models of complex systems because we cannot comprehend such systems in their entirety
        • Models help us better understand the systems we are modelling
        • Promotes unambiguous communication
        • Improves a team's ability to manage software complexity
        • Types of Models
          • Use-case
          • Business
          • Design
          • Analysis
          • Test
      • Continuously verify software quality
        • Automated testing
        • Quality is not added to a product by a few (quality assurance) persons; instead, it is the responsibility of every member of the development organization
        • Two areas of focus
          • Product
          • Process
      • Control changes to software
        • Change management is a systematic approach to managing changes in requirements, design, and implementation
    • Four Phases (IECT; several iterations per phase; produce a software generation; each iteration through the four phases is termed an evolution cycle)
      • Inception (prototyping; not necessarily subject to change management and configuration control)
      • Elaboration
      • Construction
      • Transition
    • Workflows
      • Business Modeling
      • Requirements
      • Analysis and Design
      • Implementation
      • Test
      • Deployment
      • Configuration and Change Management
      • Project Management
      • Environment
    • RUP suggests a 4+1 view model of architecture
      • Logical View (end-user functionality)
      • Implementation View (programmers; software management)
      • Deployment View (system engineering; system topology; delivery; installation; communication)
      • Process View (system integrators; performance; scalability; throughput)
      • Use-Case View (analysts; testers; behavior)

• HTML
  • Although multiple form tags can be included on a page, only one form can be submitted at a time

• Patterns
  • Interface Patterns
    • Adapter
      • Converts the interface of an existing class into a target interface that is desired by the user
      • There are two types of adapters
        • Class Adapter; wherein the adapter class subclasses the existing class and implements the target interface that is desired by the user
        • Object Adapter; wherein the adapter class subclasses the target interface class and delegates to the existing class
    • Facade
      • Provides a single point of contact for a subsystem and is responsible for collaborating with subsystem components
    • Composite
      • A composite is a group of objects in which some objects are leaves (i.e. they are stand alone objects) and others objects are in turn composites (i.e. they contain a group of objects)
      • The composite and the leaf share the same interface
      • This pattern lets clients treat an individual object and a group of objects uniformly
      • Therefore, an individual object exhibits the same behavior as a group of objects
      • This is accomplished by defining a common type for an individual object and a group of objects
      • For example, the getCount() method might be appropriate behavior for both an individual object (which will return 1) and a composite (which will return a total count)
      • An example of a composite is a directory tree
      • Another example of the composite pattern is the implementation of TestCase and TestSuite in JUnit. Both classes implement the Test interface. When you add an object to TestSuite, you're free to add either implementation of Test, i.e. TestCase or TestSuite (which may in turn contain a set of TestCases and/or a set of TestSuites)
      • Composites lend themselves to recursive behavior; but recursion should only be undertaken after confirming that the composite is a tree, i.e. each node except for the root has one and only one parent (the node that refers to it)
    • Bridge
  • Responsibility Patterns
    • Observer
      • Defines a many-to-one dependency between objects so that all the observers are notified when the observed object changes state
      • An example of the observer pattern is JUnit's TestRunner registering as a TestListener with the TestResult
      • Other examples include most event listeners (e.g. mouse and keyboard events)
    • Singleton
      • Ensure that a class is instantiated only once; typically implemented by making all constructors private and providing a public getInstance() method that creates an instance only if one does not already exist
      • Singletons typically hold state information that has application-wide scope
    • Mediator
      • Java Swing applications commonly apply this pattern, registering a single object to receive all GUI events
    • Proxy
      • A remote representative of the actual class
  • Operation Patterns
    • Command
      • Encapsulate a request as an object (rather than a method call) in order to separate the request for a service from its execution
      • This pattern allows for the scheduling of requests and storage of request objects for later undo operations
      • This pattern also allows for runtime determination of the actual methods to call in response to client requests
      • Menuing systems typically offer a good application for this pattern
      • Offers an alternative to other patterns such as Mediator and Template Method
      • An example of the command pattern is JUnit's use of the Test interface to provide a common run() method
    • Strategy
      • An alternative to subclassing
      • Each strategy is represented by a distinct class
      • All strategy classes implement a common interface
      • A factory is typically used to determine the appropriate strategy at runtime
      • This is the approach used to extend the behavior of the final class java.net.URL
      • Protocol handlers are the strategies and the URL class is the context through which a strategy is selected
  • Extension Patterns
    • Decorator or Wrapper
      • A more robust alternative to inheritance/subclassing; especially recommended if the wrapped class is not in the same package or is not designed for extension
      • Combines composition and forwarding to extend an object's behavior
      • Allows for an object's behavior to be composed dynamically
      • Used extensively by Java's I/O classes
      • Each I/O stream object typically wraps another stream object to which it forwards its operations
      • Decorator objects typically implement their operations by relying on the decorator object passed into them via their constructors
      • For example, the GZIPOutputStream class takes in an OutputStream object via one of its constructors; it adds compression behavior to the OutputStream behavior it wraps
      • This pattern allows for the assembly of functionality using an existing hierarchy of cooperating classes (behaviors) rather than creating a new class for each behavioral combination
      • One caveat is that wrapper classes are not suited for use in callback frameworks, wherein objects pass self-references to other objects for later invocations or callbacks; because the wrapped object doesn't know of its wrapper, it passes a reference to itself (this) and callbacks elude the wrapper class; this is known as the "self problem"
    • Visitor
      • This controversial pattern, useful mostly in language compiler development, leverages the double dispatch technique to allow for the definition of new operations on a class hierarchy without changing the hierarchy classes
  • Construction Patterns
    • Factory Method, Concrete Factory, or simply, Factory
      • Commits to an interface for instantiating an implementation of an abstract type (interface or abstract class) while retaining control of which implementation to instantiate based on an outside factor such as the environment, a property, the classpath, or state information
      • The Factory returns an implementation of the abstract type typed as the abstract type (as opposed to typed as the implementation of the abstract type)
      • The iterator() method, implemented by all Java collections, is an example
    • Abstract Factory
      • Sometimes the outside factor, mentioned under the Factory Method pattern, can be thematic, running across several classes
      • An example of such an outside factor might be country or region
      • This pattern often involves parallel hierarchies (families) of classes, e.g. one per country or region, that implement the same set of interfaces
      • In such cases the Abstract Factory pattern helps to determine which family or hierarchy of related or dependent objects to create
      • An abstract class serves as the Abstract Factory and determines the family of classes to create
      • Concrete subclasses of the abstract factory, one per family, serve as Factory Methods or Concrete Factories
      • A similar approach is used by the java.awt.Toolkit class, which is an Abstract Class Abstract Factory for creating families of GUI widgets for different operating systems and their GUI subsystems
  • Other Patterns
    • Inversion of Control
      • Extraction of dependencies
      • The user of the service and the service (e.g. Servlet or EJB container or database driver) are wired together not in code but in an XML configuration file
      • Removing the creation of all object instances for which the class is not directly responsible and passing into the class any object instances (dependencies) it needs; the dependencies may be passed to the dependent class using constructors, setters, or method parameters
      • Also known as the Hollywood Principle: "Don't call us, we'll call you."
    • Dependency Injection
      • A way to achieve IoC
      • A third party (e.g. Spring) initializes the user object and assign it its service dependency (e.g. database driver)
    • MVC (Model-View-Controller)
      • Also known as Model 2 and recommended for medium and large applications
      • (Model 1 represents a non-MVC approach that does not provide for a clean separation between the model, view and controller; Model 1 might be appropriate for small applications)
      • Divides an interactive application into three parts: model, view, and controller
      • The model component is the domain or business logic software layer that encapsulates core data and functionality and is independent of specific view representations; in Java, the model is typically implemented as a set of POJOs, JavaBeans, or Enterprise JavaBeans (EJBs)
      • View components represent the user interface elements that obtain data from the model and display information to the user; there are typically multiple views of the model; in Java, views are typically implemented as JSPs
      • One or more controllers serve as workflow objects that map user actions to business operations and select the view to return to the client based on the request and other state information; in Java, controllers are typically implemented as servlets
    • Virtual Proxy
      • Used to implement lazy initialization
      • The virtual proxy stands in for the actual class and initializes the actual class only when needed
    • Collecting Parameter (Smalltalk Best Practice Patterns by Kent Beck)
      • When you need to collect results over several methods, you should add a parameter to the method and pass an object that will collect the results for you
      • An example is JUnit's TestResult class

• Object Orientation
  • Aggregation
    • A term describing the part-of relationship
  • Composition
    • A stronger form of aggregation whereby the part object may belong to only one whole
    • The parts live and die with the whole, e.g. a cascading delete
  • Generalization
    • A parent class is said to be the generalization of its subclass
  • Inheritance
    • A subclass or child class inherits the behavior of its parent class
    • This is a good approach to use if the parent class is in the same package or if the parent class is specifically designed for extension; otherwise, composition is often a more robust option
    • Inheritance propagates any flaws in the superclass's API, while composition allows for the design of a new API that hides these flaws
    • Inheritance violates encapsulation because the subclass depends on the implementation details of its superclass
    • For example, if the superclass acquires a new method in a subsequent release and the subclass already has a method with the same signature and a different return type, then the subclass will no longer compile; alternately, if the previously existing subclass method has the same return type as the new superclass method, then the subclass will override the superclass method without intending to do so
  • Realization
    • A broader form of generalization
    • Indicates that one class implements the behavior specified by another
    • Subclassing may or may not be involved
    • The realizing class must conform to the interface of the realized class
  • Enumeration
    • To enumerate means to specify individually
    • An enumerated type is one where we specify individually (as words, as opposed to index numbers) all the legal values for that type
    • For example, a non-enumerated DaysOfTheWeek type might contain the index values 1 to 7
    • An enumerated version of the above example might contain the values Mon, Tue, Wed, etc.
  • Polymorphism
    • The ability of a program to automatically invoke the appropriate subclass at runtime even though at compile time the program references different subclasses via their generic superclass

      			/* Assume that Circle and Triangle are subclasses of Shape */
      			Circle c = new Circle();
      			Triangle t = new Triangle();
      			/* Here, instances of Circle and Triangle are being upcasted
      			   to Shape
      			*/
      			Shape[] shapes = {c, t};
      			/* In the following snippet of Java code, Java does not know at compile
      			   time whether shapes[i] is an instance of Circle or Triangle
      
      			   Polymorphism ensures that Java does not *need* to know this
      			   statically, i.e. at compile time
      
      			   Obviously, calculateArea() will be implemented differently by the
      			   subclasses of Shape, i.e. Circle, Triangle, etc.
      
      			   However, the compiler does not need to check what subtype of Shape
      			   it is dealing with and bind to the method of the appropriate subclass,
      			   i.e., Circle.calculateArea(), Triangle.calculateArea(), etc.
      
      			   Instead, Java will automatically determine at runtime that shapes[1] is
      			   an instance of Triangle and use dynamic binding (also known as
      			   late binding or runtime type identification RTTI) to bind the method
      			   call to Triangle.calculateArea()
      
      			   Since every sublclass of Shape has the ability to calculate its area,
      			   this program invokes Shape.calculateArea() without worrying about the
      			   specific subclass at hand
      
      			   Thus, polymorphism allows the following code to be more extensible since
      			   it will not impacted when new subclasses are added to the Shape hierarchy
      
      			*/
      			for (int i = 0; i < count; i++) {
      				System.out.println(shapes[i].calculateArea());
      			}
      			

  • Liskov Substitution Principle (LSP)
    • Any situation that requires an instance of class X can be satisfied with an instance of a subclass of class X; e.g. a situation that requires an object of type vehicle can be satisfied with an object of type car; basic LSP compliance is built into most OO languages such as Java
  • Law of Demeter

• UML
  • Class Diagrams
    • use to depict class details and inter-class relationships
    • class inheritance: use a solid line and a closed, hollow arrowhead to point to the superclass
    • interface implementation: use a dashed line and a closed, hollow arrowhead to point to the interface
    • class association (reference) with multiplicity and navigability: use a solid line with numbers at both ends and open arrowheads at either end
    • non-object (static) reference or interface association (reference) with multiplicity and navigability: use a dashed line with numbers at both ends and open arrowheads at either end
    • use a stereotype to label an interface: <<interface>>
    • aggregation: use a hollow diamond to point from class A to class B such that (for example) a field in A is a collection of objects of type B
    • composition: use a filled diamond to point from class A to class B such that A contains B
    • fields and methods
      • Use a + prefix to indicate public
      • Use a - prefix to indicate private
      • Use a # prefix to indicate protected
      • Use an underline to indicate static
  • Sequence Diagrams
    • use to depict runtime method call sequences; one per use-case
    • use a stereotype to label object creation: <<create>>

• WSDL
  • types
    • Uses the XML schema language to define complex data types and elements that are used elsewhere in the WSDL document
  • import
    • Imports WSDL definitions from other WSDL documents
  • message
    • I/O types
    • Describes the message's payload using XML schema built-in types, complex types, or elements defined in the WSDL document's "types" element, or defined in a WSDL included via an "import"
  • portType and operation
    • interface and methods
    • Analogous to Java interface and method declarations
    • operation uses one or more "message" types to define input and output payloads
  • binding
    • protocol and encoding
    • assigns a portType (interface) and its operation elements (methods) to a particular protocol (e.g. SOAP) and encoding style (e.g. literal)
  • service
    • IP address
    • assigns an Internet address to a "binding"

• JSPs/Servlets
  • Deployment
    • JSPs are typically deployed as text files and compiled into Servlets at runtime
    • Servlets are deployed as binary files
  • Data Sharing Options (listed in the order of increasing scope and lifespan)
    • PageContext: page scope
    • HTTPServletRequest: request scope
    • HttpSession: session scope
    • ServletContext: application scope
  • Forward versus Redirect
    • Forward happens on the server-side
    • Redirect happens with the knowledge of the browser
  • HttpServletRequest attributes versus parameters
    • attributes are name-value pairs passed in via Java wherein the values are objects
    • parameters are name-value pairs passed in via HTML forms wherein the values are Strings (parameters are read-only on the Java side)
  • JSP include directives such as <%@ include file="copyright.inc"%> are processed at translation/compile time
  • JSP include actions such as <jsp:include page="copyright.inc"/> are processed at runtime
  • Tags
    • Bodyless: used to perform simple actions such as rendering HTML fields or displaying images; specify attributes but no content, e.g. <tagName attributeName="attributeValue"/>
    • Tags with a body: used to perform operations on the content, such as iterating over a collection; have start tag, a matching end tag, and some content in between, e.g. <tagName attributeName="attributeValue">content</tagName>
  • JSP Custom Tag Libraries
    • Sets of JSP custom tags grouped together from a packaging perspective
    • Prevent code duplication, promote reuse and separation of presentation logic (HTML) from business logic (Java)
    • Components
      • Tag handler
      • Tag library descriptor file (WEB-INF/*.tld): includes the tag name, required and optional attributes, and the fully-qualified tag handler class name
      • Referenced in the application deployment descriptor file (web.xml): includes the tag library URI and path to the corresponding *.tld file
      • Declared via an include directive in the JSP page where it is used; the directive contains a URI that must match the URI specified in web.xml
    • Tag handlers
      • The functionality exists in Java classes called tag handlers
      • A tag handler implements one of several custom tag interfaces depending on the type of tag
      • Tag handler classes have access to all JSP resources such as PageContext, HTTPServletRequest, HTTPServletResponse, and HTTPSession
      • Behavior may be customized using tag attributes
    • Libraries
      • Particularly useful JSP custom tag libraries include the Jakarta Taglibs project and JSPTags.com
      • The JSP Standard Tag Library (JSTL) is supported by all compliant containers and consists of the following five categories of tags:
        • Core: related to epxressions, flow control, and a generic way to access URL-based resources
        • Internationalization: divided into two groups: messaging and formatting
        • XML: XPath-based access to XML documents
        • SQL: direct access to JDBC resources, including querying and updating, for quick prototyping and simple applications
        • Functions: extend the capabilities of the JSP 2.0 expression language (EL)
      • JSTL is available in two versions JSTL-RT (the pre-EL version) and JSTL-EL
  • JavaBeans
    • JavaBeans may be accessed via the <jsp:getProperty> action
    • For example, a reference to a property named "firstName" is converted into the method call getFirstName()
    • For example, a reference to a nested property named "user.address.city" is converted into the method call getUser().getAddress().getCity()
    • For example, a reference to "address[2]" is converted into the method call getAddress(2)

• Databases
  • Primary key is a column or group of columns in a table that uniquely identifies every row in the table
  • Foreign key is a column in one table that is a primary key in some other table
  • Referential integrity is the requirement that all foreign keys are present in the table where they are primary keys
  • Normal Forms
    • First
      • All columns are atomic
      • Each table has a primary key composed of the minimal set of columns that uniquely identify a row in the table
    • Second
      • Every non-key column is fully dependent on the primary key
    • Third
      • All non-key columns are mutually independent
  • Transactions
    • Sets of operations that form a single larger logical operation, e.g. a transfer of funds from account A to account B involves a debit from A followed by a credit to B
    • ACID
      • An acronym representing the four properties of a reliable transaction
        • Atomicity
          • Either all or none of the parts of a transaction will be completed
        • Consistency
          • The database will be in a legal state (e.g. integrity constraints) both before and after a transaction
        • Isolation
          • Each transaction will be isolated from all other transactions, i.e. no operation outside a transaction can see data in an intermediate state (e.g. account A has been debited but account B has not yet been credited)
        • Durability
          • Once the user has been notified, the transaction will persist and cannot be undone
  • SQL (The Oracle implementation/extension is discussed here; also known as PL/SQL)
    • DDL (Data Definition Language)
      • For example, CREATE, ALTER
    • DML (Data Manipulation Language)
      • For example, SELECT, INSERT, UPDATE, DELETE
    • GROUP BY
      • Generally used to group rows based on a certain column value (e.g. grp_id) in conjunction with an aggregate function (e.g. count, min, max, sum, avg); e.g. select grp_id, count(*) from pas_rpt_list group by grp_id
    • HAVING
      • Used in conjunction with GROUP BY to limit the results, generally using a clause involving the aggregate function; e.g. select grp_id, count(*) from pas_rpt_list group by grp_id having count(*) > 69
    • TRUNCATE
      • Used to unconditionally delete all rows in a table with minimal overhead
      • Faster than a DELETE because
        • No information is stored in the rollback segment (therefore COMMIT and ROLLBACK do not apply)
        • No information is logged in the redo log
        • Indexes are updated as a single operation (as opposed to once for each row in a DELETE)
    • Full Table Scan Versus Indexes
      • A full table scan is generally slower than using an index unless the query is accessing more than 5%-10% of the table's rows
      • A full table scan reads every row of data into memory, starting with the "lowest" (first) block (the basic unit of data storage) and going upto the "highest" (last) block or the high-water-mark
      • Rebuilding tables may improve the performance of full table scans because rebuilding the table adjusts the table's high-water-mark to the highest block in the table that has ever held data
      • The performance of a full table scan can also be improved by squeezing more rows into each block by reducing PCTFREE and increasing PCTUSED
    • Optimizer
      • Three primary modes of operation: RULE (rule-based optimizer or RBO), COST (cost-based optimizer or CBO), or CHOOSE
      • The default optimizer mode is set via the optimizer_mode parameter in the init.ora file and can overridden at the query and session levels
      • RBO tends to favor using indexes
      • CBO incorporates many of the RBO features and additionally considers statistical information pertaining to the volume and distribution of data within the tables and indexes; only effective to the extent that the tables and indexes have been recently analyzed and the statistics are accurate
      • CHOOSE invokes the CBO if the table and index statistics are current and the RBO otherwise
    • Corelated Subquery
      • Wherein the subquery refers to values in the parent query
      • Can return the same result as a join, but can be used where a join cannot, e.g. UPDATE, INSERT or DELETE
    • Join (combining two or more tables based on the equality of one or more columns common to all tables)
      • Inner (intersection)
      • Outer (union)
      • Anti (union minus intersection); implemented using NOT EXISTS or NOT IN
      • Self (joining a table to itself); used in case of a recursive relationship; accomplished via using multiple aliases for the same table
    • Set Operations
      • UNION, INTERSECT, MINUS
      • Require that the component queries return the same number of columns and that those columns have compatible datatypes (joins do not have these restrictions)
      • Typically used against two subsets of the same table
    • Bind Variables
      • Reduces parsing for SQL that needs to be executed repeatedly with different parameters
      • Prefixed with a colon and specified at runtime elsewhere via the programming language
    • Indexes
      • B-tree (default)
        • A B-tree is a tree data structure that keeps data sorted and allows searches, insertions, and deletions in logarithmic amortized time
        • A header block contains pointers to the appropriate branch block for any given range of key values
        • Branch blocks point to leaf blocks
        • A leaf block contains a list of key values and ROWIDs (row identifiers)
      • Bitmapped
        • Suitable for columns with few distinct values
      • Composite
        • Made up of more than one column with a maximum of 16 columns
        • Used only if the WHERE clause references the leading columns in the index
      • Each index contributes to a degradation in DML performance (INSERT, DELETE) and should, therefore, only be created if it significantly improves query performance (SELECT, UPDATE)
      • Indexes are disabled if a column is subjected to any modification, e.g. UPPER(column_name), column_name+1, IS NULL, !=, NOT IN, LIKE '%SMITH' (with a wildcard in the first position)
      • If the WHERE clause uses the column of only one index, Oracle performs a range scan on it to retrieve the ROWIDs of the selected rows and then accesses the table by these ROWIDs
      • If the WHERE clause uses columns of more than five indexes, Oracle performs an index merge; when performing an index merge, Oracle retrieves rows from each index matching the appropriate condition; rows that are common to all lists are returned
    • NULL
      • Indicates a data item that is missing or undefined
      • When an indexed column is NULL, that row will not have an entry in the index; i.e., NULLs are not indexed; when possible, define indexed columns as NOT NULL
      • Arithmetic operations (=, !=) cannot be performed on NULLs, i.e. two NULLs are neither equal nor not-equal
    • Query Explain Plan
      • Indicates the access path Oracle intends to take to execute the query
      • The more indented a step in the query plan, the earlier it is executed
      • Of two equally indented steps in the query plan, the uppermost is executed first
    • SQL Trace
      • Produces a query explain plan along with additional information such as CPU cycles, I/O requirements, and number of rows processed in each step
      • Enabled via the execution of the following statements
        • ALTER SESSION SET SQL_TRACE = TRUE
        • ALTER SESSION SET TIMED_STATISTICS = TRUE; optional; default is FALSE
        • MAX_DUMP_FILE_SIZE = <N>; optional; default is 500
        • USER_DUMP_FILE_SIZE = <DIRECTORY_PATH>; optional
        • The resulting file will be named ORA.TRC or ORACLE_<SID>.TRC
      • Once the trace file is found, a useable file is created via the command TKPROF <TRACE_FILE> <OUTPUT_FILE>
      • All of the above can be achieved more easily via the command SET AUTOTRACE ON
    • View
      • A virtual table representing the result of a database query
      • Whenever an ordinary view's table is queried or updated, the database converts these into queries or updates against the underlying base tables
    • Materialized View
      • A view wherein the query result is cached as a concrete table that may be updated from the original base tables from time to time
      • This enables much more efficient access, at the cost of some data being potentially out-of-date
      • It is most useful in data warehousing scenarios, where frequent queries of the actual base tables is extremely expensive
    • PL/SQL
      • Oracle's proprietary procedural extension to SQL
      • PL/SQL programs consist of blocks, which have the following structure
        • DECLARE -- Optional declaration of variables, constants, collections (arrays), and user-defined types (UDTs)
        • BEGIN -- Actual program
        • EXCEPTION -- Exception handling code for pre-defined and user-defined exceptions
        • END /* End of program */
      • The following syntax is used to select the result of a query into a variable: SELECT INTO <VARIABLE_NAME> FROM <FROM_CLAUSE> WHERE <WHERE_CLAUSE>;
      • The following syntax is used to declare a UDT: TYPE <TYPE_NAME> IS RECORD (<SUB_TYPE_1> <TABLE_NAME>.<COLUMN_NAME_1>%<PL_SQL_TYPE_NAME>, <SUB_TYPE_2> <TABLE_NAME>.<COLUMN_NAME_2>%<PL_SQL_TYPE_NAME>);
      • Triggers fire upon pre-defined DML events
      • Stored procedures (functions, procedures, triggers, and packages) are compiled entities that perform DML
      • Cursors are pointers to result sets that can be used to iterate through the result set
  • Transactional versus Data Warehouse
    • Large databases are broadly divided into two types: transactional and data warehouse
    • Transactional
      • Used for day-to-day business operations
      • Also known as online transactional processing (OLTP)
      • Typically highly normalized to support easy data insertion
    • Data Warehouse
      • Used for aggregated data views for decision support (management reporting)
      • Typically highly denormalized for easy retrieval and in the form of a star schema
      • One or more fact tables are at the center of the star schema
      • Several dimension tables surround the fact tables at the center of the star schema
      • Fact tables contain numeric data (e.g. sales total for the month) and foreign keys to the dimension tables (e.g. sales location, sales product)
      • Dimension tables contain peripheral details (e.g. the sales location table might contain address street, address city)

• XML
  • APIs
    • Document Object Model (DOM)
      • Represents an entire XML document tree, fully held in memory
      • Allows random access to an XML document
      • Suitable for processing small documents; performance-prohibitive for large documents
    • Simple API for XML (SAX)
      • Presents a view of an XML document as a sequence of events, one for each XML begin and end tag in the document
      • Lightweight; not memory intensive
      • Suitable for processing large documents
      • Does not support modifying the XML document
      • Does not allow random access to the XML document

• Open Source Java Libraries and Frameworks
  • Apache Software Foundation
    • Avalon
      • Started in 1999 as the Apache Server Framework
      • Provided a framework for component and container programming
      • Pioneered the use of design patterns such as Inversion of Control (IoC) and Separation of Concerns (SoC)
    • Batik
      • A toolkit for working with Scalable Vector Graphics (SVG) to generate, manipulate, transcode, and search
      • SVG is a W3C recommendation that defines an XML grammar for rich 2D graphics that include features such as transparency, arbitrary geometry, filter effects (shadows, lighting), scripting, and animation
      • Used by Oracle's JDeveloper 9i, JFreeChart, Borland's (formerly TogetherSoft) Control Center UML toolkit, and Apache Cocoon
    • Cocoon
      • A Web development framework built around the design patterns of Separation of Concerns (SoC) and component-based Web development
      • Uses the concept of component pipelines, each component in the pipeline specializing on a particular operation
      • Uses a Lego-like approach to building Web solutions, hooking together components into pipelines without requiring much programming
      • Used by Apache Lenya, an XML-based content management system (CMS)
    • Bean Scripting Framework (BSF)
      • Provides scripting language support within Java applications and access to Java objects and methods from scripting languages
      • Supported scripting languages include JavaScript, Python, Tcl, and XSLT
    • Xalan
      • An XSLT processor for transforming XML documents into HTML, text, or other XML document types
      • Implements XSL Transformations (XSLT) and XML Path Language (XPath)
      • Implements interfaces in the javax.xml.transform and javax.xml.xpath packages of the Java API for XML Processing (JAXP)
      • Utilizes system properties to specify the XML parser and transformer to use
    • Struts
      • An implementation of the MVC Model 2 pattern
      • The controller is implemented by:
        • The ActionServlet object (or a subclass defined by the application), typically mapped via the web application deployment descriptor (web.xml) to the URL pattern *.do
        • Action objects; one per user action, e.g. login, logout, save, refresh, etc.
        • ActionMapping objects that map URIs to appropriate Action objects
        • ActionForward objects that are the return types for Action objects and determine the next view
        • Declarative associations between ActionForward objects and JSPs
      • The model is implemented by:
        • DTOs (data transfer objects) that implement the Serializable interface
        • DTOs are typically attached to HttpServletRequest or HttpSession objects and then forwarded to the view
      • The view is implemented by:
        • ActionForm (JavaBean) objects that pass client input data from the view to the controller
        • The controller automatically collects the input data from the HttpServletRequest object and passes this data to the appropriate Action object using an ActionForm object, which can then be used to create the appropriate DTO to be passed to the business layer
        • Action and ActionForm objects are linked declaratively
        • The controller calls the reset() method on ActionForm objects prior to populating them with data from the HttpServletRequest objects; this gives ActionForm objects an opportunity to initialize their state since they are shared by multiple threads
        • After setting the data on ActionForm objects, the controller will (if configured to do so) automatically call the validate() method on ActionForm objects; this method should be used to perform data validation (e.g. has required data been supplied), not business logic validation
        • Properties of ActionForm objects need to match up with fields of the corresponding HTML forms
      • All declarative information is contained in the configuration file (by default, a single struts-config.xml file located in the web application's WEB-INF folder; however, configurable as a comma-separated list of configuration files defined as part of the ActionServlet definition in web.xml)
      • Each configuration file contains the following tags:
        • data-sources:
        • form-beans: defines ActionForms
        • global-exceptions:
        • global-forwards:
        • action-mappings: links URIs to Action and ActionForm objects; defines view options
        • controller: defines a custom subclass of RequestProcessor to which ActionServlet will delegate
        • message-resources:
        • plug-in: allows for dynamic discovery of resources at startup
      • The framework provides six core custom tag libraries (intended to alleviate the need to include Java code in JSPs):
        • HTML
          • Used to render HTML presentation components inside HTML forms, e.g. checkbox, multibox, and select
          • Most of the tags must be nested inside the form tag
          • The form tag renders a standard HTML form and links it with the appropriate ActionForm
          • Each field in the HTML form must correspond to a property of the associated ActionForm
          • The base tag allows the use of relative URL references that are calculated based on the URL of the page itself, rather than the URL to which the most recent submit took place (which is what the browser would normally resolve relative references against)
          • Many of the tags in this library support JavaScript event handlers through the use of their attributes
        • Bean
          • Used for accessing and defining JavaBeans
        • Logic
          • For managing conditional generation of output text, looping over object collections for repetitive generation of output text, and application flow management (redirecting and forwarding with URL rewriting, if the container supports it)
          • The value-comparison tags print out the body of the tag if and only if the comparison evaluates to true
          • Evaluate the body content depending on whether an ActionMessages or ActionErrors object is present in the request scope
        • Template
        • Nested
          • Allow for the nesting of Struts tags inside one another and to match the ability of the model layer to nest JavaBeans inside one another
        • Tiles
          • Allows content to be separated from layout by facilitating the creation of templates
          • Templates are JSP pages that use the Tiles custom JSP tag library to describe the layout of a page
          • Templates contain HTML layout along with placeholders such as <tiles:insert attribute="header"> for including at runtime the HTML header information from the JSP to which the template is applied
          • The insert tag performs a role similar to the JSP include directive
      • The MessageResources class provides the basis for localization (L10N) and internationalization (I18N) by linking Struts applications with a resource bundle for each supported language
      • Framework Extension Points or Hooks
        • General
          • Plugin Mechanism
            • Allows components to be plugged in and loaded dynamically
            • Any class can function as a plugin, as long as it implements the org.apache.struts.action.PlugIn interface
            • A plugin is any class you wish to initialize when Struts starts up and destroy when Struts shuts down, i.e. the lifecycle of the plugin is tied to that of Struts
            • The PlugIn interface contains two methods: init() and destroy(), invoked by ActionServlet
            • The init() method might be used to, say, create and initialize a JNDI InitialContext and store it in the ServletContext to make it available to the entire application
            • As another example, the Struts Validator framework uses the PlugIn mechanism to initialize the validation rules for an application
            • All PlugIn classes must be declared in the Struts configuration file and are loaded in the order in which they are declared
          • The Struts configuration classes can be extended to add new configuration elements
        • Controller
          • Extend the org.apache.struts.action.ActionServlet class to modify the overall Struts initialization behavior (you will also need to modify web.xml to use the ActionServlet subclass instead)
          • Extend the RequestProcessor class and declare it using the controller element in the Struts configuration file; a particularly interesting method to override is the processPreprocess() method, which is called early in the request processing stage, before the ActionForm is called and before the execute() method is called on the Action object (an alternate option is to use a servlet filter, which receives the request before it reaches the Struts controller; however, this option is only available in containers supporting Servlet 2.3 and higher and servlet filters do not have easy access to the Struts API)
          • Extend the Action class to create a base Action class to hold any behavior that all actions need to perform
        • View
          • Extend Struts custom tags to create a separate tag library; especially relevant to the HTML tag library
        • Model
          • Create a UserContainer class as an alternative to HttpSession
            • Provide stronger typed alternatives to HttpSession's the weakly typed setAttribute() and getAttribute() methods
            • Implement the HttpSessionBindingListener and Serializable interfaces
            • Methods in the HttpSessionBindingListener interface allow the UserContainer to be notified when it is bound and unbound from the session; this allows UserContainer to perform any necessary cleanup on the object; an instance of UserContainer is created for each new user at the time the user enters the application; the UserContainer object itself is stored in the session and has the life of the session; if a user exits and re-enters the site, a new UserContainer is typically created for the user
            • Implementing the Serializable interface allows UserContainer to passivate or transfer the session's contents in a cluster
          • Similarly, create an ApplicationContainer class as an alternative to ServletContext
    • Jakarta
      • Commons
        • Digester
          • Thin wrapper around the SAX API
          • Allows for the creation of parsing rules (mappings of tag sequences/patterns to classes) using XML or programmatically
      • Log4J
        • Composed of three major pieces
          • Loggers; obtained via logger = Logger.getLogger("myLogger"); named loggers such as "myLogger" inherit from the anonymous pre-existing root logger obtained via the static call Logger.getRootLogger(); allows for logging at different levels (in descending order: debug, info, warn, error, fatal), e.g. logger.warn("No records found in Person table.") will be written if the logging level is set to warn or higher
          • Appenders; select the appropriate one (e,g. FileAppender) depending on whether you want to write the log to console, file, rolling file, daily rolling file, database, Windows event log, email, or network; a logger can be associated with multiple appenders, i.e. the same message can be written to multiple destinations
          • Pattern Layouts; formats the message, e.g. %50m to print the first 50 characters of the message supplied by the logger
        • Can be configured programatically or via a configuration file (Java properties file or XML file); at a minimum use log4j.properties to configure the root logger with one appender and add it to the classpath; named loggers will inherit the root logger configuration; e.g.

          log4j.rootLogger=DEBUG, myLogFile
          log4j.appender.myLogFile=org.apache.log4j.RollingFileAppender
          log4j.appender.myLogFile=mylog.log
          log4j.appender.myLogFile.threshold=WARN

  • JDOM
    • Developed by Jason Hunter and Brett McLaughlin
    • An API designed to represent an XML document and its contents using Java paradigms such as Collections, method overloading, reflection, getters, and setters
    • Interoprates well with existing standards such as the Document Object Model (DOM) and the Simple API for XML (SAX)
    • JDOM can read from existing DOM and SAX sources and output to DOM and SAX components
    • Attempts to incorporate the best of DOM and SAX
    • Provides random access to the XML document without having to load the entire XML document in memory
    • Supports document modification via the use of standard Java constructors and setters
  • ehcache
    • Hosted by SourceForge
    • Supports mutliple CacheManagers per Java virtual machine
    • Provides LRU, LFU, and FIFO cache eviction policies
    • Supports listener plugins
    • Persists cache to disk between VM restarts
    • Used by Spring and Hibernate (an object relational mapping persistence framework)
  • Castor
    • Provides Java-XML binding
    • Provides a persistence framework
  • Flatworm
    • Designed to eliminate the need to hand-parse fixed length flat file data
    • Uses an XML file to describe the input file format and break the input into beans of the user's choosing
    • Supports multiple record types in a single file, using either record length or key field values to determine record type
  • JIMI
    • Java Image Management Interface
    • Its primary function is image I/O for a large number of image formats
  • Barbecue
    • Hosted by SourceForge
    • Library to enable the creation of barcodes in a variety of standard formats that can be displayed as Swing/AWT components, included in printed output, and generated as EPS/SVG for display in a Web application
  • ObjectWeb ASM
    • Used for bytecode manipulation to dynamically modify classes at load time
    • Used by Groovy, WebLogic Diagnostic Framework, AspectJ, Oracle TopLink (a Object-Relational Mapping ORM framework), TopLink Essentials (a free open source version of Oracle TopLink)
    • Uses a the visitor design pattern to drive transformations of existing classes
    • Smaller and faster alternative to Byte Code Engineering Library (BCEL), SERP, and Javassist
  • Bostech ChainBuilder
    • A suite of Enterprise Application Integration (EAI) products, including a Java Business Integration (JBI)-compliant Enterprise Service Bus (ESB)
  • Seam
    • Meant to provide a stateful/conversational component model to provide a bridge between, say, JavaServer Faces (JSF) and Enterprise JavaBeans (EJB)
    • Suitable for applications with complex user interactions and workflows
  • Spring
    • NOTE: Throughout the following, "bean" is not any sort of special JavaBean class but is analogous to a plain-old-Java-object (POJO) or class
    • Built on two major concepts whereby lightweight/flexible POJOs are able to compete with heavyweight/rigid EJBs; rather than having the various services (security, transaction management, etc.) hard-wired into the class definition, these services are provided in a decoupled fashion so that user-defined classes can remain as POJOs and focus on their core functions and let Spring provide enterprise services where needed
      • Dependency Injection (DI); previously known as Inversion of Control (IoC) until Martin Fowler coined the phrase DI; opposite of JNDI; instead of the object looking for its dependencies (e.g. database connection), it has its dependencies supplied (injected) by the Spring container, i.e. the BeanFactory class; the dependencies are thereby externalized and declaratively specified in XML configuration files
      • Aspect Oriented Programming (AOP); lightweight POJO classes declaratively subscribe to cross-cutting services such as logging, security, transaction management
    • Configuration happens via an XML file with the following key elements
      • The element <beans> is the root element of any Spring configuration file
      • The element <bean> (one for each class) tells Spring how to configure the class with its dependencies
        • The attribute id= gives the bean a name that is used to reference the bean when creating it via the Spring bean factory
        • The attribute class= specifies the fully-qualified class name
        • The element <property> sets a property for the bean/class via the attributes name= and value=
        • The element <constructor-arg> provides the constructor argument via the attribute value=
    • Whereas DI can be used to inject bean properties that are of type String, its real power lies in injecting bean properties that are other beans

• Security
  • Authentication: the process of validating that a valid user and password combination has been supplied
  • Authorization: the process of validating that the user has permission to access the requested resource

• Performance, Scalability, Availability
  • Terminology
    • Performance refers to the average response time for a given transaction load
    • Throughput refers to the maximum transaction load that can be accomodated while keeping average response times at the desired level
    • Scalability refers to the ability of a system to accomodate an increase in demand
      • Vertical scaling; also known as scaling up; refers to adding resources (processor, memory, disk) to a machine; also refers to the adding of cluster nodes/members to a machine; has the upside of low overhead and the downside of low redundancy (single points of failure)
      • Horizontal scaling; also known as scaling out; refers to adding machines; also refers to the adding of cluster nodes/members to additional machines; has the upside of increased redundancy and the downside of increased overhead
  • Types of Performance Testing
    • Baseline; measurement of single user average response times for end-to-end use cases prior to each phase of performance tuning
    • Load; same as above using multiple virtual users with the goal of maximizing the number of concurrent users while maintaining an acceptable average response time for all end-to-end use cases
    • Stress; using peak loads in order to surface problems and establish scalability and performance limits
    • Tools; Apache JMeter
  • Profiling
    • Whereas performance testing can identify bottlenecks at the request level, profiling tools are needed to identify bottlenecks at the Java method level
    • Profilers provide information such as which Java methods are taking the longest time to execute, how many calls are being made to specific Java methods, how many objects of a specific type are being created and whether they are being destroyed as expected (memory leaks), and how much memory is being used by each type of object
    • Tools; VisualGC, JPS, JStat, JStatD, Eclipse TPTP plugin
  • Tips on Improving Performance
    • Test performance early and often
    • Caching
      • Cache stateful objects, e.g. a collection of customer JavaBeans, one for each customer ID
      • Monitor cache hit ratios
    • Pooling
      • Pool expensive resources such as database connections, threads, and large stateless objects
      • Use a pool manager to control the number of database connections, threads, etc.; the idea is to ensure that the system degrades in performance under stress but does not use limitless resources and crash due to OutOfMemoryError
      • Make the pool manager queue-based; see the queue classes in java.util.concurrent (Java 5 and above)
      • Experiment with the sizes of the Web server and application server execute queues and thread pools
    • JVM
      • Experiment with the maximum JVM heap size to find the setting that maximizes performance
      • Setting the maximum heap size equal to the amount of available memory (256 megabytes) might not be best since it causes the garbage collector to spend too much time scanning memory for garbage collection candidates
      • Set the minimum heap size equal to the maximum heap size in order to minimize the number of garbage collections
      • Given that most objects die young, set the size of the new generation (young objects) heap area equal to one-fourth of the maximum heap size
      • Start by subdividing the new generation area using an Eden/survivor ratio of 8
      • JIT
        • Use a Java Virtual Machine (VM) that includes a Just In Time (JIT) compiler, such as Sun's HotSpot (a core component of the Java SE platform)
        • The Java VM normally interprets the platform-independent Java bytecode into platform-specific native machine code at runtime, thereby incurring an ongoing bytecode to machine code overhead cost for each bytecode instruction executed
        • A VM with a JIT compiler performs a one-time pre-translation of all the bytecode to machine code and is, therefore, able to reuse the machine code rather than incur the translation overhead each time the bytecode needs to be executed
        • Although machine code translations are performed once and then reused, the translations occur just-in-time on a per-class basis
        • The advantage of faster runtime processing has the corresponding cost of longer startup times to account for the initial bytecode to machine code compilation for all classes loaded into memory during startup
      • Garbage Collection
        • Once the application has reached steady state, watch for a consistently growing old generation section of the heap since all leaked objects will eventually end up there
        • Watch out for large objects assigned to static variables since these live in the permanent space, which may or may not be garbage collected
        • Watch out for large objects referenced from servlets and JSPs since these behave much like singletons whereby the system keeps a copy in memory for the lifetime of the application
        • Improving Java Application Performance and Scalability by Reducing Garbage Collection Times and Sizing Memory Using JDK 1.4.1
    • Multi-threading
      • Use threading to minimize idle processor time, especially when doing a lot of blocking I/O (but watch out for thrashing due to excessive overhead related to thread management and context switching)
      • Use synchronized blocks only where necessary and synchronize the minimum lines of code necessary in order to reduce thread wait times and the probability of starvation and deadlock
      • Use synchronized collection objects, e.g. Vector and Hashtable, only when necessary
      • On a multi-CPU Unix machines, experiment with using native (OS) threads (-native JVM option) rather than green (JVM) threads (-green JVM option); conversely, on single-CPU machines, use green (lightweight) threads rather than native threads
      • Use low priority (background) threads to perform slow tasks
      • Use high priority (foreground) threads to perform user interface tasks
    • Sessions
      • Store session state on the client in cookies and in HttpServletRequest objects (which have a narrower scope and are garbage collected more frequently) rather than in HttpSession objects
      • If using a cluster with HTTPSession persistence enabled, use in-memory replication rather than JDBC-based persistence; also, where appropriate, place fewer coarse-grained objects in HTTPSession (rather than multiple fine-grained objects) in order to reduce the session replication effort
        • Database HTTP session replication refers to the sharing of HTTP session state with other machines participating in a cluster by storing session state in the database
        • In-memory or memory-to-memory HTTP session replication refers to the use of inter-machine messaging to propagate session state between the machines participating in a cluster; eliminates the single point of failure of database session replication (assuming that the database itself has not been made highly available)
      • Explicitly invalidate sessions upon user logout rather than waiting for sessions to timeout and be garbage collected
      • Use reasonable session timeouts so that sessions can be garbage collected once they have served their purpose
    • Database
      • Cache commonly used and infrequently updated query results instead of going to the database for every request; refresh cache at a reasonable interval such as one minute
      • Batch SQL updates and inserts
      • Tune your SQL
      • Tune your database
      • Do more processing inside the database using stored procedures (callable statements), triggers, and built-in JVMs
      • Use prepared (parameterized) SQL statements for queries that are executed repeatedly with slight modification; however, keep the memory requirements in mind, given that prepared statements are cached on a per-database-connection basis (i.e. if you have 100 prepared statements being used over 50 database connections, then you need enough memory to cache 5,000 prepared statements)
      • Set the connection pool initial capacity equal to the maximum capacity so that under load all resources are used to service requests rather than spending time creating connections; (exception: during development, set the initial capacity to a low number to help the application start faster)
      • Suspect the database when CPU utilization remains low despite heavy load on the application
    • Use the JSP include mechanism to eliminate multiple copies of shared JSP code in memory
    • Use the SoftReference class to build your caches so that cache memory can be claimed by the garbage collector if and when the application is under stress (all soft references are guaranteed to have been cleared before the JVM throws an OutOfMemoryError)
    • Remoting
      • Use as few remote calls as possible
      • Use coarse-grained remote calls in order to reduce the number of remote calls
      • Funnel all remote calls through a facade object and use this facade object to cache remote call results
    • Graphics
      • Use as few graphics as possible
      • Use images with small file sizes
    • Add memory
    • Use load-balanced clustering to harness the processing power of multiple machines (watch out for state replication costs in the case of stateful or pinned services)
  • Reading Java Core Dumps
    • Also known as Java thread dumps
    • The core dump is a text file and can be user- or system-generated
    • If the stack trace contains the words "Compiled Code" instead of line numbers, disable Just In Time (JIT) compilation by using the -Xint VM argument to see the line numbers (JIT compilation is on by default); however, beware that disabling JIT compilation can hurt performance during periods of high load
    • The dump contains the following major sections

• Operating Systems
  • Cluster; a group of coupled computers working collaboratively and appearing as one computing resource; generally more cost-effective than one computer with the same combined computing resources and availability
    • High-Availability Clusters; also known as failover clusters or asymmetric clustering; redundant or hot-standby nodes are used to provide services when primary system components fail; the most common size of such a cluster is two nodes, which is the minimum required to provide redundancy; meant to eliminate single points of failure
    • Load-Balancing Clusters; also known as symmetric clustering; all nodes provide service; the workload is distributed evenly among multiple or all back-end nodes by a front-end load balancer
    • Grid-Computing Clusters; combine the resources of geographically scattered heterogenous collections of computers that do not necessarily trust each other; optimized for workloads consisting of many independent jobs or packets of work; (based on the concept of a power grid wherein consumers do not need to maintain complex infrastructure to generate their own power; instead users plug into the wall to consume centrally generated power)
  • File System
    • Mount; allows users to access data in a disk section as a file system instead of a sequence of disk blocks; connects the file system in a specific section of a disk to the existing file system hierarchy

• Links
  • Ad-Free Access to Regular-Expressions.info