See: Description
| Interface | Description |
|---|---|
| Byte2BooleanFunction |
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Byte2BooleanMap |
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Byte2BooleanMap.Entry |
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Byte2BooleanMap.FastEntrySet |
An entry set providing fast iteration.
|
| Byte2BooleanSortedMap |
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Byte2BooleanSortedMap.FastSortedEntrySet |
A sorted entry set providing fast iteration.
|
| Byte2ByteFunction |
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Byte2ByteMap |
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Byte2ByteMap.Entry |
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Byte2ByteMap.FastEntrySet |
An entry set providing fast iteration.
|
| Byte2ByteSortedMap |
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Byte2ByteSortedMap.FastSortedEntrySet |
A sorted entry set providing fast iteration.
|
| Byte2CharFunction |
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Byte2CharMap |
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Byte2CharMap.Entry |
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Byte2CharMap.FastEntrySet |
An entry set providing fast iteration.
|
| Byte2CharSortedMap |
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Byte2CharSortedMap.FastSortedEntrySet |
A sorted entry set providing fast iteration.
|
| Byte2DoubleFunction |
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Byte2DoubleMap |
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Byte2DoubleMap.Entry |
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Byte2DoubleMap.FastEntrySet |
An entry set providing fast iteration.
|
| Byte2DoubleSortedMap |
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Byte2DoubleSortedMap.FastSortedEntrySet |
A sorted entry set providing fast iteration.
|
| Byte2FloatFunction |
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Byte2FloatMap |
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Byte2FloatMap.Entry |
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Byte2FloatMap.FastEntrySet |
An entry set providing fast iteration.
|
| Byte2FloatSortedMap |
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Byte2FloatSortedMap.FastSortedEntrySet |
A sorted entry set providing fast iteration.
|
| Byte2IntFunction |
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Byte2IntMap |
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Byte2IntMap.Entry |
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Byte2IntMap.FastEntrySet |
An entry set providing fast iteration.
|
| Byte2IntSortedMap |
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Byte2IntSortedMap.FastSortedEntrySet |
A sorted entry set providing fast iteration.
|
| Byte2LongFunction |
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Byte2LongMap |
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Byte2LongMap.Entry |
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Byte2LongMap.FastEntrySet |
An entry set providing fast iteration.
|
| Byte2LongSortedMap |
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Byte2LongSortedMap.FastSortedEntrySet |
A sorted entry set providing fast iteration.
|
| Byte2ObjectFunction<V> |
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Byte2ObjectMap<V> |
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Byte2ObjectMap.Entry<V> |
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Byte2ObjectMap.FastEntrySet<V> |
An entry set providing fast iteration.
|
| Byte2ObjectSortedMap<V> |
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Byte2ObjectSortedMap.FastSortedEntrySet<V> |
A sorted entry set providing fast iteration.
|
| Byte2ReferenceFunction<V> |
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Byte2ReferenceMap<V> |
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Byte2ReferenceMap.Entry<V> |
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Byte2ReferenceMap.FastEntrySet<V> |
An entry set providing fast iteration.
|
| Byte2ReferenceSortedMap<V> |
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Byte2ReferenceSortedMap.FastSortedEntrySet<V> |
A sorted entry set providing fast iteration.
|
| Byte2ShortFunction |
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Byte2ShortMap |
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Byte2ShortMap.Entry |
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Byte2ShortMap.FastEntrySet |
An entry set providing fast iteration.
|
| Byte2ShortSortedMap |
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Byte2ShortSortedMap.FastSortedEntrySet |
A sorted entry set providing fast iteration.
|
| ByteBidirectionalIterator |
A type-specific bidirectional iterator; provides an additional method to avoid (un)boxing,
and the possibility to skip elements backwards.
|
| ByteBigList |
A type-specific
BigList ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ByteBigListIterator |
A type-specific
BigListIterator . |
| ByteCollection |
A type-specific
Collection ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| ByteComparator |
A type-specific
Comparator ; provides methods to compare two primitive types both as objects
and as primitive types. |
| ByteHash |
A type-specific
Hash interface. |
| ByteHash.Strategy |
A type-specific hash strategy.
|
| ByteIndirectPriorityQueue |
A type-specific
IndirectPriorityQueue . |
| ByteIterable |
A type-specific
Iterable that strengthens that specification of Iterable.iterator() . |
| ByteIterator |
A type-specific
Iterator ; provides an additional method to avoid (un)boxing, and
the possibility to skip elements. |
| ByteList |
A type-specific
List ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ByteListIterator |
A type-specific bidirectional iterator that is also a
ListIterator . |
| BytePriorityQueue |
A type-specific
PriorityQueue ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ByteSet |
A type-specific
Set ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ByteSortedSet |
A type-specific
SortedSet ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ByteStack |
A type-specific
Stack ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Class | Description |
|---|---|
| AbstractByte2BooleanFunction |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractByte2BooleanMap |
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractByte2BooleanMap.BasicEntry |
This class provides a basic but complete type-specific entry class for all those maps implementations
that do not have entries on their own (e.g., most immutable maps).
|
| AbstractByte2BooleanSortedMap |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractByte2BooleanSortedMap.KeySetIterator |
A wrapper exhibiting a map iterator as an iterator on keys.
|
| AbstractByte2BooleanSortedMap.ValuesIterator |
A wrapper exhibiting a map iterator as an iterator on values.
|
| AbstractByte2ByteFunction |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractByte2ByteMap |
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractByte2ByteMap.BasicEntry |
This class provides a basic but complete type-specific entry class for all those maps implementations
that do not have entries on their own (e.g., most immutable maps).
|
| AbstractByte2ByteSortedMap |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractByte2ByteSortedMap.KeySetIterator |
A wrapper exhibiting a map iterator as an iterator on keys.
|
| AbstractByte2ByteSortedMap.ValuesIterator |
A wrapper exhibiting a map iterator as an iterator on values.
|
| AbstractByte2CharFunction |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractByte2CharMap |
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractByte2CharMap.BasicEntry |
This class provides a basic but complete type-specific entry class for all those maps implementations
that do not have entries on their own (e.g., most immutable maps).
|
| AbstractByte2CharSortedMap |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractByte2CharSortedMap.KeySetIterator |
A wrapper exhibiting a map iterator as an iterator on keys.
|
| AbstractByte2CharSortedMap.ValuesIterator |
A wrapper exhibiting a map iterator as an iterator on values.
|
| AbstractByte2DoubleFunction |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractByte2DoubleMap |
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractByte2DoubleMap.BasicEntry |
This class provides a basic but complete type-specific entry class for all those maps implementations
that do not have entries on their own (e.g., most immutable maps).
|
| AbstractByte2DoubleSortedMap |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractByte2DoubleSortedMap.KeySetIterator |
A wrapper exhibiting a map iterator as an iterator on keys.
|
| AbstractByte2DoubleSortedMap.ValuesIterator |
A wrapper exhibiting a map iterator as an iterator on values.
|
| AbstractByte2FloatFunction |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractByte2FloatMap |
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractByte2FloatMap.BasicEntry |
This class provides a basic but complete type-specific entry class for all those maps implementations
that do not have entries on their own (e.g., most immutable maps).
|
| AbstractByte2FloatSortedMap |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractByte2FloatSortedMap.KeySetIterator |
A wrapper exhibiting a map iterator as an iterator on keys.
|
| AbstractByte2FloatSortedMap.ValuesIterator |
A wrapper exhibiting a map iterator as an iterator on values.
|
| AbstractByte2IntFunction |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractByte2IntMap |
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractByte2IntMap.BasicEntry |
This class provides a basic but complete type-specific entry class for all those maps implementations
that do not have entries on their own (e.g., most immutable maps).
|
| AbstractByte2IntSortedMap |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractByte2IntSortedMap.KeySetIterator |
A wrapper exhibiting a map iterator as an iterator on keys.
|
| AbstractByte2IntSortedMap.ValuesIterator |
A wrapper exhibiting a map iterator as an iterator on values.
|
| AbstractByte2LongFunction |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractByte2LongMap |
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractByte2LongMap.BasicEntry |
This class provides a basic but complete type-specific entry class for all those maps implementations
that do not have entries on their own (e.g., most immutable maps).
|
| AbstractByte2LongSortedMap |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractByte2LongSortedMap.KeySetIterator |
A wrapper exhibiting a map iterator as an iterator on keys.
|
| AbstractByte2LongSortedMap.ValuesIterator |
A wrapper exhibiting a map iterator as an iterator on values.
|
| AbstractByte2ObjectFunction<V> |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractByte2ObjectMap<V> |
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractByte2ObjectMap.BasicEntry<V> |
This class provides a basic but complete type-specific entry class for all those maps implementations
that do not have entries on their own (e.g., most immutable maps).
|
| AbstractByte2ObjectSortedMap<V> |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractByte2ObjectSortedMap.KeySetIterator<V> |
A wrapper exhibiting a map iterator as an iterator on keys.
|
| AbstractByte2ObjectSortedMap.ValuesIterator<V> |
A wrapper exhibiting a map iterator as an iterator on values.
|
| AbstractByte2ReferenceFunction<V> |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractByte2ReferenceMap<V> |
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractByte2ReferenceMap.BasicEntry<V> |
This class provides a basic but complete type-specific entry class for all those maps implementations
that do not have entries on their own (e.g., most immutable maps).
|
| AbstractByte2ReferenceSortedMap<V> |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractByte2ReferenceSortedMap.KeySetIterator<V> |
A wrapper exhibiting a map iterator as an iterator on keys.
|
| AbstractByte2ReferenceSortedMap.ValuesIterator<V> |
A wrapper exhibiting a map iterator as an iterator on values.
|
| AbstractByte2ShortFunction |
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractByte2ShortMap |
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractByte2ShortMap.BasicEntry |
This class provides a basic but complete type-specific entry class for all those maps implementations
that do not have entries on their own (e.g., most immutable maps).
|
| AbstractByte2ShortSortedMap |
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractByte2ShortSortedMap.KeySetIterator |
A wrapper exhibiting a map iterator as an iterator on keys.
|
| AbstractByte2ShortSortedMap.ValuesIterator |
A wrapper exhibiting a map iterator as an iterator on values.
|
| AbstractByteBidirectionalIterator |
An abstract class facilitating the creation of type-specific bidirectional iterators.
|
| AbstractByteBigList |
An abstract class providing basic methods for big lists implementing a type-specific big list interface.
|
| AbstractByteBigList.ByteSubList |
A class implementing a sublist view.
|
| AbstractByteBigListIterator |
An abstract class facilitating the creation of type-specific big-list iterators.
|
| AbstractByteCollection |
An abstract class providing basic methods for collections implementing a type-specific interface.
|
| AbstractByteComparator |
An abstract class facilitating the creation of type-specific comparators.
|
| AbstractByteIterator |
An abstract class facilitating the creation of type-specific iterators.
|
| AbstractByteList |
An abstract class providing basic methods for lists implementing a type-specific list interface.
|
| AbstractByteList.ByteSubList |
A class implementing a sublist view.
|
| AbstractByteListIterator |
An abstract class facilitating the creation of type-specific list iterators.
|
| AbstractBytePriorityQueue |
An abstract class providing basic methods for priority queues implementing a type-specific interface.
|
| AbstractByteSet |
An abstract class providing basic methods for sets implementing a type-specific interface.
|
| AbstractByteSortedSet |
An abstract class providing basic methods for sorted sets implementing a type-specific interface.
|
| AbstractByteStack |
An abstract class providing basic methods for implementing a type-specific stack interface.
|
| Byte2BooleanArrayMap |
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Byte2BooleanAVLTreeMap |
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Byte2BooleanFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| Byte2BooleanFunctions.EmptyFunction |
An immutable class representing an empty type-specific function.
|
| Byte2BooleanFunctions.Singleton |
An immutable class representing a type-specific singleton function.
|
| Byte2BooleanFunctions.SynchronizedFunction |
A synchronized wrapper class for functions.
|
| Byte2BooleanFunctions.UnmodifiableFunction |
An unmodifiable wrapper class for functions.
|
| Byte2BooleanLinkedOpenHashMap |
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Byte2BooleanMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| Byte2BooleanMaps.EmptyMap |
An immutable class representing an empty type-specific map.
|
| Byte2BooleanMaps.Singleton |
An immutable class representing a type-specific singleton map.
|
| Byte2BooleanMaps.SynchronizedMap |
A synchronized wrapper class for maps.
|
| Byte2BooleanMaps.UnmodifiableMap |
An unmodifiable wrapper class for maps.
|
| Byte2BooleanOpenCustomHashMap |
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Byte2BooleanOpenHashMap |
A type-specific hash map with a fast, small-footprint implementation.
|
| Byte2BooleanRBTreeMap |
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Byte2BooleanSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Byte2BooleanSortedMaps.EmptySortedMap |
An immutable class representing an empty type-specific sorted map.
|
| Byte2BooleanSortedMaps.Singleton |
An immutable class representing a type-specific singleton sorted map.
|
| Byte2BooleanSortedMaps.SynchronizedSortedMap |
A synchronized wrapper class for sorted maps.
|
| Byte2BooleanSortedMaps.UnmodifiableSortedMap |
An unmodifiable wrapper class for sorted maps.
|
| Byte2ByteArrayMap |
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Byte2ByteAVLTreeMap |
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Byte2ByteFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| Byte2ByteFunctions.EmptyFunction |
An immutable class representing an empty type-specific function.
|
| Byte2ByteFunctions.Singleton |
An immutable class representing a type-specific singleton function.
|
| Byte2ByteFunctions.SynchronizedFunction |
A synchronized wrapper class for functions.
|
| Byte2ByteFunctions.UnmodifiableFunction |
An unmodifiable wrapper class for functions.
|
| Byte2ByteLinkedOpenHashMap |
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Byte2ByteMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| Byte2ByteMaps.EmptyMap |
An immutable class representing an empty type-specific map.
|
| Byte2ByteMaps.Singleton |
An immutable class representing a type-specific singleton map.
|
| Byte2ByteMaps.SynchronizedMap |
A synchronized wrapper class for maps.
|
| Byte2ByteMaps.UnmodifiableMap |
An unmodifiable wrapper class for maps.
|
| Byte2ByteOpenCustomHashMap |
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Byte2ByteOpenHashMap |
A type-specific hash map with a fast, small-footprint implementation.
|
| Byte2ByteRBTreeMap |
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Byte2ByteSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Byte2ByteSortedMaps.EmptySortedMap |
An immutable class representing an empty type-specific sorted map.
|
| Byte2ByteSortedMaps.Singleton |
An immutable class representing a type-specific singleton sorted map.
|
| Byte2ByteSortedMaps.SynchronizedSortedMap |
A synchronized wrapper class for sorted maps.
|
| Byte2ByteSortedMaps.UnmodifiableSortedMap |
An unmodifiable wrapper class for sorted maps.
|
| Byte2CharArrayMap |
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Byte2CharAVLTreeMap |
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Byte2CharFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| Byte2CharFunctions.EmptyFunction |
An immutable class representing an empty type-specific function.
|
| Byte2CharFunctions.Singleton |
An immutable class representing a type-specific singleton function.
|
| Byte2CharFunctions.SynchronizedFunction |
A synchronized wrapper class for functions.
|
| Byte2CharFunctions.UnmodifiableFunction |
An unmodifiable wrapper class for functions.
|
| Byte2CharLinkedOpenHashMap |
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Byte2CharMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| Byte2CharMaps.EmptyMap |
An immutable class representing an empty type-specific map.
|
| Byte2CharMaps.Singleton |
An immutable class representing a type-specific singleton map.
|
| Byte2CharMaps.SynchronizedMap |
A synchronized wrapper class for maps.
|
| Byte2CharMaps.UnmodifiableMap |
An unmodifiable wrapper class for maps.
|
| Byte2CharOpenCustomHashMap |
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Byte2CharOpenHashMap |
A type-specific hash map with a fast, small-footprint implementation.
|
| Byte2CharRBTreeMap |
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Byte2CharSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Byte2CharSortedMaps.EmptySortedMap |
An immutable class representing an empty type-specific sorted map.
|
| Byte2CharSortedMaps.Singleton |
An immutable class representing a type-specific singleton sorted map.
|
| Byte2CharSortedMaps.SynchronizedSortedMap |
A synchronized wrapper class for sorted maps.
|
| Byte2CharSortedMaps.UnmodifiableSortedMap |
An unmodifiable wrapper class for sorted maps.
|
| Byte2DoubleArrayMap |
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Byte2DoubleAVLTreeMap |
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Byte2DoubleFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| Byte2DoubleFunctions.EmptyFunction |
An immutable class representing an empty type-specific function.
|
| Byte2DoubleFunctions.Singleton |
An immutable class representing a type-specific singleton function.
|
| Byte2DoubleFunctions.SynchronizedFunction |
A synchronized wrapper class for functions.
|
| Byte2DoubleFunctions.UnmodifiableFunction |
An unmodifiable wrapper class for functions.
|
| Byte2DoubleLinkedOpenHashMap |
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Byte2DoubleMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| Byte2DoubleMaps.EmptyMap |
An immutable class representing an empty type-specific map.
|
| Byte2DoubleMaps.Singleton |
An immutable class representing a type-specific singleton map.
|
| Byte2DoubleMaps.SynchronizedMap |
A synchronized wrapper class for maps.
|
| Byte2DoubleMaps.UnmodifiableMap |
An unmodifiable wrapper class for maps.
|
| Byte2DoubleOpenCustomHashMap |
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Byte2DoubleOpenHashMap |
A type-specific hash map with a fast, small-footprint implementation.
|
| Byte2DoubleRBTreeMap |
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Byte2DoubleSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Byte2DoubleSortedMaps.EmptySortedMap |
An immutable class representing an empty type-specific sorted map.
|
| Byte2DoubleSortedMaps.Singleton |
An immutable class representing a type-specific singleton sorted map.
|
| Byte2DoubleSortedMaps.SynchronizedSortedMap |
A synchronized wrapper class for sorted maps.
|
| Byte2DoubleSortedMaps.UnmodifiableSortedMap |
An unmodifiable wrapper class for sorted maps.
|
| Byte2FloatArrayMap |
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Byte2FloatAVLTreeMap |
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Byte2FloatFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| Byte2FloatFunctions.EmptyFunction |
An immutable class representing an empty type-specific function.
|
| Byte2FloatFunctions.Singleton |
An immutable class representing a type-specific singleton function.
|
| Byte2FloatFunctions.SynchronizedFunction |
A synchronized wrapper class for functions.
|
| Byte2FloatFunctions.UnmodifiableFunction |
An unmodifiable wrapper class for functions.
|
| Byte2FloatLinkedOpenHashMap |
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Byte2FloatMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| Byte2FloatMaps.EmptyMap |
An immutable class representing an empty type-specific map.
|
| Byte2FloatMaps.Singleton |
An immutable class representing a type-specific singleton map.
|
| Byte2FloatMaps.SynchronizedMap |
A synchronized wrapper class for maps.
|
| Byte2FloatMaps.UnmodifiableMap |
An unmodifiable wrapper class for maps.
|
| Byte2FloatOpenCustomHashMap |
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Byte2FloatOpenHashMap |
A type-specific hash map with a fast, small-footprint implementation.
|
| Byte2FloatRBTreeMap |
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Byte2FloatSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Byte2FloatSortedMaps.EmptySortedMap |
An immutable class representing an empty type-specific sorted map.
|
| Byte2FloatSortedMaps.Singleton |
An immutable class representing a type-specific singleton sorted map.
|
| Byte2FloatSortedMaps.SynchronizedSortedMap |
A synchronized wrapper class for sorted maps.
|
| Byte2FloatSortedMaps.UnmodifiableSortedMap |
An unmodifiable wrapper class for sorted maps.
|
| Byte2IntArrayMap |
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Byte2IntAVLTreeMap |
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Byte2IntFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| Byte2IntFunctions.EmptyFunction |
An immutable class representing an empty type-specific function.
|
| Byte2IntFunctions.Singleton |
An immutable class representing a type-specific singleton function.
|
| Byte2IntFunctions.SynchronizedFunction |
A synchronized wrapper class for functions.
|
| Byte2IntFunctions.UnmodifiableFunction |
An unmodifiable wrapper class for functions.
|
| Byte2IntLinkedOpenHashMap |
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Byte2IntMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| Byte2IntMaps.EmptyMap |
An immutable class representing an empty type-specific map.
|
| Byte2IntMaps.Singleton |
An immutable class representing a type-specific singleton map.
|
| Byte2IntMaps.SynchronizedMap |
A synchronized wrapper class for maps.
|
| Byte2IntMaps.UnmodifiableMap |
An unmodifiable wrapper class for maps.
|
| Byte2IntOpenCustomHashMap |
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Byte2IntOpenHashMap |
A type-specific hash map with a fast, small-footprint implementation.
|
| Byte2IntRBTreeMap |
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Byte2IntSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Byte2IntSortedMaps.EmptySortedMap |
An immutable class representing an empty type-specific sorted map.
|
| Byte2IntSortedMaps.Singleton |
An immutable class representing a type-specific singleton sorted map.
|
| Byte2IntSortedMaps.SynchronizedSortedMap |
A synchronized wrapper class for sorted maps.
|
| Byte2IntSortedMaps.UnmodifiableSortedMap |
An unmodifiable wrapper class for sorted maps.
|
| Byte2LongArrayMap |
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Byte2LongAVLTreeMap |
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Byte2LongFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| Byte2LongFunctions.EmptyFunction |
An immutable class representing an empty type-specific function.
|
| Byte2LongFunctions.Singleton |
An immutable class representing a type-specific singleton function.
|
| Byte2LongFunctions.SynchronizedFunction |
A synchronized wrapper class for functions.
|
| Byte2LongFunctions.UnmodifiableFunction |
An unmodifiable wrapper class for functions.
|
| Byte2LongLinkedOpenHashMap |
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Byte2LongMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| Byte2LongMaps.EmptyMap |
An immutable class representing an empty type-specific map.
|
| Byte2LongMaps.Singleton |
An immutable class representing a type-specific singleton map.
|
| Byte2LongMaps.SynchronizedMap |
A synchronized wrapper class for maps.
|
| Byte2LongMaps.UnmodifiableMap |
An unmodifiable wrapper class for maps.
|
| Byte2LongOpenCustomHashMap |
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Byte2LongOpenHashMap |
A type-specific hash map with a fast, small-footprint implementation.
|
| Byte2LongRBTreeMap |
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Byte2LongSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Byte2LongSortedMaps.EmptySortedMap |
An immutable class representing an empty type-specific sorted map.
|
| Byte2LongSortedMaps.Singleton |
An immutable class representing a type-specific singleton sorted map.
|
| Byte2LongSortedMaps.SynchronizedSortedMap |
A synchronized wrapper class for sorted maps.
|
| Byte2LongSortedMaps.UnmodifiableSortedMap |
An unmodifiable wrapper class for sorted maps.
|
| Byte2ObjectArrayMap<V> |
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Byte2ObjectAVLTreeMap<V> |
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Byte2ObjectFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| Byte2ObjectFunctions.EmptyFunction<V> |
An immutable class representing an empty type-specific function.
|
| Byte2ObjectFunctions.Singleton<V> |
An immutable class representing a type-specific singleton function.
|
| Byte2ObjectFunctions.SynchronizedFunction<V> |
A synchronized wrapper class for functions.
|
| Byte2ObjectFunctions.UnmodifiableFunction<V> |
An unmodifiable wrapper class for functions.
|
| Byte2ObjectLinkedOpenHashMap<V> |
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Byte2ObjectMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| Byte2ObjectMaps.EmptyMap<V> |
An immutable class representing an empty type-specific map.
|
| Byte2ObjectMaps.Singleton<V> |
An immutable class representing a type-specific singleton map.
|
| Byte2ObjectMaps.SynchronizedMap<V> |
A synchronized wrapper class for maps.
|
| Byte2ObjectMaps.UnmodifiableMap<V> |
An unmodifiable wrapper class for maps.
|
| Byte2ObjectOpenCustomHashMap<V> |
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Byte2ObjectOpenHashMap<V> |
A type-specific hash map with a fast, small-footprint implementation.
|
| Byte2ObjectRBTreeMap<V> |
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Byte2ObjectSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Byte2ObjectSortedMaps.EmptySortedMap<V> |
An immutable class representing an empty type-specific sorted map.
|
| Byte2ObjectSortedMaps.Singleton<V> |
An immutable class representing a type-specific singleton sorted map.
|
| Byte2ObjectSortedMaps.SynchronizedSortedMap<V> |
A synchronized wrapper class for sorted maps.
|
| Byte2ObjectSortedMaps.UnmodifiableSortedMap<V> |
An unmodifiable wrapper class for sorted maps.
|
| Byte2ReferenceArrayMap<V> |
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Byte2ReferenceAVLTreeMap<V> |
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Byte2ReferenceFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| Byte2ReferenceFunctions.EmptyFunction<V> |
An immutable class representing an empty type-specific function.
|
| Byte2ReferenceFunctions.Singleton<V> |
An immutable class representing a type-specific singleton function.
|
| Byte2ReferenceFunctions.SynchronizedFunction<V> |
A synchronized wrapper class for functions.
|
| Byte2ReferenceFunctions.UnmodifiableFunction<V> |
An unmodifiable wrapper class for functions.
|
| Byte2ReferenceLinkedOpenHashMap<V> |
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Byte2ReferenceMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| Byte2ReferenceMaps.EmptyMap<V> |
An immutable class representing an empty type-specific map.
|
| Byte2ReferenceMaps.Singleton<V> |
An immutable class representing a type-specific singleton map.
|
| Byte2ReferenceMaps.SynchronizedMap<V> |
A synchronized wrapper class for maps.
|
| Byte2ReferenceMaps.UnmodifiableMap<V> |
An unmodifiable wrapper class for maps.
|
| Byte2ReferenceOpenCustomHashMap<V> |
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Byte2ReferenceOpenHashMap<V> |
A type-specific hash map with a fast, small-footprint implementation.
|
| Byte2ReferenceRBTreeMap<V> |
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Byte2ReferenceSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Byte2ReferenceSortedMaps.EmptySortedMap<V> |
An immutable class representing an empty type-specific sorted map.
|
| Byte2ReferenceSortedMaps.Singleton<V> |
An immutable class representing a type-specific singleton sorted map.
|
| Byte2ReferenceSortedMaps.SynchronizedSortedMap<V> |
A synchronized wrapper class for sorted maps.
|
| Byte2ReferenceSortedMaps.UnmodifiableSortedMap<V> |
An unmodifiable wrapper class for sorted maps.
|
| Byte2ShortArrayMap |
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Byte2ShortAVLTreeMap |
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Byte2ShortFunctions |
A class providing static methods and objects that do useful things with type-specific functions.
|
| Byte2ShortFunctions.EmptyFunction |
An immutable class representing an empty type-specific function.
|
| Byte2ShortFunctions.Singleton |
An immutable class representing a type-specific singleton function.
|
| Byte2ShortFunctions.SynchronizedFunction |
A synchronized wrapper class for functions.
|
| Byte2ShortFunctions.UnmodifiableFunction |
An unmodifiable wrapper class for functions.
|
| Byte2ShortLinkedOpenHashMap |
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Byte2ShortMaps |
A class providing static methods and objects that do useful things with type-specific maps.
|
| Byte2ShortMaps.EmptyMap |
An immutable class representing an empty type-specific map.
|
| Byte2ShortMaps.Singleton |
An immutable class representing a type-specific singleton map.
|
| Byte2ShortMaps.SynchronizedMap |
A synchronized wrapper class for maps.
|
| Byte2ShortMaps.UnmodifiableMap |
An unmodifiable wrapper class for maps.
|
| Byte2ShortOpenCustomHashMap |
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Byte2ShortOpenHashMap |
A type-specific hash map with a fast, small-footprint implementation.
|
| Byte2ShortRBTreeMap |
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Byte2ShortSortedMaps |
A class providing static methods and objects that do useful things with type-specific sorted maps.
|
| Byte2ShortSortedMaps.EmptySortedMap |
An immutable class representing an empty type-specific sorted map.
|
| Byte2ShortSortedMaps.Singleton |
An immutable class representing a type-specific singleton sorted map.
|
| Byte2ShortSortedMaps.SynchronizedSortedMap |
A synchronized wrapper class for sorted maps.
|
| Byte2ShortSortedMaps.UnmodifiableSortedMap |
An unmodifiable wrapper class for sorted maps.
|
| ByteArrayFIFOQueue |
A type-specific array-based FIFO queue, supporting also deque operations.
|
| ByteArrayFrontCodedList |
Compact storage of lists of arrays using front coding.
|
| ByteArrayIndirectPriorityQueue |
A type-specific array-based semi-indirect priority queue.
|
| ByteArrayList |
A type-specific array-based list; provides some additional methods that use polymorphism to avoid (un)boxing.
|
| ByteArrayPriorityQueue |
A type-specific array-based priority queue.
|
| ByteArrays |
A class providing static methods and objects that do useful things with type-specific arrays.
|
| ByteArrays.ForkJoinQuickSort | |
| ByteArrays.ForkJoinQuickSort2 | |
| ByteArrays.ForkJoinQuickSortComp | |
| ByteArrays.ForkJoinQuickSortIndirect | |
| ByteArrays.Segment | |
| ByteArraySet |
A simple, brute-force implementation of a set based on a backing array.
|
| ByteAVLTreeSet |
A type-specific AVL tree set with a fast, small-footprint implementation.
|
| ByteBigArrayBigList |
A type-specific big list based on a big array; provides some additional methods that use polymorphism to avoid (un)boxing.
|
| ByteBigArrays |
A class providing static methods and objects that do useful things with big arrays.
|
| ByteBigListIterators |
A class providing static methods and objects that do useful things with type-specific iterators.
|
| ByteBigListIterators.BigListIteratorListIterator |
A class exposing a list iterator as a big-list iterator..
|
| ByteBigListIterators.EmptyBigListIterator |
A class returning no elements and a type-specific big list iterator interface.
|
| ByteBigListIterators.UnmodifiableBigListIterator |
An unmodifiable wrapper class for big list iterators.
|
| ByteBigLists |
A class providing static methods and objects that do useful things with type-specific big lists.
|
| ByteBigLists.EmptyBigList |
An immutable class representing an empty type-specific big list.
|
| ByteBigLists.ListBigList |
A class exposing a list as a big list.
|
| ByteBigLists.Singleton |
An immutable class representing a type-specific singleton big list.
|
| ByteBigLists.SynchronizedBigList |
A synchronized wrapper class for big lists.
|
| ByteBigLists.UnmodifiableBigList |
An unmodifiable wrapper class for big lists.
|
| ByteCollections |
A class providing static methods and objects that do useful things with type-specific collections.
|
| ByteCollections.EmptyCollection |
An immutable class representing an empty type-specific collection.
|
| ByteCollections.IterableCollection |
A collection wrapper class for iterables.
|
| ByteCollections.SynchronizedCollection |
A synchronized wrapper class for collections.
|
| ByteCollections.UnmodifiableCollection |
An unmodifiable wrapper class for collections.
|
| ByteComparators |
A class providing static methods and objects that do useful things with comparators.
|
| ByteComparators.NaturalImplicitComparator |
A type-specific comparator mimicking the natural order.
|
| ByteComparators.OppositeComparator | |
| ByteComparators.OppositeImplicitComparator |
A type-specific comparator mimicking the opposite of the natural order.
|
| ByteHeapIndirectPriorityQueue |
A type-specific heap-based indirect priority queue.
|
| ByteHeapPriorityQueue |
A type-specific heap-based priority queue.
|
| ByteHeaps |
A class providing static methods and objects that do useful things with heaps.
|
| ByteHeapSemiIndirectPriorityQueue |
A type-specific heap-based semi-indirect priority queue.
|
| ByteIndirectHeaps |
A class providing static methods and objects that do useful things with indirect heaps.
|
| ByteIterators |
A class providing static methods and objects that do useful things with type-specific iterators.
|
| ByteIterators.EmptyIterator |
A class returning no elements and a type-specific iterator interface.
|
| ByteIterators.UnmodifiableBidirectionalIterator |
An unmodifiable wrapper class for bidirectional iterators.
|
| ByteIterators.UnmodifiableIterator |
An unmodifiable wrapper class for iterators.
|
| ByteIterators.UnmodifiableListIterator |
An unmodifiable wrapper class for list iterators.
|
| ByteLinkedOpenCustomHashSet |
A type-specific linked hash set with with a fast, small-footprint implementation.
|
| ByteLinkedOpenHashSet |
A type-specific linked hash set with with a fast, small-footprint implementation.
|
| ByteLists |
A class providing static methods and objects that do useful things with type-specific lists.
|
| ByteLists.EmptyList |
An immutable class representing an empty type-specific list.
|
| ByteLists.Singleton |
An immutable class representing a type-specific singleton list.
|
| ByteLists.SynchronizedList |
A synchronized wrapper class for lists.
|
| ByteLists.SynchronizedRandomAccessList |
A synchronized wrapper class for random-access lists.
|
| ByteLists.UnmodifiableList |
An unmodifiable wrapper class for lists.
|
| ByteLists.UnmodifiableRandomAccessList |
An unmodifiable wrapper class for random-access lists.
|
| ByteOpenCustomHashSet |
A type-specific hash set with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| ByteOpenHashSet |
A type-specific hash set with with a fast, small-footprint implementation.
|
| BytePriorityQueues |
A class providing static methods and objects that do useful things with type-specific priority queues.
|
| BytePriorityQueues.SynchronizedPriorityQueue |
A synchronized wrapper class for priority queues.
|
| ByteRBTreeSet |
A type-specific red-black tree set with a fast, small-footprint implementation.
|
| ByteSemiIndirectHeaps |
A class providing static methods and objects that do useful things with semi-indirect heaps.
|
| ByteSets |
A class providing static methods and objects that do useful things with type-specific sets.
|
| ByteSets.EmptySet |
An immutable class representing the empty set and implementing a type-specific set interface.
|
| ByteSets.Singleton |
An immutable class representing a type-specific singleton set.
|
| ByteSets.SynchronizedSet |
A synchronized wrapper class for sets.
|
| ByteSets.UnmodifiableSet |
An unmodifiable wrapper class for sets.
|
| ByteSortedSets |
A class providing static methods and objects that do useful things with type-specific sorted sets.
|
| ByteSortedSets.EmptySet |
An immutable class representing the empty sorted set and implementing a type-specific set interface.
|
| ByteSortedSets.Singleton |
A class representing a singleton sorted set.
|
| ByteSortedSets.SynchronizedSortedSet |
A synchronized wrapper class for sorted sets.
|
| ByteSortedSets.UnmodifiableSortedSet |
An unmodifiable wrapper class for sorted sets.
|
Provides type-specific classes for byte elements or keys.
Copyright © 2019. All rights reserved.


