text:
Object Oriented Programming
| A Wikibookian believes this page should be split into smaller pages with a narrower subtopic.
You can help by splitting this big page into smaller ones. Please make sure to follow the naming policy. Dividing books into smaller sections can provide more focus and allow each one to do one thing well, which benefits everyone.
Object Oriented Programming (OOP) means any kind of programming that uses a programming language with some object oriented constructs or programming in an environment where some object oriented principles are followed. At its heart, though, object oriented programming is a mindset which respects programming as a problem-solving dilemma on a grand scale which requires careful application of abstractions and subdividing problems into manageable pieces. Compared with procedural programming, a superficial examination of code written in both styles would reveal that object oriented code tends to be broken down into vast numbers of small pieces, with the hope that each piece will be trivially verifiable. OOP was one step towards the holy grail of software-re-usability, although no new term has gained widespread acceptance, which is why "OOP" is used to mean almost any modern programming distinct from systems programming, assembly programming, functional programming, or database programming. Modern programming would be better categorized as "multi-paradigm" programming, and that term is sometimes used. This book is primarily aimed at modern, multi-paradigm programming, which has classic object oriented programming as its immediate predecessor and strongest influence.
Historically, "OOP" has been one of the most influential developments in computer programming, gaining widespread use in the mid 1980s. Originally heralded for its facility for managing complexity in ever-growing software systems, OOP quickly developed its own set of difficulties. Fortunately, the ever evolving programming landscape gave us "interface" programming, design patterns, generic programming, and other improvements paving the way for more contemporary Multi-Paradigm programming. While some people will debate endlessly about whether or not a certain language implements "Pure" OOP—and bless or denounce a language accordingly—this book is not intended as an academic treatise on object oriented programming or its theory.
Instead, we aim for something more pragmatic: we start with basic OO theory and then delve into a handful of real-world languages to examine how they support OO programming. Since we obviously cannot teach each language, the point is to illustrate the trade-offs inherent in different approaches to OOP.
- 1 Introduction
- 2 Classes, Types, and Classic OOP
- 2.1 Simple Objects vs Behavioral Entities
- 2.2 Encapsulation
- 2.3 "State" is Evil!
- 2.4 Inheritance
- 2.5 Object/Relational Mappings
- 3 Separation of Static and Dynamic
- 3.1 Systems Architecture
- 3.2 The Benefits of Static Analysis
- 3.3 Traditional Neglect of Dynamic Analysis
- 4 Messages, Protocols and Dispatch
- 5 Interfaces
- 6 Lifetime Management
- 7 Generic Programming
- 8 Abstraction Barrier
- 9 The Introduction of Functional Programming Ideas
- 10 See also
For an overview and history of Object Oriented programming OOP, please reference the Wikipedia article.
The reader is expected to have a basic familiarity with programming in general, as we will give examples in a variety of languages. We will explain any non-obvious syntax in the discussion, although this is besides the point. The point is to give some indication of the flavor of the languages and some insight into the real-world application of OO ideas.
We will divide up OOP into two phases— classic and modern. While this distinction is somewhat arbitrary, we believe it is instructive to consider OOP as it was practiced in the 1980s and early 1990s to demonstrate the motivation for more current practices.
What is Classic OOP?
Object oriented programming can be traced back to a language called Simula, and in particular Simula 67, which was popular during the 1960s. It was Simula that first instituted "classes" and "objects," leading to the term "object oriented" programming. By the early 1990s, enough experience had been gained with large OOP projects to discover some limitations. Languages such as Self, ideas like interface programming (also known as component or component-oriented programming), and methodologies such as generic programming were being developed in response to these difficulties. Although often derided by OOP purists, it was the standardization of C++ in 1998 —including generic programming facilities — that really ushered in the modern era of OOP, which we also refer to as Multi-Paradigm programming. This is largely due to the popularity of C++ and the genius of the Standard Template Library (STL) demonstrating the utility of the new methodology to such a large audience.
Classic or Pure OOP[edit]
By 1980, Xerox had made Smalltalk available to outsiders, appropriately named Smalltalk-80. Unlike other early programming languages, Smalltalk was a complete environment rather than just a language, a characteristic it had in common with Lisp at the time. While Lisp machines were foreshadowing IDEs to come, Smalltalk was pioneering the GUI, ultimately influencing the development of the Macintosh computer. Meanwhile, while Xerox was developing Smalltalk during the 70s, the C language was becoming popular thanks to UNIX being largely written in C. Therefore, it was C —an otherwise unlikely candidate —that Bjarne Stroustrup fused with ideas from Simula to create "C with Classes" which was renamed to C++ in 1983. In 1985, unsatisfied with Smalltalk, C++, and various object systems being tacked onto Lisp dialects, Bertrand Meyer created Eiffel. Even though much more recent, Java essentially cloned vintage C++, and so we consider Smalltalk, vintage C++, Eiffel, and Java to be Classic OOP. The object systems tacked onto Lisp (eventually standardized as CLOS in 1994) produced a very different methodology. While we don't consider CLOS to be Classic OOP, it did influence modern OOP.
Modern OOP and Multi Paradigm Programming[edit]
Classic OOP developed a tendency to over-rely on a technique called "inheritance," and eventually programmers realized that they were using inheritance for many things that are conceptually distinct. Modern OOP basically incorporates these concepts, sometimes as language level features, sometimes through programmer practice. The goal largely being looser coupling, easier maintenance and reuse. Historically, David Ungar and Randall Smith completed their first working Self compiler in 1987, and by 1990 Sun Microsystems had picked up the project. While Self did not survive to really become a modern OOP language, it was a second generation OOP language. Then, in the early 1990s, Alexander Stepanov and Meng Lee pioneered generic programming and wrote early drafts of C++'s STL. This began a (still ongoing) trend of incorporating functional programming ideas into more traditional OOP environments, in a kind of reverse CLOS. Additionally, the early 1990s saw the development of CORBA and Microsoft's COM, which was a natural extension of the ideas that had led to the original Windows API. This interface or component programming was a natural extension of encapsulation —a basic tenet of OOP, as we will see. All of these developments were aimed at further managing or reducing complexity. Since this was the original goal of OOP and these techniques are used in conjunction with classic OOP, we find it appropriate to consider them in a treatment on "OOP".
Contemporary object oriented programming, therefore, tends to be rather distinct from classic object oriented programming. Particularly, getting used to which abstractions are the most useful for which problem types is more challenging now that there are more from which to choose! In a now classic book, Gamma et. al. introduced Design Patterns which helped to synthesize a variety of OOP techniques as applied to very common problems.
Future of OOP[edit]
The future contains more standardization of functional programming techniques in OOP environments, particularly lambda expressions and closures, and more robust meta-programming constructs. Applying design patterns automatically through generic or meta programming techniques is an interesting area.
What is an Object?[edit]
Loosely, the term object is used to conjure up connections with real world objects like a chair or a guitar. Except that for software, only some simplified abstraction is used, designed specifically for the task at hand. While a real chair is composed of atoms and molecules and reacts to its environment based on the laws of physics and its atomic composition, a "chair object" will vary wildly depending on whether you're writing a game or a Point-of-Sale system for a furniture store. Approaching your problem from the perspective of the chair will not be as productive as approaching the chair from the perspective of your problem.
In most of the languages used in this book, you will find that technically speaking (something akin to whistling 9600 baud, I understand), an object is "an instance of a class". Great, so what does that mean? Well, we can trace this idea all the way back to Plato and his Platonic Ideal. If you spent more time watching Bill and Ted's Excellent Adventure than reading Plato, the idea is that the concept of a chair is a separate entity from any particular chair. In other words, you can conceive of a chair in the abstract without thinking of any particular chair.
In most OOP languages, this abstracted idea of a chair is called a class (from classification) and is a prototype or blueprint for actually making chairs. The act of making something from the blueprint is often called instantiating, and the made thing is both an object and an instance of the class that served as a blueprint. As humans, we normally tend to do this in reverse —we categorize objects we encounter. We can easily identify chair-like things we run into as being chairs; this classification is where we got the term class in the first place.
It is easy to drift off into abstruse philosophical debates over objectness; in some areas like knowledge representation and computational ontology they are very relevant. However, for a computer programmer, it is only necessary to figure out what your application needs to know about and do with chairs. This can be a sufficiently difficult problem, it's usually not necessary to make it harder!
If you're still fuzzy on the whole idea, consider a more technical explanation. Structs (structures), records, tables, and other ways of organizing related information predated object oriented programming. You may be familiar with something like the following Pascal code:
TYPE chair = RECORD
model : integer;
weight : integer;
height : integer;
color : COLOR;
This doesn't actually create a chair variable, but defines what a chair variable will look like when you create one. You could proceed to create arrays of chairs and so forth, and as we hope you've discovered for yourself, this kind of thing is quite indispensable for keeping your programs understandable. Object oriented programming wants to push this advantage and milk it for every ounce of understandability, correctness, and simplicity it can.
A fundamental problem solving technique is divide and conquer —you just have to figure out how to partition your problem into sub-problems. OOP innovators realized that we already had figured out ways to partition the problem, and it was reflected in the way we organized our data, like above. If you looked at an application that had that chair RECORD in it, you would surely find lots of code for doing things with chairs. Why else would you bother to define it? So, if you were to extract all of that code from all over the application and put it together with the chair definition, the reasoning goes, you should have an easier time ensuring that:
- all chair code is correct
- all chair code is consistent with each other
- there's no duplicated chair code
- overall, you have less spaghetti because chair code is no longer tangled up with sofa code etc
So you take that chair definition and that code extracted from all over the application, and call that a class. Take a chair variable and call it an object, and you're off to the races.
Since this is supposed to be a pragmatic book, let's look at our first example code, this time in Python code:
class Chair:
model = None
height = None
weight = None
color = None
def has_arms(self):
return self.model % 2 # odd-numbered models have armrests
This doesn't look terribly different from the Pascal example. The only difference is that class Chair now contains a has_arms method. Methods are functions that live within a class, and are usually used to process certain class specific data. Hopefully the purpose is fairly clear, so let me point out the important part: has_arms is a calculated or inferred property—this information is not stored directly.
In Python, you would use this class like so:
c = Chair()
c.model = 15
c.height = 40
c.weight = 10
c.color = 7
if c.has_arms():
Here, the "c" variable is an instance of the 'chair' Class, also known as a chair object. We initialize the properties like you would in Pascal (this will change later!) and do one thing if the chair has arms and something else if it doesn't. But we never initialized a "has_arms" property or anything of the like.
Since part of the goal is for you to become syntax agnostic, we present this same example again in C++:
class Chair
int model;
int weight;
int height;
int color;
bool has_arms()
return model % 2 ? true : false;
Chair c;
c.model = 15;
c.height = 40;
c.weight = 10;
c.color = 7;
if (c.has_arms())
Now, we would just like to mention that this is just the tip of the iceberg and this example is not representative of good style (in either language). There may seem like little purpose to making objects with so little functionality, and you could easily generate equivalent code that requires no new class:
struct Chair
int model;
int weight;
int height;
int color;
} c;
Chair c = {15, 40, 10, 7 };
if (c.model % 2)
The purpose of this section is to help you understand the terms; we will delve more into the benefits in the sections on encapsulation, polymorphism, inheritance, and on and on. However, let us say that while the "low-level" way might seem shorter and simpler, the object oriented benefits accrue with program size and complexity. This is not surprising, as that's what OOP was designed for, but it does make simple examples hard to come by. So bear with us.
State Machines[edit]
If you are unfamiliar with state machines, we won't delve too deep into them, but we highly recommend you look into them more. It's good for your clarity of thought process. Pedantically speaking, state machines are somewhat complicated mathematical constructs, and there are many interesting results that can be derived using the mathematical notation. But that's not our interest. Our interest is two-fold:
- For one, state machines provide a clear graphical way to illustrate potentially complicated application logic. First, you identify what your possible states are. For example, a server might be IDLE, CONNECTED, BUSY, ERROR, etc. Then, you define all the possible inputs, i.e. messages that the client might send, and for each state diagram the server's response to each input. This helps promote thoroughness as you think about reactions to unanticipated messages in various states.
- Secondly, state machines are a standard tool with a relatively standard notation. There are tools and libraries that will automatically make code given some canonical state machine format as input. This is effectively what regular expression processors do.
In object oriented programming, "objects" are sometimes implementations of state machines. State machines are a better conceptual underpinning for behavioral entities —servers, regular expression processors, graphics engine, and virtual machines are all good examples of behavioral entities.
A basic distinction between simple objects and behavioral entities is that simple objects do not change their behavior based on their value. In fact, we tend to refer to their value rather than state. Simple objects tend to be kept in collections and searched through, passed to and returned from functions, and in general act like values. String and Rectangle are classic examples. Later on, we'll discuss message passing as an abstraction of method invocation, and it may seem a little strange in the context of simple objects.
If you are still having trouble with the concept of objects, download and play with BlueJ, Most people "get it" within hours of using that IDE.
Classes, Types, and Classic OOP[edit]
There are some books on OOP that will tell you that the cornerstones of object oriented programming are encapsulation, inheritance, and polymorphism, or something along those lines. This is fairly typical of the classic OOP view, and there's nothing wrong with it per-se, it's just that we've generalized some ideas and decoupled things here and there since then.
Simple Objects vs Behavioral Entities[edit]
There are two fundamentally different types of objects, created and designed with different purposes in mind, using different techniques. We label these two types "Simple Objects" and "Behavioral Entities," although these labels are our own. Simple objects tend to represent values, like colors, coordinates, vectors, strings, etc, while behavioral entities tend to represent system components like services, message queues, engines, application logic, etc.
Simple objects, if they own anything, are just wrapping what they own (like a system level handle). Usually, however, simple objects are untied to anything else, have no complicated startup or shutdown, and have little overhead. Simple objects tend to demand high performance, guaranteed correctness, discourage incorrect usage, are put in collections, searched, passed around, and generally manipulated by the rest of the program. Writing good simple objects, combined with good collection libraries provided by your language of choice, can easily reduce the complexity of basic operations by as much as 80%. Simple objects tend to focus on the encapsulation side of OOP rather than fancy message passing, as it's usually not a helpful abstraction to think of simple objects sending or receiving messages.
Behavioral entities tend to maintain their state in various collections of simple objects, like a server keeping a list of logged in users. Behavioral entities tend to focus on behavior (to state the obvious), and configuring or tailoring that behavior in various circumstances. Message passing mechanisms, including polymorphism, tend to be central to the construction of behavioral entities. As a result, you tend to get whole families of similar entities, for example, an FTP server, an ssh server, an HTTP server, etc. that all have common functionality (like accepting connections).
One of the primary forces behind OOP is separating out all of the common elements from these families and writing it once. This has obvious advantages in debugging and maintenance: you only have to fix bugs in common code once. Obviously, this is just abstraction at work but OOP gives you a well understood set of tools to do it with. Some languages features are tailored for one or the other. For example, operator overloading is truly important for simple objects, but mostly irrelevant for behavioral entities.
Encapsulation is about risk management, reducing your maintenance burden, and limiting your exposure to vulnerabilities —especially those caused by bypassed/forgotten sanity checks or initialization procedures, or various issues that may arise due to the simple fact of the code changing in different ways over time. Technically, encapsulation is hiding internal details behind an opaque barrier so as to force external entities to interact through publicly available access points.
Think about it in the context of an OS kernel, like the Linux kernel. In general, you don't want a common user level application modifying any internal kernel data structures directly —you want applications to work through the API (Application Programming Interface). Hence encapsulation is the general term we use for giving varied levels of separation between any core system elements and any common application elements. Otherwise, "unencapsulated code" would be bad for a number of obvious reasons:
- Applications could easily set invalid or nonsensical values, causing the whole system to crash. Forcing the application to use the API ensures that sanity checks get run on all parameters and all data structures maintain a consistent state.
- Internal data structures could be updated and change (even drastically so) between seemingly minor kernel updates. Sticking to the API insulates application developers from having to rewrite their code all the time.
- Applications could be used to "snoop" on each other, elevate their privileges, hog system resources, and violate any number of security protocols if they could directly manipulate kernel data structures.
- Application developers need little or no understanding of the Linux kernel to access kernel data. The random number engine illustrates this well. It can be accessed through /dev/random instead of wading through kernel structures, and you still get the same data.
There are more, surely you can think of some. You may be thinking, "This is supposed to be about object oriented programming. I don't want to be a kernel developer!" Yes, we know, but the software kernel is the perfect example for discussing encapsulation, even though the kernel possesses no object oriented code itself. Encapsulation does not strictly apply to OOP, but it is used most within it. All the kernel's internal data —its message queues, its process lists, its filehandles, etc. —are all encapsulated inside the kernel, and cannot be seen outside the kernel. To work with the kernel, you must use its public interface, the API. For all the same reasons, writing your code in this way pertains the same benefits, even for writing a small app like a text editor or a mail client.
Since the entire purpose of encapsulation is to hide details and restrict access, it makes us consider exactly how access is restricted. It also makes us consider what exactly is a detail that needs to be protected, and what exactly should be exposed to the outside world. Figuring out what to expose, and especially at what granularity, is something of an art and we'll talk about it more in the section on interfaces. We'll move on to access restrictions, which come in two basic kinds: compile time and run time.
Encapsulation is nothing but a combining of code and data as a single unit. It is achieved using the class concept, e.g.:
class addition
int a,b;
void read()
cout<<"\n Enter two numbers";
void print()
cout<<"\n first number:"<<a;
cout<<"\n Second number:"<<b;
int cal()
return a+b;
In the above example we are combining data (
a and
b) and the methods (
cal()) in to a single unit called by
addition. Now we can access those methods by using objects.
Compile Time Enforced Access Restrictions[edit]
Many OOP languages have keywords along the lines of "public", "private" and "protected". These three were used by C++ in particular and have been oft copied since. They are used to group class members into three different levels of access:
- Public: Part of the public interface, anybody can access this member.
- Private: An internal detail, only members of this class may access this member.
- Protected: An internal detail also available to descendants of this class.
As you can see, this is not the most flexible framework for controlling access. C++ also has a "friend" keyword to allow certain exceptions to access restrictions, but other problems persist. One common problem results from single classes that grow very large: sometimes you want access restricted to a subset of a classes functions. Alternatively, many generic frameworks like serialization or persistence need access to "private" data members. Unfortunately, there is no way to differentiate between "implementation detail" and "secret information".
These kinds of language-level keywords only serve to prevent programs that violate these restrictions from compiling (and most scripting languages are compiled to some intermediate form these days). If somebody used a modified compiler that ignored these access restrictions (or in some languages just used some casting tricks), there is generally nothing to prevent a determined programmer from getting around these barriers.
Runtime Enforced Access Restrictions[edit]
Depending on the chip architecture in use, or possibly on the virtual machine running the byte code, it is sometimes possible to put "protected" information into areas of memory that will generate exceptions if read from, written to, or both. This allows for a program to abort or take other action if encapsulation is violated.
Accessors and Virtual (or Calculated) Properties[edit]
Accessors are just functions that set or return properties of an object. All too often, you'll see this kind of code in Java:
class Dummy {
private int val;
public int getVal() { return val; }
public void setVal(int val) { this.val = val; }
In this case,
getVal and
setVal are accessors, or accessor functions. Java promotes lots of gratuitous accessors, and it often looks like unnecessary bloat. Sometimes it is. But often, people miss the point of encapsulation. If
Dummy is well thought out, then
Val is conceptually a property of
Dummy. The fact that in this case that property is kept as a couple of bytes in memory is besides the point for anybody using a
"Dummy". Even more importantly, users of Dummies are protected from any changes to how Val is calculated. All too often, the writer of a Dummy class is one himself, and
Val has no logical or conceptual significance, and the accessors just get in the way.
"State" is Evil![edit]
Something that we don't see reiterated enough: State (as opposed to change) is evil! Or, (perhaps better said) maintaining unnecessary state is the root of all (er... many) bugs. Let's look at an example, now in Ruby:
# We're displaying something over time, so we're dealing
# with both pixels and seconds. Based on the zoom level,
# there is a correlation between them: pixels per second,
# or PPS.
class Timeline
GetPosInSeconds() {current_position_in_seconds;}
SetPosInSeconds(s) {current_position_in_seconds = s;} # oops, we're out of sync
GetPosInPixels() {current_position_in_pixels;}
SetPosInPixels(p) {current_position_in_pixels = p;} #oops, we're out of sync
In this example, we're maintaining gratuitous state — which is to say, we're holding the position in both seconds AND pixels. This is convenient, and important for users of this class, but we've messed up the encapsulation here. Whenever you set the value in one unit, you've destroyed the correctness for the other unit. Okay, you say, here's a simple fix:
# We're displaying something over time, so we're dealing
# with both pixels and seconds. Based on the zoom level,
# there is a correlation between them: pixels per second,
# or PPS.
class Timeline
GetPosInSeconds() {current_position_in_seconds;}
current_position_in_seconds = s;
current_position_in_pixels = s*PPS;
GetPosInPixels() {current_position_in_pixels;}
current_position_in_pixels = p;
current_position_in_seconds = p/PPS;
This fixes the obvious error with the previous example, but you've created a lot of work for yourself. Now you have to keep every calculation in every method in the Timeline class duplicated to maintain consistency. There could be dozens more where this came from (trust me). And what about when you add in other units, say inches? You have to duplicate all of that again. Presumably, you see where this is heading: calculated properties, logical properties, virtual properties, whatever you like to call them. Let's see this example again:
class Timeline
PPS; # Pixels Per Second
IPS; # Inches Per Second
GetPosInSeconds() {current_position_in_seconds;}
SetPosInSeconds(s) {current_position_in_seconds = s;}
GetPosInPixels() {current_position_in_seconds*PPS;}
SetPosInPixels(p) {current_position_in_seconds = p/PPS; }
GetPosInInches() {current_position_in_seconds*IPS;}
SetPosInInches(i) {current_position_in_seconds = i/IPS; }
Now, we're presuming that the conversion factors of PPS and IPS are set correctly for simplicity, but otherwise we've vastly simplified our problem. In twenty other functions we now write, we only have to worry about seconds, there's no consistency problems to worry about. Additionally, if we need to change our base units from seconds to pixels, the Timeline users need never know.
In many books, inheritance and OOP are made to seem synonymous, so it may seem strange that we deferred this discussion so far. This is a reflection of the diminished role of inheritance over time. In fact, one of the primary distinctions between Classic and Modern OOP lies in the usage of inheritance. As the old adage goes, if all you have is a hammer, then everything looks like a nail. And so it happened that often times, inheritance was the only tool available to the erstwhile OOP programmer, and so every concept under the sun (or at least the ghostly glow of a CRT) was crammed into inheritance. This lack of conceptual integrity and separation of concerns led to over-intimate dependencies and many difficulties. In some languages, programmer technique evolved to make the concepts clearer using the same limited language functions, while other languages explicitly developed features to address these concerns. Because you are almost certain to be exposed to some of this misguided advice at some point in your OOP learning, we'll try and explain some of the problems to you. However, much of the discussion will go in the sections where they properly belong!
First off, though, what is inheritance? Well, just like when your grandma dies and you inherit that gawd-awful ugly lamp, inheritance in OOP grants the child-class (or derived-class) all of the attributes of the parent (or super) class. So, for example (in C++):
class Parent
int f() {return 10;}
class Child : public Parent
// see, nothing here! But wait, we inherited the function f()!
Child c;
int result = c.f(); // huh? Oh, f() was inherited from the parent!
Is-A vs Has-A Moley Baloney[edit]
The most over-used and rather worthless discussion on inheritance that you will see revolves around the "Is-A vs Has-A" discussion. For example, a car is-a vehicle but has-a steering wheel. The idea these authors are chasing is that your car class should inherit your vehicle class and have a steering wheel as a member. You might also run across examples with shapes, where a Rectangle is-a Shape. The point is, once again, abstraction. The goal is to identify operations that operate only on the abstract notion of vehicle or shape and then write that code only once. Then, through the magic of inheritance, you can pass in cars or rectangles or what-have-you to the generic code, and it will work, since the derived classes are everything the parent classes are, "plus more".
The problem here is that inheritance is mixing together several things: you inherit "typeness", interface, and implementation all at the same time. However, all of the examples focus on interface while talking about "typeness". The abstract code doesn't care that a car "is-a" vehicle, just that the objects respond to a certain set of functions, or interface. In fact, if you want to give your chair class accelerate(), brake(), turn_left() and turn_right() methods, shouldn't the abstract code be able to work on chairs then? Well, of course, but that doesn't make chairs vehicles.
The kinds of solutions proposed in these "is-a" discussions have thus been mostly replaced by so-called interface programming and template programming. Since template programming offers the loosest coupling, it focused some attention on the syntactic-semantic confusion. Just because you have functions with the proper names, does that mean that they do what you think they do? If a chair class has accelerate(), brake() and other vehicle type methods, does it make sense to have generic vehicle code work on this chair? This led to more codifying of the assumptions of generic code: say, brake(INFINITY) ==> STOPPED. This implies that brake(x) != accelerate(-x). So chair may make a better vehicle than the Starship Enterprise!
Delegation and "Dynamic Inheritance"[edit]
You will see more about delegation later in the section on message passing, but we wanted to mention that many problems solved by delegation are often tackled by inheritance in languages that don't offer a delegation feature. It's easier to show an example than explain, so in short, here's what delegation looks like:
interface I { int f(); }
class A implements I { // A member variable that actually services all requests for // calls to the I interface. delegate I private_i; A(I target) { private_i = target; } }
class B implements I { int f() { return 1; } }
B b; // create a B object to be the target of A's delegation A a(b); // Create an A object, passing in b int foo = a.f(); // This call to f() is delegated to b.f(), causing 1 to be returned.
Inheritance accomplishes a similar feat
class B { int f() { return 1; } }
class A inherits B { }
A a; int foo = a.f(); // returns 1 just like in the delegation example.
However, the delegate can change over time, whereas base classes cannot. As a result, sometimes delegation is referred to as "dynamic inheritance".
Multiple Inheritance[edit]
Multiple inheritance is where an object inherits its properties from many different classes. For example, a house is both a "building" and a "place to sleep in".
In multiple inheritance, an object inherits its properties from many objects (its parents or base classes). Therefore, we need to set up some classes, which we will use C++ for:
class Building
int size;
int purpose;
int price;
class PlaceToSleepIn
int type; // tent, house, dorm, etc.
bool pleasant_to_live_in; // true or false
In C++, to inherit all the types, one uses the : operator, like so:
class House : public Building, public PlaceToSleepIn
// all of the Building and PlaceToSleepIn variables are here!
int rooms; // the number of rooms
Problems with Inheritance[edit]
One problem of Inheritance is that users of predefined classes may not know the location of the abstracted data. Therefore, it may not be easy for them to obtain it. Most of the problems with inheritance is due to design fragility or issues with the way a programming language implements it.
A normal issue in dealing with inheritance in large programs is called Fragile Base Class. It arises when subclasses of the base class make assumptions about the property (the definition of the attribute) that are outside the contract provided by the base class.
An example could be of an attribute that was declared in the base class as byte but later turns out to need the range of word. Changing this to word will necessitate at least recompiling all sub-classes but that might well not be enough because the sub-classes might have relied on the type of this attribute so that the source code also will need to be changed.
This intrinsic knowledge of the implementor about a given implementation is a problem in general programming but one that OOP/OOD does attempt to solve by offering greater opportunities for better programming practices. But as anything else with code it is up for the programmer to make use of it as to be as transparent as possible as to enable other to take full advantage of its code and so of the property of inheritance.
Object/Relational Mappings[edit]
Separation of Static and Dynamic[edit]
Systems Architecture[edit]
(Logical) Networks[edit]
The Benefits of Static Analysis[edit]
Provable Correctness[edit]
Dealing With Hierarchies[edit]
Deep Single-Rooted Hierarchy[edit]
Shallow, Multi-Rooted Hierarchies[edit]
Traditional Neglect of Dynamic Analysis[edit]
Data Flow Diagrams[edit]
Interfaces and Components[edit]
Messages, Protocols and Dispatch[edit]
Synchronous vs Asynchronous[edit]
Virtualization and Polymorphism[edit]
Polymorphism means the ability to take more than one form, that is one name,multiple forms. In oops,an operation may exhibit different behaviour in different instances. The concept of polymorphism is implemented using function overloading and operator overloading.
An Interface allows a class to expose a different set of properties and methods depending on context. For example, say that you were writing a Visual Basic 2005 application that manages clients. A client could be an individual person, or an organization. Part of the program generates address labels for clients.
You might define a person like this:
Class Person
Public LastName As String
Public FirstName As String
Public Address As String
End Class
You might also define an Organization like this:
Class Organization
Public Name As String
Public MailingAddress As String
Public BuildingAddress As String
End Class
As you can see, the main differences between a Person and an Organization are:
- a Person has both a first name and a last name, while an organization has only a single name
- an Organization has a separate mailing address, while a Person only has one address
So that you can have the one routine to print address labels, you create an interface called "IAddressLabel" (by convention, the name of an interfaces should start with a capital I).
Interface IAddressLabel
ReadOnly Property Name() As String
ReadOnly Property Address() As String
End Interface
You now change the Person class to implement this interface. The main thing to notice is that the Person's first and last names are combined on the label.
Class Person
Implements IAddressLabel
Public LastName As String
Public FirstName As String
Public Address As String
Public ReadOnly Property Address1() As String Implements IAddressLabel.Address
Return Address
End Get
End Property
Public ReadOnly Property Name() As String Implements IAddressLabel.Name
Return FirstName & " " & LastName 'combine the first and last names for the address label
End Get
End Property
End Class
You now change the Organization class to implement the IAddressLabel interface. Notice that the address for the label is the mailing address, not the building address.
Class Organization
Implements IAddressLabel
Public Name As String
Public MailingAddress As String
Public BuildingAddress As String
Public ReadOnly Property Address() As String Implements IAddressLabel.Address
Return MailingAddress 'Use the mailing address for the address label
End Get
End Property
Public ReadOnly Property Name1() As String Implements IAddressLabel.Name
Return Name
End Get
End Property
End Class
Now you can group the disparate objects together as a collection of address labels!
Sub Main()
'create a person object
Dim Bill As New Person
Bill.FirstName = "William"
Bill.LastName = "Jones"
Bill.Address = "123 Test Rd Testville 9123"
'create another person object
Dim Sally As New Person
Sally.FirstName = "Sally"
Sally.LastName = "Smith"
Sally.Address = "999 Sample Ave Testburg 9222"
'create an Organization object
Dim WidgetsInc As New Organization
WidgetsInc.Name = "Widgets Incorporated"
WidgetsInc.BuildingAddress = "9123 Avenue Rd Sampletown 9876"
WidgetsInc.MailingAddress = "P.O. Box 123 Sampletown 9876"
'Because all three objects implement the IAddressLabel interface, we can put them in the same array
Dim MailingList(2) As IAddressLabel
MailingList(0) = Bill
MailingList(1) = Sally
MailingList(2) = WidgetsInc
'loop through, displaying the address label for each object
Dim i As Integer
For i = 0 To 2
MsgBox(MailingList(i).Name & vbCrLf & MailingList(i).Address)
Next i
End Sub
Interfaces vs. Inheritance[edit]
Interfaces and Inheritance can both be used to solve the problem of treating dissimilar objects collectively. For example, if you have a Cat class and a Dog class, but have some routine that needs to process them together, you could either:
- Create an Animal base class, which contains procedures common to both Cats and Dogs, and have Cat and Dog inherit from Animal, or
- Create an IAnimal interface, and have both Cat and Dog implement the interface.
Which approach to use depends on several factors. In general:
- If you are extending an existing class, then use inheritance. For example, if you already have an Animal class, and then discover a need to distinguish between Cats and Dogs
- If you are simply wanting to treat different objects as the same, then use Interfaces. For example, you already have Cat and Dog classes, and then discover a need to manipulate them in a similar fashion
The introduction of Components[edit]
Inheritance vs Delegation[edit]
Dynamic Inheritance[edit]
Lifetime Management[edit]
Manual Lifetime Management[edit]
In the real world, factories are used to make stuff (e.g. automobiles). In OO programming, factories also make stuff; specifically, OO factories "make" (instantiate) objects.
At least in Java, a constructor is unable to return a reference to an existing object—it MUST return a brand-new object. This can cause two problems—too many object instances, and identical objects that are duplicates—not the exact same object.
Factories are generally implemented as a public static method inside a class that has only private constructors. In this way, only the factory can create instances "Guaranteeing[1]" that all instances of the object have been created by the factory.
The factory most often has an internal "Cache" of objects. Whenever a user asks the factory for a new object, the cache is consulted first and one of the cached objects are returned if it is identical—otherwise a new instance is created, added to the cache and returned.
Factories can also be used to inject user code into an "Unmodifiable" library. It is possible to save and restore a user object that implements some important functions of a library object. The library then uses that factory to get instances of the users object, and doesn't even know that the user has replaced a core component with completely new code.
As an example... Say the library uses Library objects all over the place. The library user can create a class (let's call it User) that extends Library. The user then calls LibraryFactory.set(User.class), and the factory stores it. Inside the library, whenever the library wishes to use a Library object, it calls the LibraryFactory.Factory() function to get a new instance. Without changing any code, the user can now completely change the way the library functions by overriding one or more methods in his User class.
This is used in various places inside the Java SDK to allow you to change how chunks of the SDK works without rewriting any of the code.
- ↑ In Java, just having private constructors does not truly guarantee that all your objects came from the factory. Serialization and reflection can still create new instances without going through the constructor.
Reference Counting[edit]
Garbage Collection[edit]
Garbage collection refers to freeing of heap-allocated memory. The heap memory must be freed eventually. Either the programmers code must explicitly free it, or some automatic system mechanism is required.
The most common mechanism is mark and sweep. This is where the system knows of certain top-level classes (Threads and windows mostly). It follows all the references from these "Known" classes to every class that can be reached and marks each class. When it's done, it "sweeps" (gets rid of) every unmarked class.
Garbage Collection is a huge enabler of Object Oriented development—it completely changes the way you design. With code-based memory management it is necessary to have some way to track an object. If it is created on the stack, it will be deleted when the method exits (so instances passed outside your method will become invalid). If it is created on the heap, some object must delete it manually—so if your method is going to create an object and pass it to two other objects that both retain the object, you have a problem. Who deletes the object? The original method can't because it will have exited before the two objects are finished with it, and the two objects shouldn't know anything about each other.
This type of problem is often solved with "Reference counting" which is another form of garbage collection, but a manual one. It also leads to fewer long-lived, free-roaming classes being created since they have to be tracked.
GC solves problem, that of ownership. If you are programming in a language with Garbage Collection, you may create classes on the fly, pass them off, retain a copy or forget about it... You really can't go wrong. When all instances have been "Forgotten", the class disappears.
The drawback is that GC tends to take a solid chunk of time. This is less true lately as at least Java has threaded GC and the ability to limit the amount of time GC will run. There are actually dozens of tuning and reporting options and the ability to select from multiple GC systems to fit your need.
GC Implementations run from trivial (instance counting) to amazingly complex. The current default Java VM uses a multi-tiered system with different mechanisms for new, middle-aged and old objects. For instance, since almost all new objects tend to die almost instantly, the first section (Eden) is divided in half. When one half becomes full, the currently referenced objects are copied to the other side. The system switches to using the "new" side and completely forgets about the old half. There is no explicit code invoked to delete objects that are already gone.
This means that GC can actually be more efficient than traditional allocation/free since there is no free operation for nearly all objects.
Garbage collection should be considered essential to OO Design.
Persistence is simply the act of having objects that "Stick around" between invocations of your program.
This can be trivial (Just serializing an object out when exiting, serializing it back in when loading) to a full OO-database implementation.
Hibernate is a good program that sits between your application and a database and ensures that your objects are properly persisted.
Serialization is converting an object to a stream of bytes that can then be saved to a file or transmitted over a network.
Generic Programming[edit]
Abstracting Classes[edit]
In this article along with the demo project I will discuss Interfaces versus Abstract classes. The concept of Abstract classes and Interfaces is a bit confusing for beginners of Object Oriented programming. Therefore, I am trying to discuss the theoretical aspects of both the concepts and compare their usage. And finally I will demonstrate how to use them with C#.


text:
In Stock
Philmac Gas, a new generation of mechanical compression fittings have been designed to offer many performance and installation benefits over traditional jointing methods.
Added to cart
this product has product has been added to your cart.
The requested quantity of this product cannot be added to your cart. Please try again
© 2019 Hamilton Gas Products Ltd | All Rights Reserved

subset: commoncrawl


text:
The Singapore Story: Memoirs of Lee Kuan Yew
Prentice-Hall, 1998 - Biography & Autobiography - 680 pages
Visionary? Authoritarian? Model for the West? Lee Kuan Yew, the long-time leader of Singapore, has been called all these things, and more. In these vivid memoirs, Lee takes a profoundly personal look back at the events that led to Singapore's independence and shaped its struggle for success. And, as always, he lets the chips fall where they may.In intimate detail, Lee recounts Singapore's unforgettable history. You'll be with Lee as he leads striking unionists against the colonial government; shares tea and rounds of golf with key players in Britain and Malaya; and drinks warm Anchor beer with leaders of the communist underground at secret midnight meetings. From British colonial rule through Japanese occupation in World War II, Communist insurrection, riots, independence -- and the struggles that followed -- few political memoirs anywhere have been this blunt, or this fascinating.Anyone interested in the political history of Singapore, Asia, and the modern world.
From inside the book
78 pages matching committee in this book
Page 676
Where's the rest of this book?
Results 1-3 of 78
What people are saying - Write a review
LibraryThing ReviewUser Review - HadriantheBlind - LibraryThing
This is the first of two volumes of memoirs by Lee Kuan Yew, prime minister of Singapore for 30 years, and its most influential leader. It is not without reason that he titles his memoir The Singapore ... Read full review
Review: The Singapore Story: Memoirs of Lee Kuan YewUser Review - Maxim - Goodreads
Overrated book, i think, but still very interesting, since the author was leader of Singapore for almost half a century. His comments on politics and economics are often very smart and iteresting to ... Read full review
Suddenly Independence
44 other sections not shown
Other editions - View all
Common terms and phrases
Albar Alliance asked Assembly August Barisan Borneo territories Britain British Cambridge campaign candidates chief minister Chin Chye China Chinese-educated Chinese-speaking Choo colonial committee communal communists constitution decided defence election English English-educated Federation fight Fong Swee Suan front Hokkien House independence Indian Indonesian Internal Security Council Ismail Japanese Keng Swee knew Kuala Lumpur Labour later leaders Lee Kuan Yew Lee Siew Choh Lennox-Boyd Lim Chin Siong Lim Yew Hock London Malay Malaya Malaysia Malaysian Malaysia Malaysian Solidarity Convention Mandarin Marshall meeting merger Nair non-communist Ong Eng Guan organisation Pang Boon parliament party police political prime minister pro-communists problems Raffles College Raja rally Razak referendum reported riots Road Sarawak secretary Selkirk September Siew Singapore government Singapore's Siong and Fong Socialist Special Branch speech Sukarno talks told took trade unions Tunku UMNO Utusan vote wanted workers
References to this book
The Political Economy of the Asian Financial Crisis
Stephan Haggard
Limited preview - 2000
All Book Search results »
Malaysian eclipse: economic crisis and recovery
Jomo Kwame Sundaram
Snippet view - 2001


text:
Opa! My Big Fat Greek Wedding Sequel in the Works
May 28, 2014 8:51 PM EDT
Break out the Windex! The producers behind My Big Fat Greek Wedding have announced that a sequel to the 2002 hit romantic comedy is in the works, according to The Hollywood Reporter. Nia Vardalos, who starred in and wrote the first film, has pen… Read more


text:
The area Catharine and Amy is private. You will need an access code to gain entry.Enter the access code in the box below:
If you don't have the access code, you can click here to request access.
© 2013 Fairy Photography by Helen Osler ABN: 66 293 514 945
| Powered by Fotomerchant.com


text:
Advanced Mask 9 (Single)
Advanced Mask 9 (Single)
All of Trestle's Masks can be bought individually, so whether you are expanding your set or specifically purchasing for a project Trestle can meet your mask requirements.
Our masks are all individually hand crafted by our mask makers and have a high demand; as a result the current expected time for delivery is 4 weeks from the date of confirmed payment.
Please note that due to the hand painted nature of these masks, the actual colours may vary slightly from the images shown.
Price shown excludes VAT, shipping fees apply


text:
Change Your Life...
Own your time, your business, and your financial future.
You can create the income that you need from home.
Stayin Home and Lovin It! is an award-winning team that has heart and passion for what we do. We are dedicated to helping people find the quality of life that they are looking for and need. We believe in working from the comfort of our homes and enjoying the important things in our lives.
Stayin Home and Lovin It Team | 866-424-3199 | email@example.com | members login
Powered by Home Office Pro


text:
Bombers bombard Eagles
There have been some close games between the Barnum Bombers and the East Central Eagles over the last three or four seasons, but Friday, October 12 was not one of those nights. The weather was beautiful for what has seem to become a rotating Homecoming tradition between the two foes, but the score was not even close as host Barnum bombarded the visiting East Central Eagles by a score of 58-16.
Barnum scored 22, 23 and 13 points in the first three quarters, respectively before pulling back the reigns, leading 58-0. The final quarter, played in running time, found the Eagles being able to get on the board twice with two touchdowns and two points after runs for the final tally of 58-16.
Barnum's Steve Swanson, who soon got a pass interception, line drove a kick off an up-back's shins, but Eagle Casey Sura was able to secure the loose ball and Swanson made the stop on the 28.
One run went well for the Eagles, but the next attempt against area sack leader defensive end John Zmyslony went nowhere. A third- and four-screen to the left middle seemed to be set up well enough but the pass floated, was tipped and Swanson had an interception at 10:48.
After one false start, Barnum settled down and Daniel Warpula got a big gain on his first touch. Eagle Logan Zimmermann made a good, soil tack on Zach Peterson. Bomber Colton Selix went right for a first down on a fine sweep around the right side. From the 10, Warpula was escorted into the end zone behind Peterson and Zmyslony for a TD. Selix made a fine little run for the two point for 8-0.
Eagle Isaiah Lobby made a decent effort on a two-hopper to the 33, but on the first play of their second possession the Eagles fumbled and Jaxon Lind recovered at 9:04 as the Eagles suffered their second turnover in as many possessions.
Bomber Zac Carlson launched a long pass down the right side, but it was overthrown with Eagle Nathaniel Ecklund on the coverage. An inside handoff to Peterson gained three. Warpula ran the left sweep for a first down. Barnum continued to methodically moved toward the goal line and eventually, from just a yard out, it was Peterson to score. The pass for points failed, but the Bombers had blasted off to 14-0 with 6:34 still remaining in the first frame.
Lobby made a good return to the 38 with Selix tackling. A left middle run by Eagle Steven Gunderson went nowhere and Eagle Kaleb McCulloch found only a couple with Selix up fast. A pass to the left was a good catch, but not enough for a first down and the Eagles elected to punt. Lobby, who has been said to have gotten college looks as a punter, booted an excellent one that rolled all the way to the nine at 5:03.
On the first play from scrimmage, Carlson made a beauty of a bomb that hit Bomber Brandon Newman on stride for a 91-yard shocker. A little lob to Selix showed Carlson's ability to throw the touch pass as well and Barnum had blown it open at 22-0 with 4:50 still remaining in the first quarter.
A short kick went out of bounds, so the Eagles got to start on their 35. Bomber Tory Slater held a middle to six, but the Eagles followed with their first first down at 4:11. That was followed by a little out pass to Eagle Tavion Buchanon for a three-yard loss. A pass to McCulloch was a loss of six with Slater smelling it out and snuffing it short. An inside hand and a Slater stop for a loss of five made it third and 19 and Barnum took over on downs as Tanner Fuglestad tackled. A punt was returned by Warpula from the 15 to the 32. A personal foul flew on the play so Barnum would have to operate from the 17. A pass to the right flat was incomplete, but a pass to Warpula on the right flat gained good ground to close the quarter with Barnum up 22-0.
The pass was not enough for a first so the Bombers elected to punt. Due to a high snap, it was a very good one and went out on the 42.
A counter was countered on a big hit by Zmyslony for a loss of three. Sura went right for two against Bomber Sam Anderson. The Eagles tried a trick play — a half back pass — but it hung like an apple on a tree and got the Eagles' third turnover at 10:40.
Peterson ran the middle for eight. Warpula ran for a first before McCulloch tackled. From 11 yards out it was Newman to score. Speedy Bomber Cody Shelgren took a pitch in for the two-point and the gap further widened to 30-0 at 9:20.
The Eagles would again be forced to punt and it was another boomer by Lobby between the 15 and 20 yard line.
On third-and-one, the Eagles jumped offside. Shelgren made a good play on a screen for second-and-six. A sweep right was third-and-five. Newman took the controls at quarterback and struck gold on very good faking on the left side. Newman launched a fine ball for Swanson to run under on stride and to gallop to the end zone. Newman found Bomber Seth Vogt virtually all alone on the two-point and Barnum had further raced to a 38-0 lead with 5:40 still remaining in the halftime.
Disaster struck the Eagles again. This time it was the fourth turnover in the form of a short, high kick that did roll out of bounds and was covered by the Bombers. In just over two and one-half minutes the Bombers would find the end zone again. After working the ball down the short field, it was Warpula on his fourth TD of the game. The Bombers, usually going for two-point pats, decided to practice the point after in a game situation and Vogt got it done for 45-0.
The Eagles got a first down at 1:50. McCulloch fought for a few yards and some extra yardage. A tipped pass, intended for McCulloch, was almost another interception. A pass along the left side also was nearly picked off with Vogt covering at 47.5 and Barnum took over on downs.
Peterson blasted the middle for a first to the 40. Peterson had another strong run for seven to the 47. With 12 ticks left, the Bombers elected not to run another play and to head to shelter with a 45-0 lead. The kick was a decent one and returned to the 31. On the very first play of the third quarter, it was Selix scorching off a 69-yard sprint. The kick failed, but it made little difference at 11:39 with Barnum going up 51-0.
After a three-and-out for East Central another good punt by Lobby looked like it would be a decent return for Warpula, but a flag flew and Barnum would start from its own five. That made little difference as the Bombers went on a sustained drive that included five first downs and culminated in Newman running seven yards to paydirt. Vogt hit his second kick of three kicks on the eve and Barnum shot forward to lead 58-0 at 4:02.
Bombers Richard Parzy, Anderson and Fuglestad made fine plays on the kick and the first play from scrimmage, including Fuglestad's coverage on an incomplete pass. The Eagles, running first-stringers such as McCulloch, were able to string together three first downs to head into the fourth frame trailing 58-0, but they would soon be able to score.
From the 15, a pass was overthrown. A Statue of Liberty play returned to the field from the playbook archives. On the next lay, Zimmermann, an East Central eleventh grade fullback, hit the middle for a score. McCulloch squeezed a good pass in the left corner from Lobby for 58-8 at 9:27.
Barnum's substitute quarterback got sacked once as running time made the rest of the game speed right along. The Eagles were able to put together five first downs and work the ball downfield against each squad's reserves, but it was East Central's Buchanon, a junior running back, who was able to score from four yards out. It was Seth Allen, also a junior, but a tight end, that caught a Lobby pass for the game's final tally of 58-16.
The Bombers' six senior starters, Selix, Warpula, Swanson, Zmyslony, Anderson and Vogt, who had all played key roles in the game as Warpula caught a pass and ran for two touchdowns; Selix had one touchdown and two extra points; Swanson ran for a TD and had an interception; Zmyslony, the area sack leader, seemed was all over Lobby to hurry passes on several occasions; Anderson played a fine game defensively. Others of note were Newman, Mitchell Weller, Fuglestad, Lind, Brady Youngberg and Slater.
East Central's Gunderson had a decent game. McCulloch, a senior running back, stood out. Junior Zimmermann had a TD and classmate Buchanon had a TD. McCulloch had a two-point conversion from Lobby and Lobby, a junior, tossed a two-point to junior Allen as well. Four turnovers had really hurt the Eagles in terms of time of possession.
Selix led the way for Barnum as he rushed only five times but gained 116 yards and scored a TD and a two-point conversion as part of an offense that racked up a total of 477 yards. Warpula put the most points on the board with three TDs. Quarterback Carlson was 3-for-6 for 103 yards and a TD toss to Warpula. Newman threw a TD pass to Swanson and Newman ran for a score and passed a two-point conversion to Vogt.
It was the third loss for 2-5 and 2-4 East Central on the season, while the Bombers, under coaches Brian Robertson, Rich Newman and others, continue to play intense and smart football and have only two losses — one of those a very close game with AAA Cloquet and the other to number-two ranked AA Moose Lake-Willow River. Neither of those teams were blowouts as could have been expected.
Barnum, improving to 5-2 and 5-0 in the conference, will travel for a Wednesday, October 17 meeting with the Deer River Warriors who were 2-4 and 2-2 prior to their Friday night fight at 0-6 Oglivie. East Central travels south on October 17 to play a team with a similar record — the Rush City Tigers.


text:
Are you as sick as I am of seeing "It's the End of the World as We Know It" quoted on Facebook? Here are some newer tunes inspired by the end of the Mayan Calendar.
Dent May – "2099"
Just released this week, Mississippi indie pop great Dent May has released a dance-pop track inspired by the end of the world — which will take place in 87 years, apparently (actually that seems sort of plausible). "Are you afraid of what tomorrow's gonna bring?" he asks before declaring "If we all die by a nuclear war/We're gonna go out on the dancing floor." Dent May's Do Things was released this year on Animal Collective's Paw Tracks label, it's great and super underrated, check it out!
Hunter Hunted – "End of the World"
L.A. band Hunter Hunted have released this video to their KCRW-touted track "End of the World." Despite its Road Warrior look, they make the apocalypse seem like a lot of fun. They're at the Troubador Feb. 12.


text:
As a person, I am definitely oriented in specific ways. I'm not talking about political or religious affiliations, I'm talking about those deep-down personal orientations that define who you are.
Let's just say there's never been a question that I might be ambidextrous.
When my brother, who is left handed, was in school, it was during a time when they used to try to teach left-handed children to be right handed. So even today there are certain things he does right handed and other things, like write and eat, that he does naturally with his left hand.
Not me. About the only thing I do with my left hand is scratch my right elbow.
So you can imagine my consternation when I consider my upcoming rotator cuff surgery which will require my right arm to be in a sling for three weeks.
In preparation, I have decided to start doing things with my left hand.
I don't write many checks — I pay most of my bills on line, so that's not a big issue.
However, this morning I tried brushing my teeth with my left hand. Those of you who think it's humorous to have toothpaste from your earlobe to your elbow are more than welcome to try this at home. Please send pictures.
I hope your day starts and ends with a smile. Thanks for checking in.


text:
Cyber security rock star
"Rock star" Rebekah Mohr shares her story as a pioneer in Shell's IT Security.
Meet some of the people behind our projects and business, from wells engineers to IT specialists and the many roles in between, discover what working for Shell is really like.
"Rock star" Rebekah Mohr shares her story as a pioneer in Shell's IT Security.
Hear from Shell employees about how they work together to reach their potential.
Sometimes the hardest disabilities to live with are the ones you can't see. Read this Shell colleague's story.
Meet Joe, Onshore Asset Manager
Meet Marie-Guylaine, Reservoir Engineer
Meet Cindy, Pipeline Maintenance Engineer
Meet Sid, Atmospheric Fines Drying Supervisor (Mine Tailings)
Meet Teo, Well Intervention Engineer
Join a collaborative, pioneering team that is committed to helping develop the energy resources needed to power progress.
Find out what life is like on the Shell Graduate Programme from current employees.


text:
To all:
It has become apparent that we have an increase in spammers targeting members behind the scenes via PM's (Private Messaging). Since we can't read your private mail, and the spammers steer clear of us; we have no way of knowing who is doing it to whom. Please feel free to forward any of these messages to me directly. To be fair, I need to see the message to be sure it's spam to act on it, and not just two people bickering.
I frequent the board numerous times a day when not at work or on vacation, so I can usually act quickly to curb them.
You could also likely direct them to Todd (user name- ghosttowns.com) if I haven't responded within a day or two of your message.
If you are unsure of how to forward the messages, I've created a post with step by step instructions.
As far as any spam that is posted on the public forums, you may message me on them as well, though I usually get those taken care of the same day; so there's no big concern there.
Thanks for your help.
"I have a .44 and a shovel, I'm sure no one's gonna miss you" - Virginia City, NV
There are a few ways to send a PM or forward a PM message to another member. *You must be registered and signed in (no guests) to contact via PM*
To send a message:
Simply click on the name of the member which will bring up their public file. On the right side, under Contact Info there will normally two links. One is for Private messaging, the other is to contact by email. It should look like so:
Send a message via email to GaryB
Private Message:
Send a private message to GaryB
Simply click the private message link and the PM screen will appear. You type in your message just as you would a post in the public forum. Then click Submit Message to send it to the person you selected. You can also add user names by typing them in within the Recipient Username field to send them to multiple members.
To forward a message:
You can either copy and paste the original message in the message field while using the above mentioned way. Or, by clicking the Forward link in the lower right hand corner of the original message to you. That will in turn open the PM window and you will have to manually type in your recipients names.
Lastly, when signed in, you will see a link labeled Private Messages in the upper right hand corner of any screen under your user name and log in status. By clicking that link, you open your inbox folder screen and PM menu. On the left, there will be a link under Private Messages labeled Send New Message. By clicking that link, you will open the Send new PM listed above, in which following any of the aforementioned directions will get you through.
"I have a .44 and a shovel, I'm sure no one's gonna miss you" - Virginia City, NV
There are currently 1 users browsing this thread. (0 members and 1 guests)


text:
- Home
- News
- Sports
- Opinion
- Obituaries
- Features
- Special Sections
- Classifieds
- Public Notices
If you have the misfortune of experiencing a life-threatening ordeal like a heart attack or stroke, you do have the good fortune of having a quality hospital nearby to help save your life.
Doug Arbour, chief executive officer of Springs Memorial Hospital in Lancaster, is living proof.
On a night in mid-May, Arbour awoke with what he thought was indigestion.
It wasn't. It was worse, much worse. In this case a massive heart attack.
If you currently subscribe or have subscribed in the past to the The Lancaster News, then simply find your account number on your mailing label and enter it below.
Click the question mark below to see where your account ID appears on your mailing label.
|ZIP Code:


text:
Fish and chips at Lake Ferry
For the best fish and chips head out to Lake Ferry on Wairarapa's beautiful southern coast.
1 / 3
Lake Ferry is a fantastic spot, just a tiny town on the edge of Lake Onoke and Cook Strait. Clear days serve up fantastic views of the Kaikouras in the South Island and the view across Onoke to Ocean Beach is the perfect backdrop to a days fishing.
Speaking of fishing, the lake mouth, where it meets the sea provides a perfect white-baiting spot and the kahawai love to run in the just off the shore where the waves break.
Although you can't swim here its a great place to lay on the pebbles and read a good book, throw in a line or just walk along breathing in that fresh sea air.
There's a great pub here - The Lake Ferry Hotel - and it serves the absolute best fish and chips around. A quiet garden bar overlooking the lake provides some stunning views, a great spot to enjoy a cold beverage from the bar. Order a meal (emphasis on the fish and chips) and relax in one of the most beauitful and isolated spots Wairarapa has to offer.
Lake Ferry is only half an hour's drive from Martinborough and is often cycled. About 40mins drive around the coast is Ngawi and Cape Palliser, home to the ninth flashiest lighthouse in the world and a fantastic fur seal colony.
For more information about the Wairarapa visit www.wairarapanz.com


text:
Forum for discussing Fixed wing FPV Aircraft
Well, I haven't tried it yet, but here it is.
I installed a bullet shaped micro cam with a 90 dg FOV,
a 5.8GHZ VXMTR, and a antenna, just the...
There are currently 1 users browsing this forum. (0 members & 1 guests)
Use this control to limit the display of threads to those newer than the specified time frame.
Allows you to choose the data by which the thread list will be sorted.
Order threads in...
Note: when sorting by date, 'descending order' will show the newest results first.
Forum Rules


text:
We recognise how important your professional status is to you, but we also understand that sometimes your personal situation should be taken into account when your professional fee is due.
To apply for your professional concession, log on to our concessions portal and follow the simple steps below.
This relates to the personal concessions you are applying for. Please complete only one section from Step 1.
We send out renewal invitations in early November. If you wish to apply for a concession before 1 November the reduced rate will appear on your renewal. If you apply for the concession after this date an updated renewal invitation can be downloaded by logging into the payment portal.
If you are also a professional of one of the other international organisations, you may be eligible for an additional concession. If eligible, please select and complete only one section. If you are not a professional of another organisation, please skip this section and advance to step 3.
Confirm your status by agreeing to the declaration and the terms and conditions.
Alternatively, you can apply using our concessions form.
If you fall into one of the groups listed below, you could be entitled to a concession:


text:
WTA Tour, Cincinnati live streaming in WTA Tour.
Watch WTA Tour, Cincinnati Rojadirecta tennis streams free.
All Rojadirecta streams and Redstream streams are added hours before the start WTA Tour, Cincinnati . Refresh the page to check if we have added more streams.
Share to Facebook, Twitter or Google+ with the buttons below to unlock all the WTA Tour, Cincinnati Rojadirecta streams.
WTA Tour, Cincinnati live tennis streaming. Free live stream WTA Tour, Cincinnati in Worldwide, WTA Tour.
Redstream and Rojadirecta are the best place to watch free live WTA Tour, Cincinnati streaming.
We crawl the web to find the best tennis live streams and we also list streams submitted by webmasters. Users can find many streams to watch WTA Tour, Cincinnati . So we are sure that redstreamsport.com offers you the best live tennis streaming.
We are excited to let you know that tennis streams are now live. Watch Rojadirecta tennis live streams here on Redstream! We crawl the web to find the best live stream links. Redstream and Rojadirecta Live streams. All tennis and the best live streams in the best one, REDSTREAM.
The tennis events are broadcasted live in all countries. The problem is that live events are not broadcasted on TV for free. You need to pay premium cable tv channels to watch tennis events on TV. You can also watch tennis online on websites that are licensed to stream tennis online. However, they usually are subscription services and have country restrictions where the site is based. If you really want to watch TV tennis matches online from your computer or from any devices, then you are in the correct place, Redstream free live sports streaming will satisfy your tennis needs.
Copyright © RedStream · & · Rojadirecta · · tennis Live Streams · · Redstream. All Rights Reserved. · · Free live sport streaming · Coded with ⚡Sports stream · football Live stream · NFL Live stream · NBA Live stream · NHL Live stream · MLB Live stream · ATP Live stream · Rugby Live stream · MMA Live stream ·


text:
November 8, 2018 – November 9, 2018
Suite presents POP Thursdays! Great drink and bottle specials!
18 to party, 21and up to pop!
Doors open at 10 PM | Email email@example.com for table reservations
An unbeatable location – wether you are visiting or need a staycation, Aloft is just a short elevator ride up from the EPICENTRE.Make a Reservation


text:
Before and After: Campaign Desk (finally!)/
This process ended up taking a bit longer than I expected, but I couldn't be happier with the results. One benefit to the extra time is that the desk has been allowed to fully cure, so I know it's now ready for the furious scribbling of all my ideas and late night typing sessions. Here's where it started.
I wrote more about it here.
The transformation for this piece required some cleaning, wood putty, and a few layers of primer, paint, and urethane. This, of course, is in addition to the Brasso for the hardware.
It wasn't as bright as I would've liked this afternoon, so I had to use the flash on my camera which cast some funky shadows. Don't worry--the walls in my office are not baby blue. In reality, they're more of a blueish-grey, and it makes for a great place to read and study. I have another project I've been working on for above the desk, so hopefully I'll be able to get it done and blog about it next week. My office makeover is far from finished, but I'm on my way!


text:
Friday, March 30, 2012
Fitness related post for your Friday
Posted by californiadreamin at Friday, March 30, 2012 6 comments Links to this post
Labels: diet, doctor appointments, fitness
Thursday, March 22, 2012
Did You Think I Wouldn't Talk About It?
Posted by californiadreamin at Thursday, March 22, 2012 4 comments Links to this post
Sunday, March 18, 2012
Because Im a Good Momma All Year...
The Jessica Simpson Alan Cowgirl boot
I REALLY think these would be a fabulous gift for my Mothers Day present :) If anyone knows my hubs, please send him a message ASAP. Lord knows I've randomly posted hints everywhere he might see. Their so hard to find, because they are an amazing boot!
Posted by californiadreamin at Sunday, March 18, 2012 3 comments Links to this post
Tuesday, March 13, 2012
So Whats Next?
Okay so before my feet even reached the half marathons starting line, I've been thinking about my next workout routine. For a few months I've been lifting here and there, but mainly focusing on my endurance and getting my miles in. I mean, lets be honest: when you run 10 miles, the last thing you wanna do is lift heavy weights, am I right or am I right?
So after talking to my beautiful long lost twin, Becky, I decided to copy her in true twin fashion and do a workout routine she found in her Fitness RX for Her magazine.
How is everyones workouts going, have you kicked it in gear yet since we're only a few short months away from the heat (aka bikini season)? This next week, Winter has FINALLY decided to stick around my part of the world, so it's hard to imagine being in a bathing suit right now, but I know the day is coming. What else is coming? Shorts, and skirts and dresses. Im itching to go shopping and get some new clothes, but Im gonna wait until it gets a little closer to the heat. Pinterest is not helping with this itch
Posted by californiadreamin at Tuesday, March 13, 2012 6 comments Links to this post
Monday, March 12, 2012
Posted by californiadreamin at Monday, March 12, 2012 15 comments Links to this post
Tuesday, March 6, 2012
Sorry, but Im not sorry
Posted by californiadreamin at Tuesday, March 06, 2012 3 comments Links to this post
Labels: reality tv
Monday, March 5, 2012
Q&A Link Up Vlog
Hey ladies - Im linking up with Shasta Anne and PIPM.
*Note, I am going to stop saying the word "Um". I say it sooooo many times in this video and didn't even realize. Sorry!! Oh and I promise I don't sound like a Valley Girl, which Im realizing this video makes me sound like 100%*
Posted by californiadreamin at Monday, March 05, 2012 2 comments Links to this post
Friday, March 2, 2012
Ice Bath, Party of One
Posted by californiadreamin at Friday, March 02, 2012 7 comments Links to this post


text:
"If you look at these kinds of data sets across almost all diseases, the incidence seems to increase over time. It's probably an issue of chronic diseases being picked up over time."
KYOTO, JAPAN — The annual incidence of both bullous pemphigoid and pemphigus vulgaris has climbed steadily over the past decade in the United Kingdom for reasons unknown, according to a study of more than 1,000 patients.
The mortality associated with these autoimmune diseases may have beenunderestimated in the past, based upon the results of Dr. Sinead Langan's large, population-based study presented at an international investigative dermatology meeting."People with bullous pemphigoid are twice as likely to die and those with pemphigus vulgaris are three times as likely to die as [are] matched controls," said Dr. Langan of the University of Nottingham (England).
Her study of The Health Improvement Network (THIN)–a large, population-based database of computerized primary care medical records–identified 868 patients diagnosed with bullous pemphigoid (BP) and 139 diagnosed with pemphigus vulgaris (PV) during 1996-2006. Each patient was matched by age and gender with four controls from the same general practice.She undertook the study because, despite the substantial morbidity and mortality associated with these autoimmune diseases, little is known about their epidemiology. For example, there are only two published studies addressing PV mortality; one, from the Middle East, reported a 1-year mortality of 5%, while a 1975 U.S. study found a 50% 1-year mortality, she said. The reported BP mortality has cut a similarly wide swath.
The incidence of BP in the new U.K. study climbed with advancing age, peaking in a group aged 80-84 years. The median age at presentation was 80 years, and 62% of affected patients were women.
PV incidence showed a bimodal distribution, with a peak at ages 45-49 years and a second, larger one at 80-84 years. Median age at presentation was 71 years, and two-thirds of patients were women.
Dr. Joel M. Gelfand commented that he doesn't believe the rising annual incidence rates of BP and PV observed in the U.K. study are real, and suspects that more sophisticated statistical analyses would show as much.
"If you look at these kinds of data sets across almost all diseases, the incidence seems to increase over time. It's probably an issue of chronic diseases being picked up over time," according to Dr. Gelfand, who has led several landmark studies carefully documenting increased cardiovascular and cerebrovascular risks in psoriasis patients using the U.K. General Practice Research Database. He is medical director of the clinical studies unit in the department of dermatology at the University of Pennsylvania, Philadelphia.
Dr. John R. Stanley, professor and chair of dermatology at the University of Pennsylvania, said Dr. Langan's study left him uncertain about how to apply the findings in clinical practice. "We don't know [from the U.K. study] whether to treat more aggressively or less," Dr. Stanley observed at a meeting of the European Society for Dermatological Research, the Japanese Society for Investigative Dermatology, and the Society for Investigative Dermatology.
Dr. Langan agreed these data are not illuminating on that score. However, the database also contains information on medications, and she is planning a study she hopes will help guide treatment decisions.
Related Articles
Peptimmune begins Phase I trial for pemphigus vulgaris.
Peptimmune has announced that it has initiated a Phase I clinical trial to test the safety of PI-0824 in patients with pemphigus vulgaris (PV). The study is being undertaken at four sites. PI-0824 is a synthetic injectible peptide being developed ……
BANFF, ALTA. — Pemphigus vulgaris is rare in childhood, Dr. Jeffrey Callen said in a poster session at the annual meeting of the Society for Pediatric Dermatology. The disease usually occurs between 40 and 60 years of age. Dermatologically, oral ……
Cosmeceutical critique: niacinamide.
Unlike many cosmeceutical ingredients, there is a great deal of research that supports the use of topical niacinamide. Studies have shown its usefulness in increasing synthesis of collagen and lipids, inhibiting the transfer of melanosomes, and decreasing inflammation. As a ……
Randomized controlled study to evaluate CellCept in the treatment of pemphigus vulgaris.
Aspreva Pharmaceuticals Corporation is currently working to provide more evidence-based medicines for less common diseases. The company recently announced the initiation of a Phase III trial to evaluate the safety and efficacy of CellCept (mycophenolate mofetil) with corticosteroids to achieve ……
HLA typing identifies pemphigus risk factors.
ZURICH — The human leukocyte antigen class II DRB1*0402 allele proved to be the strongest genetic risk factor for pemphigus vulgaris in both whites and IndoAsians in the largest HLA typing study to date conducted in a European population, Dr….
Pemphigus vulgaris acantholysis ameliorated by cholinergic agonists.
Know Cutaneous Signs of Internal Malignancies.
SEA ISLAND, GA. — Manyofthe7%15% of patients with internal malignancy who develop cutaneous paraneoplasias will seek care for these dermatologic conditions first, so family physicians should be alert to their significance for early diagnosis, Dr. Toni L. McCullough said at ……
Autoantibodies for bullous pemphigoid found in unaffected.
KYOTO, JAPAN — More than 7% of individuals without any form of autoimmune disease possess elevated serum bullous pemphigoid 180 and/or BP230 autoantibodies on the commercially available enzyme-linked immunosorbent assay, according to testing of stored serum from 370 people. These ……
Youth, mucosal disease predict pemphigus relapse.
SORRENTO, ITALY — Patients with pemphigus who are younger than 40 years at the time of diagnosis and whose first remission is brief are likely to have a more severe course of disease and multiple relapses, Dr. David Mimouni said ……
IVIg for refractory pemphigus. (Steroid-Resistant Disease).
NEW ORLEANS — Intravenous immunoglobulin helped to get pemphigus under control in patients with disease refractory to systemic steroids. In two studies, 15 patients with moderate to severe pemphigus vulgaris and 7 patients with severe pemphigus foliaceus experienced significant improvement ……
Erythema gyratum repens in a case of resolving psoriasis.
Abstract Erythema gyratum repens (EGR) is a rare skin syndrome often associated with internal malignancies, and thus considered paraneoplastic (1). There are cases of erythema gyratum repens in the literature associated with other dermatoses without underlying malignancies'. We present a ……
A practical technique for differentiation of sub-epidermal bullous diseases: localization of in vivo-bound IGG by laser scanning confocal microscopy.
The purpose of this study was to develop a practical technique to distinguish autoimmune sub-epidermal bullous diseases.The authors present a prospective study from an academic referral center. The patient population consisted of forty-two patients fulfilling clinical, immunological, and/or immunoelectron microscopic ……


text:
We have implemented a new system to motivate you even more with your language learning: busuu-berries, Stars and Badges!
We will now reward your language learning efforts and your help to others with some sweet berries!
|You will get busuu-berries each time you do a learning unit or correct a writing exercise on www.busuu.com.
|Depending on your number of busuu-berries, you will receive Stars – or even Diamonds!
|But you can also send your busuu-berries to a friend in order to motivate him. So you shouldn't keep all this delicious berries for yourself, share them as well with your friends!
And that´s not all – you can also receive special busuu-badges to reward specific activitiessuch as correcting a lot of posts, having finished a course or having a lot of friends. (Take a look at the detail of each badge)
An extra 10 busuu-berries have been granted to each of our users as a gift to celebrate this new system!
You can easily find out how many busuu-berries, Stars and badges you already have based on your past performance by connecting on www.busuu.com!
We hope you all like our new reward system andwould be pleased to receive your feedback.
Enjoy language learning with busuu.com!


text:
This site will look much better in a browser that supports web standards, but it is accessible to any browser or Internet device.
This web site is partly funded by Canadian Culture Online (CCO), a program of the Department of Canadian Heritage. Its objectives include that of connecting Canadians with the country's diverse heritage through an integrated approach to the digitization and accessibility of key collections from Canada's federal, cultural heritage institutions.
We also invite you to visit the following federal government web sites, partially funded by CCO:


text:
Crystal-ball gazing regarding a potential Brexit is notoriously tricky business and must be caveated with an appropriately large health warning.
How a Brexit might look in reality is currently unclear, as the terms of such a departure are up for negotiation. If the UK opted to remain part of the single market, it is likely that harmonising legislation would have to be adopted as a precondition. A Brexit is not, by requirement, the end of EU legislative influence.
That being said, however, some tentative predictions can be made.
Significant aspects of UK pensions law originate in EU law. The EU has driven pensions legislation notably in areas such as scheme specific funding, transfers of undertakings and anti-discrimination. Over time, these provisions have been implemented into, and consolidated within, national law – the Pensions Act 2004, the TUPE Regulations 2006 and the Equality Act 2010 respectively.
Any exit from the EU would not affect national legislation, which would remain intact. Repeal would be time-consuming, and it seems unlikely that large-scale repeal or reform of pensions law would be top of any post-Brexit to-do list. Many of the current requirements are designed to protect members, meaning repeal could be politically unpopular.
Subject to exit terms, a Brexit might, however, impact on EU compliance issues currently filed in the "too difficult" category: future EU laws may not be adopted, and uncertainty in relation to EU requirements where the method of implementation is unclear, such as guaranteed minimum pension equalisation, could be removed.
Note also that many pension schemes have incorporated the current legislative requirements into their scheme rules. Post-Brexit, scheme trustees would still be bound by these and, without a pressing reason to undergo the time-consuming and costly process of amendment, change is likely to be gradual and, in some cases, may be impossible, as overriding national pensions legislation would continue to bind trustees and employers, and would not be directly affected by a Brexit. For example, UK legislative protections would continue to safeguard members' accrued benefits from detrimental changes.
Changes might be seen in the UK courts', Pensions Ombudsman's and Pensions Regulator's interpretation of the legislation, none of whom would continue to be bound to consider the ECJ's and EIOPA's interpretation and guidance. However, such differentiation would likely be incremental, at least to begin with.
A potential Brexit, therefore, is likely to usher in a gradual shift rather than a radical about-turn in pensions law. This being the case, trustees, employers and pensions professionals should be well-equipped to respond, much as they have been to the changes in pensions law over the past few decades.