Honoring the Fallen: An Interactive Memorial Map
John R. McDonough
- Date of Birth: 05/10/1939
- Home Record: South Orange
- State: NJ
- Branch: Navy
- Place of Death: MIA, Pacific Ocean
- Year of Death: 1966
- Villanova Class Year: 1962
- Major: Economics
About
John R. McDonough served during the Vietnam War. He had the rank of Lieutenant. His service number was 154308223. He served with USNAVFORV, Vaw 13, TF 77, USS Hancock. Lieutenant McDonough, U.S. Naval Reserve, was a member of Carrier Early Warning Squadron 13, Carrier Air Wing 15 aboard the Aircraft Carrier USS CONSTELLATION (CVA-64).
On June 20, 1966, he was the pilot of a Douglas Skyrader Electronic Surveillance Aircraft (EA-1F) on a night mission. During the launch, the bridle connecting the aircraft to the catapult broke, and the aircraft fell of the carrier bow and snagged. His remains were not recovered. John is honored on the Vietnam Veteran’s Memorial in Washington DC. Name inscribed at VVM Wall, Panel 08e, Line 67. He is buried at the Honolulu Memorial Cemetery, Honolulu Hawaii.
Works cited
- John R. McDonough. HonorStates.org.https://www.honorstates.org/index.php?id=286857
- John R. McDonough. Vietnam Veterans Memorial Fund Wall of Faces. https://www.vvmf.org/Wall-of-Faces/36556/JOHN-R-MCDONOUGH/
- College, V. (1962). Belle Air 1962. Villanova, PA : Villanova College. https://library.villanova.edu/Find/Record/vudl:540336
Cite this article
"John R. McDonough." Honoring the Fallen: An Interactive Memorial Map. http://localhost:4000/article/1962-01-01-johnrmcdonough.html


Mode of Travel:
Driving
Walking
Bicycling
Transit
Destination:
Google Dublin
Buckingham Palace
Google London
KFC Dublin


Comet parameter: max_variable_mods_in_peptide
- Specifies the total/maximum number of residues that can be modified in a peptide.
- As opposed to specifying the maximum number of variable modifications for each
of the 6 possible variable modifications, this entry limits the global number
of variable mods possible in each peptide.
- The default value is "10" if this parameter is missing.
Example:
max_variable_mods_in_peptide = 6
max_variable_mods_in_peptide = 10


Merchant Galibredo:
Where are you from, youngster? What are you looking for?
No, no, I'm not talking about goods... I want to know why you came here...
Sorry -- I'm not speaking very clearly. Never mind!
Can I help you find anything today?
Buy accessories.
View information about the local lord and tax rate.
Quest


Windows provides 'Credential Store' framework to store the network based passwords in a secure encrypted format. This provides convenient and reliable mechanism to store the passwords for network logins so that user don't have to enter the password every time while accessing the network resources.
Windows also allows applications to seamlessly manage this 'Credential Store' using Credential Management API functions [
Reference 2] such as CredEnumerate, CredRead, CredWrite, CredProtect, CredUnprotect, CredDelete etc.
For Windows XP
On Windows XP, the encrypted user credentials are stored in the hidden file called 'Credentials' inside both APPDATA and LOCALAPPDATA locations mentioned below.
APPDATA Location - C:\Documents and Settings\<username>\Application Data\Microsoft\Credentials\<user sid>\
LOCALAPPDATA Location - C:\Documents and Settings\<username>\Local Settings\Application Data\Microsoft\Credentials\<user sid>\
For Vista & Windows 7
Vista onwards, the user credentials are stored in the multiple files with random name (generated using GUID) inside both APPDATA and LOCALAPPDATA locations mentioned below. (There will be separate credential file for each of the network accounts)
APPDATA Location - C:\Users\<username>\AppData\Roaming\Microsoft\Credentials\
LOCALAPPDATA Location - C:\Users\<username>\AppData\Local\Microsoft\Credentials\
These credential files are hidden and not visible even if you have enabled 'show hidden files/folders' in the folder settings. To view these files, use the command prompt and navigate to the above locations and then issue the 'dir /a' command.
Each of these credential file begins with standard signature at the beginning of the file which can used for its verification. Here are the first 16 bytes representing the identity of such credential file.
0x01, 0x00, 0x00, 0x00, 0xD0, 0x8C, 0x9D, 0xDF, 0x01, 0x15, 0xD1, 0x11, 0x8C, 0x7A, 0x00, 0xC0


--- layout: post title: Coding Dojo at Sussex University date: 2007-03-22 00:00:00 categories: personal software-development ---
The Brighton Coding Dojo Night offers "an exciting opportunity to collaborate with others to explore group computer programming - where groups of people work together to create a single program. This event hopes to bring together a mix of public, students and professionals looking to explore creative group coding in a unique atmosphere. Although some basic knowledge of programming concepts is preferred, you do not need to be proficient in any one language."
I'm really looking forward to this :)


import {toHexString, toOpcodeString} from "../util/OpcodeUtils";
import {Opcode} from "../Opcode";
class Chip8Error extends Error {
constructor(message: string, ...args: any) {
super(args);
this.message = message;
}
toString(): string {
return `${this.constructor.name} - ${this.message}`;
}
}
export class DisassemblerError extends Chip8Error {
opcode: number;
address: number;
constructor(address: number, opcode: number, message: string) {
super(message);
this.address = address;
this.opcode = opcode;
}
toString(): string {
return `Couldn't disassemble opcode ${toOpcodeString(this.opcode)} from address ${toHexString(this.address)}, ${this.message}`;
}
}
export class StackOverflowError extends Chip8Error {
programCounter: number;
opcode: Opcode;
constructor(programCounter: number, opcode: Opcode, message?: string) {
super(message || '');
this.programCounter = programCounter;
this.opcode = opcode;
}
toString() {
return `The program caused a stack overflow at address ${toHexString(this.programCounter)} from opcode ${this.opcode}`;
}
}
export class IllegalMemorySpace extends Chip8Error{
programCounter: number;
opcode: Opcode;
constructor(programCounter: number, opcode: Opcode, message?: string) {
super(message || '');
this.programCounter = programCounter;
this.opcode = opcode;
}
toString() {
return `The program accessed illegal memory space ${toHexString(this.programCounter)} from opcode ${this.opcode}`;
}
} |


Settings
Choose your theme highlight color
Last.FM Status: Not Authorized
exit_to_appLog in to Last.FM
Default media keys will continue to work regardless of these settings. These settings are in addition to the defaults.
Use the "Escape" key to reset the hotkey.


# -*- coding: utf-8 -*-
"""
scheduler.py
Created on Nov. 12, 2017
by Boxuan
"""
import argparse
import os
import sys
import random
from scheduler.models import Session
from django.utils import timezone
from dateutil import parser
from datetime import timedelta
from wallet.models import Transaction
from django.core.mail import send_mail
from account.models import User
[docs]def begin_all_sessions(time):
print("begin all sessions, time = ", time)
# get all sessions start at specific time
sessions = Session.objects.filter(start_time=time)
for session in sessions:
#print("\nsession.id = ", session.id)
records = session.bookingrecord_set.all()
for record in records:
if record.status == record.INCOMING:
record.status = record.ONGOING
record.save()
#print("set record (id: ", record.id, ") status from INCOMING to ONGOING")
#print("set session from ", session.status, " to ", session.CLOSED)
session.status = session.CLOSED
session.save()
[docs]def end_all_sessions(time):
print("end all sessions, time = ", time)
# get all sessions end at specific time
sessions = Session.objects.filter(end_time=time)
for session in sessions:
#end sessions which just finish
#print("\nsession.id = ", session.id)
records = session.bookingrecord_set.all()
for record in records:
if record.status == record.ONGOING:
record.status = record.FINISHED
record.save()
#print("set record (id: ", record.id, ") status from ONGOING to FINISHED")
# only Private Tutor session has transaction
if session.tutor.tutor_type == session.tutor.PRIVATE_TUTOR:
transaction = record.transaction
receiver = transaction.receiver
amount = transaction.amount
commission = transaction.commission
# tutor receives tuition fee
receiver.user.wallet_balance += amount
receiver.user.save()
# send email to tutor about balance change
content = "Please check on Tutoria, your session " + str(session.id)
content += " has finished and your wallet balance has changed from "
content += str(receiver.user.wallet_balance - amount) + " to "
content += str(receiver.user.wallet_balance)
send_mail('Session Finished & Balance Change', content<EMAIL_ADDRESS>[receiver.email], False)
# (todo) company receives commission
myTutor = User.objects.get(username='mytutors')
myTutor.wallet_balance += commission
myTutor.save()
#print("transaction id = ", transaction.id, "transfer tuition fee = ", amount, " to tutor = ", receiver)
# send email to student (review reminder)
content = "Please check on Tutoria, your session " + str(session.id)
content += " has finished and you can give a comment to the tutor at "
content += "http://<IP_ADDRESS>:8000/tutor/" + str(session.tutor.id) + "/review"
send_mail('Session Finished, Please give your comment', content<EMAIL_ADDRESS>[record.student.email], False)
lock_time_bound = time + timedelta(days=1)
print("lock_time_bound = ", lock_time_bound)
sessions = Session.objects.filter(start_time__gt=time, start_time__lt=lock_time_bound)
for session in sessions:
if session.status == session.BOOKABLE:
print(session)
session.status = session.CLOSED
session.save()
[docs]def run(flag, time):
# parse the time string to datetime format
time = parser.parse(time)
# make timezone aware
time = timezone.make_aware(time, timezone.get_current_timezone())
if (flag):
begin_all_sessions(time)
else:
end_all_sessions(time)
[docs]def run_range(start_time, end_time):
start_time = parser.parse(start_time)
start_time = timezone.make_aware(start_time, timezone.get_current_timezone())
end_time = parser.parse(end_time)
end_time = timezone.make_aware(end_time, timezone.get_current_timezone())
time = start_time
while time <= end_time:
end_all_sessions(time)
begin_all_sessions(time)
time += timedelta(minutes=30)
[docs]def help():
print("call run(flag, time) to start/end all sessions")
print("example: run(True, \"Nov 17 2017 9:00AM\") means begin all sessions")
print("\n\n================================")
print("call run_range(start_time, end_time) to go over the range")
print("example: run_range(\"Nov 17 2017 0:00AM\", \"Nov 17 2017 11:30PM\") would begin & end all sessions in the day in turn")
if __name__ == '__main__':
run(True, "Nov 17 2017 9:00AM")
## create ArgumentParser() object
#parser = argparse.ArgumentParser()
## add argument
#parser.add_argument('--flag', required=True, help='True: begin_all_sessions; False: end_all_sessions')
#parser.add_argument('--time', required=True, help='Type in a time')
#
## parse argument
#try:
# args = parser.parse_args()
#except:
# parser.print_help()
# raise
#run(args.flag, args.time)


D
istributed
I
on
C
hromatogram
E
xtractor
Contact:
<EMAIL_ADDRESS>for feedback, comments, complaints etc.


A bunch more minor tweaks!
-
Tutorial is now excluded from the school end time because it's effectively
optional.
-
Period 8 is now disabled by default to reduce confusion. If you have a
period 8, turn it back on in Options.
- PSAs won't be marked as read when UGWA auto-updates.
-
The alternate schedules stored offline has been reset, so last year's
alternate schedules don't prop up this year and show school on Saturday.
-
The normal schedule will show as a placeholder while alternate schedules
load.
-
Notifications at the start of a period will open the period's associated
link when clicked.
- Empty assignments are editable now.
-
Fixed colours not showing properly in the assignment editor's period
dropdown.
- There's now a hint on how to stop viewing a barcode just in case.
Also, check out the latest video by the Ovine Office of Propaganda and
Service:


Modern Warfare looks stunning in 4K, the best enhanced games for PS4 Pro
Best PlayStation 4 Pro Enhanced Games Android Central 2019
PlayStation 4 Pro enhancements vary from game to game, with some focusing on visuals while others pump energy into their performance. Just because a game looks good, though, doesn't mean it is good. The games below strike the perfect balance of being top-quality games regardless of any enhancements, but their improvements only make them that much better.
- ★ Featured favorite: Call of Duty: Modern Warfare
- Tense and scary: Resident Evil 2 Remake
- RPG Greatness: Outer Worlds
- Kick some Nazi ass: Wolfenstein II: The New Colossus
- Wild West outlaws: Red Dead Redemption 2
- Norse mythology: God of War
- Ancient Greek adventures: Assassin's Creed Odyssey
- Zombie Infected apocalypse: The Last of Us Remastered
- Travel the world: Uncharted 4: A Thief's End
- A galaxy far, far away: Star Wars Battlefront II
- A PS2 classic: Shadow of the Colossus
- Web-slinging fun: Marvel's Spider-Man
★ Featured favorite: Call of Duty: Modern Warfare
Staff pick
Modern Warfare is a return to world-class form for Infinity Ward and Activision. The campaign is engaging, while the multiplayer modes offer many hours of entertainment with your friends. If you haven't played a Call of Duty game before, now is the time to pick up this modern classic.
Tense and scary: Resident Evil 2 Remake
Horror fans owe it to themselves to play the Resident Evil 2 Remake, and it's not something anyone else should miss out on either — if you can stomach it. Quickly regarded as one of the greatest remakes of all time, Resident Evil 2 gives players a choice on PS4 Pro of choosing between checkerboarded 4K at 30FPS or a lower resolution at 60FPS. Zombies never looked so good.
RPG Greatness: Outer Worlds
From the creators of Fallout: New Vegas comes one of the hottest games this year. The RPG elements are breathtaking, as are the worlds you get to explore. When you are using a PS4 Pro, the worlds come alive like never before.
 As it turns out, it happened to be a load of fun, and over on PS4 Pro, the resolution is bumped up to 1440p. It's not the most impressive enhancement, but it's certainly welcome.
Wild West outlaws: Red Dead Redemption 2
Rockstar makes some of the best games in the business, as evidenced by Red Dead Redemption 2. You'll be hard-pressed to find glaring criticisms with the game — other than the labor practices it was created under. This stunning creation of the American Wild West as the time of cowboys and outlaws was fading away runs at 4K on PS4 Pro with HDR support.
Norse mythology: God of War
Kratos and Atreus became nearly everyone's favorite father/son duo after God of War released. Their journey is as harrowing as it is emotional, and it was beautifully captured in a game with impeccable gameplay mechanics to boot. On PS4 Pro, players can choose to either favor performance or resolution, whether you need the best visuals possible at checkerboarded 4K or want the game running at an unlocked frame-rate capped at 60FPS.
Ancient Greek adventures: Assassin's Creed Odyssey
Ubisoft's latest historical venture thrusts players back into the middle of ancient Greece during the Peloponnesian War. Sprawling city-states surrounded by imposing mountains and the Aegean sea can be viewed at a dynamic resolution on PS4 Pro, with the highest native resolution maxing at around 1620p. Just be sure to make good use of Odyssey's photo mode.
Zombie Infected apocalypse: The Last of Us Remastered
Joel and Ellie's journey originated on PS3, but PS4 is where it found its new home. The Last of Us Remastered takes one of last generation's most highly-acclaimed games, and lets players choose from a variety of resolution, frame-rate, and shadow configurations on PS4 Pro. Enjoy it in stunning 4K at 30FPS or go for 60FPS at 1800p.
Travel the world: Uncharted 4: A Thief's End
Nathan Drake's final adventure on the hunt for pirate Henry Avery's long lost treasure is best experienced on PlayStation 4 Pro. From the coastlines of Madagascar to the Scottish Highlands, everything looks beautiful at 1440p with HDR support, giving its colors more vibrancy and the resolution a crisp edge that wasn't present before.
A galaxy far, far away: Star Wars Battlefront II
Say what you want about EA and Battlefront II's initial microtransactions, but it's actually not a bad game when you get past the controversy and focus on its actual content. Not only does it have several multiplayer game modes spanning the prequel trilogy all the way until the recent sequels, but it also has a dedicated single-player campaign. Star Wars Battlefront II runs at 1440p and 60FPS on PS4 Pro.
A PS2 classic: Shadow of the Colossus
Shadow of the Colossus launched on PS2 but was rebuilt from the ground up specifically for PlayStation 4. The best way to experience this classic title is undoubtedly on PS4 Pro, which can render it at 4K running at 30FPS or 1080p at 60FPS. If you missed out on it over a decade ago, now's the time to pick it up.
Web-slinging fun: Marvel's Spider-Man
Join your friendly neighborhood Spider-Man on his heroics through New York City in stunning 4K with HDR support on PS4 Pro. Insomniac absolutely knocked this one out of the park, and it may very well be one of the best superhero video games ever to release — it certainly gives the Batman Arkham series a run for its money.
The cream of the enhanced crop
The best first-person game in a long time, Modern Warfare looks amazing enhanced on a PlayStation Pro. If you don't enjoy shooting games, you can't go wrong with God of War, with its compelling storyline and impressive dad beard.
Speaking of a compelling storyline, if you haven't tried The Last of Us enhanced for the PS4 you are missing out on one of this generations best games, the way it was meant to be seen.
PS4 enhanced games will likely become more common, and as we moved towards the PlayStation 5, 4K games will become the standard. Developers are likely to make more enhanced games to get ready for the PS5 launch. Look for more games in the coming months.
We may earn a commission for purchases using our links. Learn more.


[Moderator's note: I am splitting these reviews up by country, because I have to split them up some way. I am not trying to be provincial. -ecl]
SIFF Reviews (English-Language, non-USA) Film reviews by Jeff Meyer Copyright 1991 Jeff Meyer
TRULY, MADLY, DEEPLY (Britain, 1990):
Top-notch comedy/drama about a woman who is having a very hard time getting over the death of her husband. So, one weekend -- he comes back! Nice plot (I like the ending particularly), very funny dialogue at times, and a number of good actors (Alan Rickman as the dead husband, Michael Maloney, Bill Paterson) completely dwarfed by Juliet Stevenson's wonderful performance as the lead -- she is enormously engaging and sympathetic, and has the sort of personality that the screen can barely contain.
[Rickman appeared after the film; he has worked with Stevenson in the Royal Shakespeare Company, and spent most of the time praising her performance. Liked his comment about his role in the new Costner ROBIN HOOD, PRINCE OF THIEVES, as the Sheriff of Nottingham: "I haven't seen the film yet. I suspect what you'll see of me on the screen will be me -- but somewhat louder."]
DECEMBER BRIDE (Ireland, 1990):
Beautifully-shot film of passion, religious tension and scandal in rural Ireland at the turn of the century. Dialogue is generally substituted for many heavy, passionate looks between the principals (an independent woman and the two brothers who she serves); unfortunately, they're not *that* good at staring, so it's basically a washout. Pretty to look at, though.
 DROWNING BY NUMBERS is a visually and symbolically stunning film; the characters circle around the plot like satellites in their own erratic orbits, tied to the events and settings of the story by some fatalistic sense of gravity. It is surreal in the extreme, with various elements (of both the plot and visual variety) crisscrossing with one another throughout the length of the film.
The characters themselves have all the humanity of Delphic oracles; they're there to say things, and to symbolize things, and to act as figures in the painting. DROWNING BY NUMBERS is more of a series of sequential paintings than a movie; it has the mathematical precision of a Bach orchestral suite, and slightly less humanity. It's precisely the sort of film that normally annoys the hell out of me -- character development sacrificed for form, and meaning and message superseded for the visual quality. But whatever pretensions DROWNING BY NUMBERS has are blotted out by Greenaway's amazing skills in cinematography and image composition. Simply put, Greenaway gets away with it. Why? Because it works. Because I never lost interest in it. Because.
If you can put up with this sort of thing, it shouldn't be missed; most people, I think, won't like it -- I would only recommend it to particular acquaintances. It tells a story (of a series of women who murder their husbands, by the way), but the story isn't the point of the film. For me, DROWNING BY NUMBERS was the most technically and visually impressive film of the festival, and probably the one that gave my brain the most grist for the mill. A film completely for the head, and completely absent from the heart. Approach with caution, but if so inclined, jump in. You may get in over your head, and you may not.
THE BIG STEAL (Australia, 1990):
I'd put this in the higher end of teenage coming-of-age/romance/sex-comedy films.  Nothing new for the genre, but it's nicely done, with some pleasantly odd performances by supporting cast members (particularly those playing Danny's parents) and some well-timed farce in the second half. It builds towards the end, and turns out to be a lot more entertaining than you'd credit it could be during the first half hour.
PRISONERS OF THE SUN (Australia, 1990):
A docu-drama, based on the war trial where a number of Japanese POW camp officials were tried for war crimes after World War II. Bryan Brown plays the prosecuting attorney, trying to find links between the murder of several Australian airmen and a high military official (George Takei) who ran the camp, and is now valuable to the Americans as a leader in the post-war Japanese government. There's nothing wrong with the film, but as a story there are no surprises, the pace is rather leaden and there's a certain feeling of inevitability to the whole thing. Not something to complain about in a documentary, but in a drama... The US cinema produced waves of films like this in the late 70s and early 80s, and I (and, I suspect, many others) have become sort of burned out on them.
STAN AND GEORGE'S NEW LIFE (Australia, 1990):
This is one of those films that you really want to like -- the premise is good, the actors are well-cast and engaging, and yet... it never really gets off the ground. Stan is a shy, middle-aged barber (for you comix fans, Rob pointed out to me that the actor playing Stan looks like Reid Fleming, the World's Toughest Milkman, on qualudes) who decides to go out and change his life; he goes to work for the weather service. There he meets George, a quiet, cheerful woman who keeps the meteorological data collected and reported by the farmers. The two of them are charming together, but their relationship becomes overshadowed during the last half of the film by a semi-comic conspiracy within the department to cover up incorrect data. You end up feeling cheated that you didn't spend more time with the two principals, and not their odd relatives or co-workers.
STRANGERS IN GOOD COMPANY (Canada, 1990):
If I'm a lucky sod, I'll see a dozen films at the festival that are good through and through; enjoyable to watch for any number of reasons, if not, perhaps, a complete success on the part of the filmmakers. But if the cinematic dice are really rolling out a winning streak, I'll see a film where it becomes obvious very early on that the person in the driver's seat knows exactly what s/he's up to, and that I'm in for a damn fine show. There were two of them this year: Greenaway's DROWNING BY NUMBERS, and Cynthia Scott's STRANGERS IN GOOD COMPANY. (*NOT* to be confused with the recent Christopher Walken film, THE COMPANY OF STRANGERS.) The films couldn't be more different (thank God -- I'm not sure the world is ready for two Peter Greenaways), but there is not an iota less exactness in Scott's film than in DROWNING BY NUMBERS.
STRANGERS works on a simple premise: a busload of elderly women are travelling in backwoods British Columbia when their bus breaks down. They are stranded in a remote, abandoned farmhouse, and must dust off and unite their various skills while waiting to return home. No, this does *not* take a turn into suspense, battle for survival, etc. As these women spend time waiting for rescue, each is slowly, patiently revealed to us, in conversation with one another, and as they explore the beautiful countryside around them. It is a cliche to say that everyone is extraordinary, if you look closely enough; but the cliche is borne out here. Perhaps it is particularly enlightening, because so many of these women have the appearances (and in some case, mannerisms) we commonly attribute to elderly; with no sense of rushing or hurry, Scott brings out their remarkable lives and personalities. Scott's previous films have all been documentaries, and while STRANGERS could be considered a documentary in its characters, if not its plot, it is obvious that the director has learned how to use the camera to give a feeling of reality and -- more importantly -- sincerity.
As we grow older, those loved ones who are older still become easily isolated and categorized in our minds. We move away from home; our own lives take center stage for us, and (unless we are lucky or persistent or inordinately considerate) loved ones who were woven throughout our daily pattern are relegated to memory, or touchstones to memory; encounters are spent remembering one's past with them, while their present condition becomes more and more of an icon -- the loved one is substituted by an "elderly person". STRANGERS IN GOOD COMPANY reminds us -- it reminds me, anyway -- that the people we strive to see through the wrinkles are still there; and maybe, if we dig just a little, someone even more remarkable that we never had the chance to meet when we were younger. Not a chance to throw away. Cynthia Scott didn't; I think you'll be very glad of that if you see this film.
ISABELLE EBERHARDT (France/Australia, 1991 (World Premiere)):
Ah, time again for one of those continental stories of tragic heroines running around turn-of-the-century Europe, innocent and courageous and hard-drinking and chock-full of integrity as all get-out. Eberhardt goes to Algiers to examine the French occupation of the Arab territories as a reporter. She is thwarted at every turn by the authorities, particularly a nasty Lt. who likes to tie her up and imprison her in a frightfully Victorian manner; but she manages to make friends with the Arabs and report the story at the Risk of Her Own Life. (Amazing, as I would imagine her choice of clothing, particularly the lack of a veil, would keep a solitary woman from getting much attention from the leadership of an Arab camp. However, my ignorance of Arab customs is boundless, so I bow to the experts.) In between all this, she throws herself at a ragged young French soldier, who seems rather surprised (probably because she comes out of three-day treks through the desert looking like she just doused herself in Chanel #5 and prepared for a Premiere magazine photo shoot.)
This being a European tragic semi-documentary, the couple quarrel a lot about their relationship, and end up with a consumptive disease at the end. (Though that's not how Eberhardt buys it; suffice it to say that while it's a nice effect, I burst out laughing.) Isabelle Eberhardt was apparently a real person; the director tried to convince us after the screening that, while much of the film was based on periods of Eberhardt's life which are undocumented, the events here "could have" occurred. (Much as if Eberhardt "could have" been visited by space aliens or Elvis in the desert.) The production values are good, the photography excellent, and you get to see Peter O'Toole ride through the desert again, though not on a camel. (All it did was make me long for Maurice Jarre's soundtrack.) Lots of unintentional humor, but not enough to get you out to see it. Pfft.
THE WHITE ROOM (Canada, 1990 (US Premiere)):
THE WHITE ROOM is an engaging little fable about true love, voyeurism, the world's view of celebrities, shyness, murder and rock music. Sound interesting? It is, and except for a rather weak ending, it's a fascinating little movie, hovering between suspense and comedy. The fable format, with the narrator, is an excellent way to unfold the story, which deals with a young man who's voyeurism into a rock singer (Margot Kidder's) apartment makes him a witness to a brutal murder. Shaken up by this, he leaves home to find his way in the Big City; here, he uncovers several links to the murders, and meets a mysterious woman in black.
The director, Patricia Rozema, previously made I'VE HEARD THE MERMAIDS SINGING; from the descriptions, this film is quite a bit different than that one. One comes to care for the main characters, though (and despise one of them), and while the ending seems a bit of a band-aid to being painted into a plot corner, it's not too objectionable. If you like rather odd fairy tales (but not too odd), try this out.
Moriarty, aka Jeff Meyer INTERNET<EMAIL_ADDRESS>Manual UUCP: {uunet, uw-beaver, sun, microsoft, hplsla}!fluke!moriarty .
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


The First Photos of Shay Mitchell’s Daughter Atlas Are Here, and Y’all, She’s a Cutie!
by Alessia SantoroWhen Shay Mitchell's daughter was first born, all we got to see of the little one, named Atlas Noa, was her teeny hand.
The first full photos of Atlas were shared in an interview in Vogue in which Shay said of new motherhood, "I find myself being a lot more present, and I'm just looking at her every single day. You reflect on how fast time passes when you're forced to slow down. The surprising thing is how much I enjoy this calmness." Aw!
Keep scrolling to see all of the photos of Atlas that we have so far. We can't wait for Shay to share more!
Pictures of Shay Mitchell's Daughter, Atlas
A post shared by Shay Mitchell (@shaymitchell) on Nov 18, 2019 at 9:35am PST
A post shared by Shay Mitchell (@shaymitchell) on Oct 20, 2019 at 7:05pm PDT
A post shared by Shay Mitchell (@shaymitchell) on Nov 6, 2019 at 1:48pm PST
Image Source: Flannery Underwood


I'm a UX designer and programmer who's had too much education, and continues to learn. Recently I've been learning React via the Fullstack online course, and I've realized that front-end programming isn't as terrible as I first thought.
Project was completed at Juno College. I had to research the current mobile and web process for purchasing tickets, as well as check out the kiosks. After doing some location scouting, as well as conducting some interviews to gauge how people feel about purchasing tickets, I chose to focus on the mobile purchasing flow. Also, conducting a preliminary usability evaluation lead me to realize that there were some problems there.
I repeatedly heard that users were uncertain that they were buying tickets for the correct day, and that it was not easy to compare different movies at different theatres. So I busted out the pencils and got to sketching.
I used these sketches to do some quick paper prototyping with classmates, to make sure I wasn't missing anything, before committing to a digital "paper prototype". This next round of testing is where it gets interesting, as some of the choices I made were not resonating with the people I was testing. And despite some initial frustration ("Maybe they just don't get it...") I remembered that this is the point of testing! I realized that I was making some things more confusing (not having sensible defaults for some of the fields, requiring the user to fill in extra info to get to where they need) that I tried to correct in my final prototype.
Overall I'm happy with how it turned out. I feel like I learned a lot, especially with how to use sketch, and get through an entire research proposal, from ideation to prototyping.
A project I did while interviewing for a previous job, I am proud of my work on this one. I was tasked with doing a player evaluation (UX for game speech) for a mobile game. I had to focus on the new player experience over the first 1-2 hours, and give my feedback.
Where it all started, university class project. How we went about user testing the (now semi-defuct) Bixi Bike Toronto website.