exception « WordPress.com Tag Feed

Why Rape Isn't a Good Reason for Abortion

Mike — Sat, 06 Sep 2008 15:50:20 +0000

One of the stories coming out of the convention is that the GOP adopted a stance on abortion that was tougher than what John McCain has taken. Namely, the GOP platform does not believe that rape or incest is a valid reason (aka excuse) for abortion. Unfortunately, many pro-life advocates (and politicians) believe that any law limiting abortion should contain exceptions for rape or incest. Abort73.com presents the case against using rape as an excuse for abortion:

Let's say the woman does carry her child to term and decides to raise her daughter herself. After five years, however, she decides that the little girl's presence in her life is too much of a burden. Should that mother have the right to kill her five year-old daughter who was born to her as a result of sexual assault?

Obviously not. No matter what the circumstances are regarding the little girl's conception, she is a human being with a right to life that cannot be taken away from her. But what about before she is born, does this change anything? No, it doesn't. Abortion is an act of violence that kills a living human being. The circumstances surrounding the conception do not change this simple reality. Rape and abortion share this in common. They are both acts of violent assault against an innocent victim. Aborting a child conceived through rape simply extends this pattern of violence and victimhood. It does not "unrape" the woman, but it will almost certainly increase her regret and misery. Whereas rape is an act of violence for which she bears no responsibility, abortion is an act of violence for which she would be morally culpable. Consider the following email, received by Abort73 on January 19, 2007:

I just wanted to say that I am so pleased to read your stance on abortion in the case of rape. My mother was a 14-year-old girl who was raped, and she tried to have an abortion. The only reason I am alive today is because the doctor miscalculated her due date and thought she was too far in the pregnancy to have the abortion, when in reality he was a month off (this actually happened twice). It pains me every time I hear even die hard pro-lifers say "except in the case of rape". I know it is traumatizing for a girl or woman that is raped to have to carry a child, but it is no more traumatizing than someone who gets shot during a violent attack and has to deal with those wounds. Counseling and therapy can help heal the trauma, but the trauma will be there whether she has the abortion or not, and the abortion could even make it worse. It has caused me so much anxiety over the years to think that many pro-lifers would have approved of my mother's abortion. By the way, she gave me up for adoption, and my adoptive parents were never able to have children. Thank you so much for this wonderful view against abortion even in the case of rape.

Fazendo unit test usando Doctrine no symfony 1.1

patrickespake — Mon, 01 Sep 2008 19:26:12 +0000

Algumas vezes é necessário fazer testes de unidades para verificar o funcionamento da camada de model no symfony.

Você pode criar um arquivo no diretório test/unit do seu projeto, por exemplo: meutesteTest.php.

Nesse arquivo você deve inicializar as configurações do symfony e banco de dados, da seguinte forma:

[sourcecode language="php"]

require_once(dirname(__FILE__).'/../../../config/ProjectConfiguration.class.php');
$configuration = new ProjectConfiguration();
include($configuration->getSymfonyLibDir().'/vendor/lime/lime.php');
$appcfg = $configuration->getApplicationConfiguration('cron', 'dev', true);
$databaseManager = new sfDatabaseManager($appcfg);

$t = new lime_test(1, new lime_output_color());

try {

$produtos = Doctrine::getTable('produtos')->find(1);

$t->pass("Consulta realizada com sucesso.");

} catch (Exception $e) {

$t->fail("Consulta falhou.");

}
[/sourcecode]

Para rodar o teste de unidade execute:

[sourcecode language="bash"]
symfony test:unit meuteste
[/sourcecode]

O symfony irá executar o teste de unidade e mostrar se foi realizado com sucesso ou sem sucesso.

city v country in the friendliness stakes

cityterer — Fri, 29 Aug 2008 08:28:08 +0000

i really felt for her. she’s not very assertive, as she admitted. she comes from the country and at one stage, she said that people from the country are much friendlier than in the city. i took exception to that. i said that i didn’t ...
passthepopcorn.wordpress.com

Silverlight custom fonts - How to and issues.

agkdesign — Wed, 20 Aug 2008 04:38:23 +0000

I have been working on a few projects lately, one of them requiring a custom font to be embedded into the Silverlight application. It's really simple to do.

Open your project in Visual Studio. First thing is to add the new font to your project.

Right click your project in the tree > Add > New Item and select the font from the browser. (Note: You can't add a font while it sits within your windows folder, copy the font out of the folder to your desktop or something to add it.)

once the font is in the tree, right click it and go to properties.

Build action = Content
Copy to Output Directory = Copy if newer

So they should now include your font into the project when you build it.

Next up is to put it into the XAML.

and TADAHHH! Custom font in your Silverlight app.

So that was pretty simple hey, but there is a problem with it.

If you use Expression Blend to make your Silverlight apps you will run into some issues with using custom fonts. Its a bug that seems to cause a lot of trouble when using custom fonts in your application.

If you try to edit your project in Blend you will probably get this error

You can simply get rid of this error by building the project, but you will notice that when it was loaded in blend, it was loaded as a WPF application and not Silverlight, so you don't have the state manager and your project tree is empty. So you can edit your current application, but you cannot add new items to it.

The only way around this is to remove the references to the new font in your application until you have finished your application, then add the font references (or you can just comment them out).

So now you can have all your completely outlandish fonts in your applications and its still real text, not pictures!!! Totally sweet.

C'mon lets do that generic, it would be pretty [cuil]

fbthomas — Tue, 05 Aug 2008 18:51:20 +0000

passing an exception and not knowing how many are still out there until your process is going through - this is normal Developing in these generic projects.

Today i clicked on the little green arrow .... -> and BOOOOOOOOOOOOOOOOOOOOOOOM there was a result. Unbelievable. There wasn't anything before more beautiful than this tiny little print Message.

Encore.

chloedargelos — Mon, 04 Aug 2008 21:24:16 +0000

Je ne promets rien, je ne fais que tenter. Essayer encore de m'accorder à cet espace qui semble trop grand pour moi, immensément vide et qu'il faudrait emplir jour après jour de l'écume de mes journées.
Ou peut-être me trompé-je.
J'ai laissé en friches l'autre espace qui ne me convenait plus. J'ai voulu marquer une étape, un changement dans ma vie personnelle et mon écriture, puisqu'elles sont intrinsèquement liées. Comme lorsque je change de carnet et mets alors fin à un cycle, à une période, un amour, une tranche de vie et d'écriture, à des tâtonnements.
J'ai très envie d'aborder ce renouveau avec plus de liberté, plus d'insouciance aussi, me risquer à la fiction, admettre que tout est inventé trafiqué modelé par l'écriture et la conscience écrivante.

Ces derniers mois ont été décisifs - du moins je le crois. J'ai perdu un amour très fort, et avec lui toutes mes armes pour me battre. Je n'ai plus la force de lutter contre l'autre, je ne peux plus m'exténuer, me faire croire que tout ira bien du moment que Le garçon est près de moi. ça ne marche pas. Jusqu'ici je ne voyais dans ma douleur que celle d'avoir été flouée par un amant - maintenant je comprends que je lui volais aussi sa liberté, que je refusais sa douleur sous prétexte qu'il devait être assez fort pour supporter.

En ce moment je suis un peu perdue, je réfléchis, j'hésite. Je voudrais faire les bons choix, ne pas écorcher des personnes auxquelles je tiens. Je n'aime pas bousculer les autres pour me faire une place, je déteste déranger. Alors je m'adapte constamment. Je suis une sorte de caméléon depuis toujours, et j'ai fini par apprécier cette aptitude en prenant conscience des facilités qu'elle pouvait m'apporter. Partout, je semble capable de déceler ce qui pourra être le germe d'un rapprochement, avec presque n'importe qui. Je suis passe-partout. Seules certaines de mes amies connaissent mes emportements et mes faiblesses, mes souffrances et mes contradictions. Mes rêves.

Cette capacité d'adaptation m'a poussée à la méfiance, à l'observation. Ma mère me racontait souvent cette anecdote : lorsque j'étais en Maternelle à l'école publique de Saint-Germain-Des-Prés, la maitresse avait remarqué que j'avais passé un mois à regarder et observer les autres enfants avant de me rapprocher de certains d'entre eux.
Déjà une certaine exigence.
J'ai le sentiment d'avoir gardé cette exigence, l'impression d'être un peu en-dehors, de ne pas faire partie du monde, et c'est ce qui m'a poussée à écrire. D'abord écraser ma souffrance, le dégoût face à mon corps ; puis les passions naissantes, le Bleu.

Voilà, j'écris pour tout ça. Le Bleu, les corps, les pleurs étouffés, l'enfance.

Société Générale-Les prêts à la consommation

Martin — Mon, 04 Aug 2008 01:22:57 +0000

Les prêts à la consommation vous permettent de financer tous vos projets (à l'exception des opérations de nature immobilière) tels que l'acquisition d'un véhicule, l'achat d'un ordinateur, le financement d'un voyage ou les études de vos enfants. Vous n'avez aucun justificatif à fournir sur la nature de vos dépenses.Plus+

Cînd stăpînul nu-i acasă...

rinatbictaghirov — Fri, 01 Aug 2008 07:15:47 +0000

Cînd stăpînul nu-i acasă şoarecii joacă pe masă...

Au trecut 2 săptămîni de cînd Fabio ne-a părăsit...

Aceasta se simte foarte bine...

[caption id="attachment_6" align="aligncenter" width="300" caption="CruiseControl madness"][/caption]

Rinat are varianta lui:

[caption id="attachment_36" align="aligncenter" width="300" caption="Waitnig for Fabio"][/caption]

pick up your microphone...

butletsbeserious — Mon, 28 Jul 2008 10:32:15 +0000

Always on the look out for a new paradigm to explain the current situation, the rhythms, repetitions and distortions in the political world. The state of emergency seemed as good as any. And, plus, many respected academics seem to agree! So we can rest easy with that decision, for now.

In the US, at least, we seem to live in a world filled with extraordinary threats. By contrast, extraordinary opportunities are running short, as that would imply that the ordinary opportunities we, as Americans, enjoy (or used to), are insufficient. But once we eliminate these threatening distractions, we can get back to all the things that traditional American values have to offer. The Green World of the Clinton years, where the only distraction from making money off of Oracle and Microsoft was the opportunity to chide our president for a common marital indiscretion. Trust me, reality TV will never compare to the rising tide of affluence and political boredom that lay behind that spectacle. Tila Tequila just isn't as much fun when your favorite hedge fund is tanking, live, on MSNBC.

Those days will be back, though. Once the Chinese and the Middle East are under control, Europe stops rankling about our GM agriculture, and Africa stops chafing our collective conscience... But who can deliver us?

Right administration is no longer the province of the government (the executive in particular). Rather, we must choose a leader with the qualities to guide us through this dark time: character, judgment, heroism, patriotism, courage. Obama, or McCain? Where is our Pericles, our Caesar? Who will rally us to defeat our enemies (who even lurk among us)? Perhaps we are right to look for something closer to a monarch than a bureaucrat.

I guess that line from Schmitt got me (and everyone else) all tied in knots: "sovereign is he who decides on the state of exception". A description of the political landscape. But as a contingent one, it leads me to some potentially irritating questions.

But how did we come to this place, the new state of emergency? What's it like to live here? What sustains it? And will we ever leave?

Basic Object-Oriented Concepts

Venkat Shiva Reddy — Thu, 24 Jul 2008 08:37:03 +0000

How People Understand Technology
How People Approach Object-Oriented Technology
Object-Oriented Terms and Concepts
- Objects
- Classes, Metaclasses, Parameterized Classes, and Exemplars
- Black Boxes and Interfaces
- Aggregation
- Specialization and Inheritance
- Abstract Classes
- Operations
- Constants
- Exceptions
- Object Coupling and Object Cohesion
- Systems of Objects

How People Understand Technology

There is an old story of how several blind men set out to understand what an elephant was by examining a live specimen. Each of them explored a different part of the elephant's body. One blind man, falling against the elephant's side, proclaimed that an elephant must be very much like a wall. Another, grasping the elephant's ear, decided that an elephant must closely resemble a leaf. One grabbed the elephant's tail and determined that elephants must resemble ropes. Yet another felt the elephant's leg and came away convinced that elephants are very much like trees. Still another held the elephant's trunk and exclaimed that elephants had much in common with snakes.

While there was at least a grain of truth in each blind man's observation, none of them had a complete and accurate understanding of just what an elephant is. We can imagine the many animated debates that these blind men had when they compared notes -- each sure that the others must be wrong.

Often, people studying technology are like the blind men in our story. It is very common to focus intently on one facet of one aspect of a technology while ignoring the vast breadth of the same technology. There is nothing wrong with this -- unless a person studying the facet begins to think that he or she has somehow acquired a good grasp of the entire technology.

To acquire an in-depth understanding of a technology requires a great deal of research. The sheer bulk of material that must be examined is daunting. The task is further complicated by the unfortunate errors contained in many discussions. Even if an individual can assimilate a large quantity of material and easily identify any errors, there is still the process of analyzing what has been assimilated. To truly understand a technology, an individual must be able to recognize valid patterns, and to easily spot invalid patterns.

How People Approach Object-Oriented Technology

Object-oriented technology is both immense and far-reaching. End users of computer systems and computer-based systems notice the effects of object-oriented technology in the form of increasingly easy-to-use software applications and operating systems and in more flexible services being provided by such industries as banking, telecommunications, and cable television. For the software engineer, object-oriented technology encompasses object-oriented programming languages, object-oriented development methodologies, management of object-oriented projects, object-oriented computer hardware, and object-oriented computer aided software engineering, among others.

It is not surprising, therefore, that there is some confusion regarding object-oriented terms and concepts. In this article, we will provide the reader with working definitions for object-oriented terms and concepts that are necessary for a reader to acquire a basic understanding of object-oriented technology.

Many of the terms commonly used in object-oriented technology were originally used to describe object-oriented programming (coding) concepts. Specifically, although the terms were borrowed from a non-computer-software perspective, they were first used extensively to describe concepts embodied in object-oriented programming languages, such as Smalltalk, C++, and Eiffel. However, these terms are quite useful even if one never intends to write any software at all.

For example, an industrial modeler could create an object-oriented model of a plastics manufacturing facility. Molding machines, plastic parts, and even the "recipes" (proportional combinations) of the chemicals used to create the various plastics could all be described in object-oriented terms. Further, dynamic and static relationships among these items could also be described in object-oriented terms.

Finally, keep in mind that there is no one ultimate set of definitions for object-oriented terms and concepts. Depending on who you are talking to, terms and definitions will vary slightly. This is normal; in different parts of the United States, the same breakfast item might be referred to as a pancake, a griddle cake, a flapjack, or a hot cake. Even in technical arenas, this variation in terminology is common. A chemist might use the terms "valance" and "oxidation state" to identify the same concept.

Object-Oriented Terms and Concepts

Objects

Objects are the physical and conceptual things we find in the universe around us. Hardware, software, documents, human beings, and even concepts are all examples of objects. For purposes of modeling his or her company, a chief executive officer could view employees, buildings, divisions, documents, and benefits packages as objects. An automotive engineer would see tires, doors, engines, top speed, and the current fuel level as objects. Atoms, molecules, volumes, and temperatures would all be objects a chemist might consider in creating an object-oriented simulation of a chemical reaction. Finally, a software engineer would consider stacks, queues, windows, and check boxes as objects.

Objects are thought of as having state. The state of an object is the condition of the object, or a set of circumstances describing the object. It is not uncommon to hear people talk about the "state information" associated with a particular object. For example, the state of a bank account object would include the current balance, the state of a clock object would be the current time, the state of an electric light bulb would be "on" or "off." For complex objects like a human being or an automobile, a complete description of the state might be very complex. Fortunately, when we use objects to model real world or imagined situations, we typically restrict the possible states of the objects to only those that are relevant to our models.

We also think of the state of an object as something that is internal to an object. For example, if we place a message in a mailbox, the (internal) state of the mailbox object is changed, whereas the (internal) state of the message object remains unchanged.

Sometimes people think of objects as being strictly static. That is, the state of an object will not change unless something outside of the object requests the object to change its state. Indeed, many objects are passive (static). A list of names does not spontaneously add new names to itself, nor would we expect it to spontaneously delete names from itself.

However, it is possible for some objects to change their own state. If an object is capable of spontaneously changing its own state, we refer to it as an "object with life." (Objects with life are sometimes also called "active objects" or "actors.") Clocks and timers are common examples of objects with life. If we were modeling a business process, we would recognize that salespeople and customers were also objects with life.

Classes, Metaclasses, Parameterized Classes, and Exemplars

There are two broad categories of objects: classes and instances. Users of object-oriented technology usually think of classes as containing the information necessary to create instances, i.e., the structure and capabilities of an instance is determined by its corresponding class. There are three commonly used (and different) views on the definition for "class":

A class is a pattern, template, or blueprint for a category of structurally identical items. The items created using the class are called instances. This is often referred to as the "class as a `cookie cutter'" view. As you might guess, the instances are the "cookies."
A class is a thing that consists of both a pattern and a mechanism for creating items based on that pattern. This is the "class as an `instance factory'" view; instances are the individual items that are "manufactured" (created) using the class's creation mechanism.
A class is the set of all items created using a specific pattern. Said another way, the class is the set of all instances of that pattern.

In this article, we will use the definition of a "class an `instance factory.'"

We should note that it is possible for an instance of a class to also be a class. A metaclass is a class whose instances themselves are classes. This means when we use the instance creation mechanism in a metaclass, the instance created will itself be a class. The instance creation mechanism of this class can, in turn, be used to create instances -- although these instances may or may not themselves be classes.

A concept very similar to the metaclass is the parameterized class. A parameterized class is a template for a class wherein specific items have been identified as being required to create non-parameterized classes based on the template. In effect, a parameterized class can be viewed as a "fill in the blanks" version of a class. One cannot directly use the instance creation mechanism of a parameterized class. First, we must supply the required parameters, resulting in the creation of a non-parameterized class. Once we have a non-parameterized class, we can use its creation mechanisms to create instances.

In this article, we will use the term "class" to mean metaclass, parameterized class, or a class that is neither a metaclass nor a parameterized class. We will make a distinction only when it is necessary to do so. Further, we will occasionally refer to "non-class instances." A non-class instance is an instance of a class, but is itself not a class. An instance of a metaclass, for example, would not be a non-class instance.

In this article, we will sometimes refer to "instantiation." Instantiation has two common meanings:

as a verb, instantiation is the process of creating an instance of a class, and
as a noun, an instantiation is an instance of a class.

Some people restrict the use of the term "object" to instances of classes. For these people, classes are not objects. However, when these people are confronted with the concepts of metaclasses and parameterized classes, they have a difficulty attempting to resolve the "problems" these concepts introduce. For example, is a class that is an instance of a metaclass an object -- even though it is itself a class? In this article, we will use the term "object" to refer to both classes and their instances. We will only distinguish between the two when needed.

Black Boxes and Interfaces

Objects are "black boxes." Specifically, the underlying implementations of objects are hidden from those that use the object. In object-oriented systems, it is only the producer (creator, designer, or builder) of an object that knows the details about the internal construction of that object. The consumers (users) of an object are denied knowledge of the inner workings of the object, and must deal with an object via one of its three distinct interfaces:

the "public" interface. This is the interface that is open (visible) to everybody.
the "inheritance" interface. This is the interface that is accessible only by direct specializations of the object. (We will discuss inheritance and specialization later in this chapter.) In class-based object-oriented systems, only classes can provide an inheritance interface.
the "parameter" interface. In the case of parameterized classes, the parameter interface defines the parameters that must be supplied to create an instance of the parameterized class.

Another way of saying that an item is in the public interface of an object is to say that the object "exports" that item. Similarly, when an object requires information from outside of itself (e.g., as with the parameters in a parameterized class), we can say that the object needs to "import" that information.

Aggregation

It is, of course, possible for objects to be composed of other objects. Aggregation is either:

the process of creating a new object from two or more other objects, or
an object that is composed of two or more other objects.

For example, a date object could be fashioned from a month object, a day object, and a year object. A list of names object, for example, can be thought of as containing many name objects.

A monolithic object is an object that has no externally-discernible structure. Said another way, a monolithic object does not appear to have been constructed from two or more other objects. Specifically, a monolithic object can only be treated as a cohesive whole. Those outside of a monolithic object cannot directly interact with any (real or imagined) objects within the monolithic object. A radio button in a graphical user interface (GUI) is an example of a monolithic object.

Composite objects are objects that have an externally-discernible structure, and the structure can be addressed via the public interface of the composite object. The objects that comprise a composite object are referred to as component objects. Composite objects meet one or both of the following criteria:

the state of a composite object is directly affected by the presence or absence of one or more of its component objects, and/or
the component objects can be directly referenced via the public interface of their corresponding composite object.

It is useful to divide composite objects into two subcategories: heterogeneous composite objects and homogeneous composite objects:

A heterogeneous composite object is a composite object that is conceptually composed of component objects that are not all conceptually the same. For example, a date (made up of a month object, a day object, and a year object) is a heterogeneous composite object.
A homogeneous composite object is a composite object that is conceptually composed of component objects that are all conceptually the same. For example, a list of addresses is a homogeneous composite object.

The rules for designing heterogeneous composite objects are different from the rules for designing homogeneous composite objects.

Specialization and Inheritance

Aggregation is not the only way in which two objects can be related. One object can be a specialization of another object. Specialization is either:

the process of defining a new object based on a (typically) more narrow definition of an existing object, or
an object that is directly related to, and more narrowly defined than, another object.

Specialization is usually associated with classes. It is usually only in the so-called "classless" object-oriented systems that we think of specialization for objects other than classes.

Depending on their technical background, there are a number of different ways in which people express specialization. For example, those who are familiar with an object-oriented programming language called Smalltalk refer to specializations as "subclasses" and to the corresponding generalizations of these specializations as "superclasses." Those with a background in the C++ programming language use the term "derived class" for specialization and "base class" for corresponding generalizations.

It is common to say that everything that is true for a generalization is also true for its corresponding specialization. We can, for example, define "checking accounts" and "savings accounts" as specializations of "bank accounts." Another way of saying this is that a checking account is a kind of bank account, and a savings account is a kind of bank account. Still another way of expressing this idea is to say that everything that was true for the bank account is also true for the savings account and the checking account.

In an object-oriented context, we speak of specializations as "inheriting" characteristics from their corresponding generalizations. Inheritance can be defined as the process whereby one object acquires (gets, receives) characteristics from one or more other objects. Some object-oriented systems permit only single inheritance, a situation in which a specialization may only acquire characteristics from a single generalization. Many object-oriented systems, however, allow for multiple inheritance, a situation in which a specialization may acquire characteristics from two or more corresponding generalizations.

Our previous discussion of the bank account, checking account, and savings account was an example of single inheritance. A telescope and a television set are both specializations of "device that enables one to see things far away." A television set is also a kind of "electronic device." You might say that a television set acquires characteristics from two different generalizations, "device that enables one to see things far away" and "electronic device." Therefore, a television set is a product of multiple inheritance.

Abstract Classes

Abstract Classes We usually think of classes as being complete definitions. However, there are situations where incomplete definitions are useful, and classes that represent these incomplete definitions are equally useful. For example, in everyday conversation, we might talk about such items as bank accounts, insurance policies, and houses. In object-oriented thinking, we often isolate useful, but incomplete, concepts such as these into their own special classes.

Abstract classes are classes that embody coherent and cohesive, but incomplete, concepts, and in turn, make these characteristics available to their specializations via inheritance. People sometimes use the terms "partial type" and "abstract superclass" as synonyms for abstract class. While we would never create instances of abstract classes, we most certainly would make their individual characteristics available to more specialized classes via inheritance.

For example, consider the concept of an automobile. On one hand, most people know what an automobile is. On the other hand, "automobile" is not a complete definition for any vehicle. It would be quite accurate to describe "automobile" as the set of characteristics that make a thing an automobile, in other words, the "essence of automobile-ness."

Operations

The public interface of an object typically contains three different categories of items:

operations (sometimes referred to as "method selectors," "method interfaces," "messages," or "methods"),
constants, and
exceptions.

An operation in the public interface of an object advertises a functional capability of that object. For example, "deposit" would be an operation in the public interface of a bank account object, "what is current temperature" would be an operation in the public interface of a temperature sensor object, and "increment" would be an operation in the public interface of a counter object.

The actual algorithm for accomplishing an operation is referred to as a method. Unlike operations, methods are not in the public interface for an object. Rather, methods are hidden on the inside of an object. So, while users of bank account objects would know that they could make a deposit into a bank account, they would be unaware of the details as to how that deposit actually got credited to the bank account.

We refer to the operations in the public interface of an object as "suffered operations." Suffered operations are operations that meet two criteria: they are things that happen to an object, and they are in the public interface of that object. For example, we can say that a bank account "suffers" the operation of having a deposit made into it. The bank account can also "suffer" the operation of being queried as to its current balance. Some people also refer to suffered operations as "exported operations."

There are three broad categories of suffered operations, i.e.:

A selector is an operation that tells us something about the state of an object, but cannot, by definition, change the state of the object. An operation that tells us the current balance of a bank account is an example of a selector operation.
A constructor is an operation that has the ability to change the state of an object. For example, an operation in the public interface to a mailbox object that added a message to the mailbox would be a constructor operation. (Please note that some people restrict the definition of the term "constructor" to those operations that cause instances of a class to come into existence.)
In the context of a homogeneous composite object, an iterator is an operation that allows its users to visit (access) each of the component objects that make up the homogeneous composite object. If we have a list of addresses, for example, and we wish to print the entire list, an iterator would allow us to visit each address object within the list and then, in turn, to print each address.

Iterators can be further divided into two broad categories: active (open) iterators and passive (closed) iterators. Active iterators are objects in their own right. Passive iterators are implemented as operations in the interface of the object over which they allow iteration. Passive iterators are further broken down into selective iterators and constructive iterators. Passive selective iterators do not allow their users to change the object over which the iteration takes place. Passive constructive iterators do allow users to change the object over which iteration takes place.

We can also describe suffered operations as primitive or composite. A primitive operation is an operation that cannot be accomplished simply, efficiently, and reliably without direct knowledge of the underlying (hidden) implementation of the object. As an example, we could argue that an operation that added an item to a list object, or an operation that deleted an item from a list object were primitive operations with respect to the list object.

Suppose that we wanted to create a "swap operation," an operation that would swap in a new item in a list, while at the same time swapping out an old item in the same list. This is not a primitive operation since we can accomplish this with a simple combination of the delete operation (deleting the old item) followed by the add operation (adding the new item). The swap operation is an example of a composite operation. A composite operation is any operation that is composed, or can be composed, of two or more primitive operations.

Sometimes objects need help in maintaining their characteristics. Suppose, for example, that we wanted to create a "generic ordered list" object. An ordered list is a list that must order its contents from the smallest to the largest. Specifically, every time we add an item to our ordered list, that item would have to be placed in its proper position with respect to all the other items already in the list. By "generic," we mean a template that can be instantiated with the category (class) of items we wish to place in the ordered list.

It would not be unreasonable to implement this object as a parameterized class. Obviously, one of the parameters would be the category of items (e.g., class) that we desired to place in the list. For example, could instantiate (make an instance) the generic ordered list with a "name class" resulting in the creation of an "ordered list of names class."

There is a problem, however. Given that we could instantiate the generic ordered list with just about any category of items, how can we be sure that the ordered lists will know how to properly maintain order -- no matter what we use to instantiate the generic ordered list? Suppose, for example, that we wanted an ordered list of "fazoomas." How could the generic list class tell if one fazooma was greater than or less than another fazooma?

A solution would be for the generic ordered list to require a second parameter, a parameter over and above the category of items (class) that we desired to place in the list. This second parameter would be a "<" (less than) operation that worked with the category of items to be placed in the list. In the case of our ordered list of fazoomas, this second parameter would be a "<" that works with fazoomas.

The "<" that worked with fazoomas is an example of a required operation. A required operation is an operation that an object needs to maintain its outwardly observable characteristics, but which the object cannot supply itself. Some people refer to required operations as "imported operations."

Constants

In addition to suffered operations, the public interface of an object can also contain constants. Constants are objects of constant state. Imagine that we want to create a "bounded list of addresses class." A bounded list is a list that has a fixed maximum number of elements. A bounded list can be empty, and it can contain fewer than the maximum number of elements. It can even contain the maximum number of elements, but it can never contain more than the defined maximum number of elements.

Assume that we place a constant in the public interface of our bounded list of addresses. This constant represents the maximum number of elements that can be placed in the bounded list. Assume also that there is a suffered operation that will tell us how many elements (addresses, in our example) are currently in the bounded list. We can now determine how much room is available in the bounded list by inquiring how many addresses are already in the list, and then subtracting this from the previously-defined constant.

In some cases, as with the bounded list example above, constants are provided more for convenience than necessity. In other cases, such as in the case of encryption algorithms needing a "seed value," constants are an absolute requirement.

Exceptions

A third category of items that can be found in the public interface of objects is exceptions. Exceptions have two different definitions:

an event that causes suspension of normal application execution, and
a set of information directly relating to the event that caused suspension of normal application execution.

Exceptions can be contrasted with an older, less reliable technology: "error codes." The idea behind error codes was fairly simple. You would request that an application, or part of an application, accomplish some work. One of the pieces of information that would be returned to the requester would be an error code. If all had gone well, the error code would typically have a value of zero. If any problems had occurred, the error code would have a non-zero value. It was also quite common to associate different non-zero values of an error code with specific errors.

Error codes suffered from two major problems:

No one was forced to actually check the value of returned error codes.
Changes (additions, deletions, and modifications) in the meanings of the special values assigned to error codes were not automatically passed on to interested parties. Tracking the effects of a changed error code value often consumed a significant amount of resources.

To understand how exceptions directly address both of these issues, we first need to understand how exceptions typically work:

Exceptions may be defined by the environment or by the user.
When an exceptional (but not unforeseen) condition occurs, an appropriate exception is activated. (People use different terms to express the activation of an exception. The most common is "raise." Less commonly, people use the terms "throw" or "activate.") This activation may be automatic (controlled by the environment) or may be expressly requested by the designer of the object or application.

Examples of exceptional conditions include trying to remove something from an empty container, directing an elevator on the top floor to "go up," and attempting to cause a date to take on an invalid value like "February 31, 1993."

Once the exception is activated, normal application execution stops and control is transferred to a locally defined exception handler, if one is present. If no locally defined exception handler is present or if the exception handler is not equipped to handle the exception, the exception is propagated to the next higher level of the application. Exceptions cannot be ignored. An exception will continue to be sent to higher levels of the application until it is either turned off or the application ceases to function.
An exception handler checks to see what type of exception has been activated. If the exception is one that the handler recognizes, a specific set of actions is taken. Executing a set of actions in response to an exception is known as "handling the exception." Handling an exception deactivates the exception; the exception will not be propagated any further.

Unlike error codes, exceptions cannot be ignored. Once an exception has been activated, it demands attention. In object-oriented systems, exceptions are placed in the public interfaces of objects. Changes in the public interfaces of objects very often require an automatic rechecking of all other objects that invoke operations in the changed objects. Thus, changes in exceptions result in at least a partially automated propagation of change information.

Object Coupling and Object Cohesion

Engineers have known for centuries that the less any one part of a system knows about any other part of that same system, the better the overall system. Systems whose components are highly independent of each other are easier to fix and enhance than systems where there are strong interdependencies among some or all of the components. Highly independent system components are possible when there is minimal coupling among the components, and each component is highly cohesive.

Coupling is a measure of the strength of the connection between any two system components. The more any one component knows about another component, the tighter (worse) the coupling is between those two components. Cohesion is a measure of how logically related the parts of an individual component are to each other, and to the overall component. The more logically related the parts of a component are to each other the higher (better) the cohesion of that component.

The objects that make up an object-oriented system exhibit object coupling and object cohesion. Object coupling describes the degree of interrelationships among the objects that make up a system. The more any one object knows about any other object in the system, the tighter (worse) the coupling is between those two objects.

To construct systems from objects, we must couple (to some degree) the objects that comprise the system. This is necessary object coupling. However, if in the design of an individual object, we give that object direct knowledge of other specific objects, we are unnecessarily coupling the objects. Unnecessary object coupling reduces both the reusability of individual objects, and the reliability of the systems that contain unnecessarily coupled objects.

Object cohesion, on the other hand, is a measure of how logically related the components of the external view of an object are to each other. For example, if we are told that a date object is comprised of a month object, a day object, a year object, and the color blue, we should recognize that the color blue is not appropriate, and lowers the cohesion of the date object. We want our objects to be as cohesive as possible for two reasons. First, objects with low cohesion are more likely to be changed, and are more likely to have undesirable side effects when they are changed. Second, objects with low cohesion are seldom easily reusable.

Systems of Objects

In constructing object-oriented models and object-oriented applications, one quickly finds that single classes and single instances are not enough. You need some way of creating and dealing with large objects. A system of objects is defined as two or more interacting or interrelated, non-nested objects. (We exclude simple aggregations of composite objects from our definition of systems of objects.)

Systems of objects fall into two general categories:

kits, which are collections of items (classes, metaclasses, parameterized classes, non-class instances, other kits, and/or systems of interacting objects) all of which support a single, large, coherent, object-oriented concept, such as computer graphics windows or insurance policies. There may indeed be some physical connection among some of the members of a given kit. However, kits are "granular." While all the components of a kit are logically related, there are very few physical connections that bind them together.
systems of interacting objects, which are collections of items (classes, metaclasses, parameterized classes, non-class instances, kits, and/or other systems of interacting objects) all of which support a single, large, coherent, object-oriented concept, and in which there must be a direct or indirect physical connection between any two arbitrary objects within the collection. Further, systems of interacting objects have at least one internal, independently executing thread of control. Lastly, systems of interacting objects may exhibit multiple, completely disjoint public interfaces.

Kits resemble libraries. Say, for example, that we had to create a computer application with a graphical user interface. Graphical user interfaces normally contain several different types of windows. It would be very useful if we had a library of windows and window components from which we could construct any window we desired. Windows are objects, and the components of windows (buttons and check boxes) are themselves objects. A collection of windows and window components can be viewed as a kit.

Systems of interacting objects, on the other hand, resemble applications. For example, suppose that we wanted to construct an object-oriented application that controlled the elevators in a particular building. We would assemble elevators, buttons, lamps, panels, and other objects into a working application that would control the elevators. Such an application would not be viewed as a library, but as a highly cohesive whole. The elevator controller application is a system of interacting objects.

التعامل مع الاخطاء في البرمجة الكائنية : الفئة ExecutionCondition مثالاً

alnabhani — Tue, 22 Jul 2008 03:37:56 +0000

يعد اسلوب البرمجة الكانئية افضل اسلوب برمجي تطبقه في معظم اللغات الحديثة والقوية وخصوصا لغات الدوت نت سواء كانت VB.Net او C# ، وعندما تطبق هذا الاسلوب فمن الاكيد بانك ستقوم ببناء فئات Classes وستحتوي بداخلها على اعضاء Members كـ Properties,Function,Subs وغيرها ، ثم تستخدم هذه الفئات في أي جزء رئيسي من الرنامج بإنشاء كائن جديد منها ثم اسناد القيم والخصائص إليه من خلال المشيد Constructor في حالة وجوده او من خلال الخصائص القابلة للكتابة Writable Properties او لاشيء من هذا !

لاحقا وبعد ان تكتب الاكواد داخل الأعضاء الخاصة بفئتك التي انشاتها للتو واللحظة ، فإنك قد تتساءل حول عملية قنص الاستثناءات Exceptions ، فماذا لو حدث استثناء معين او خطاء وقت التنفيذ في الكود ؟ هذا ما سنناقشه هنا .

لنفترض انك قد قمت بعمل فئة بالإسم MyData والتي تمثل بيانات شخصيه معينه يتم اسنادها لها ،كالخصائص التالية مثلا : FirstName,FamilyName,Age ، بحيث صارت كالتالي :

Public Class MyData

Dim _FirstName As String

Public Property FirstName() As String

Get

Return _FirstName

End Get

Set(ByVal value As String)

_FirstName = value

End Set

End Property

Dim _FamilyName As String

Public Property FamilyName() As String

Get

Return _FamilyName

End Get

Set(ByVal value As String)

_FamilyName = value

End Set

End Property

Dim _Age As Byte

Public Property Age()

Get

Return _Age

End Get

Set(ByVal value)

_Age = value

End Set

End Property

End Class

ثم طلبت منك ان تضيف لهذه الفئة طريقة Method تقوم بكتابة البيانات الى ملف - وذلك بإضافتها الى بيانات اخرى موجودة سابقا- لتكتب الاسم الاول والعائلة والعمر ، ولنفترض - واقول نفترض- انك كتبت الكود التالي بالضبط ( بما فيه من اخطاء فادحة ! ) :

Public Sub WriteDataToFile(ByVal FileName As String)

Dim FileContent As String

FileContent = "الإسم الأول : " & Me.FirstName & " العائلة : " & Me.FamilyName & " العمر " & Me.Age

My.Computer.FileSystem.WriteAllText(FileName, FileContent, True)

End Sub

الآن لو قمنا بإنشاء كائن جديد من هذه الفئة واعطيناه قيما لخصائصه وطلبنا من الكائن ان يتكرم علينا بتنفيذ الطريقة WriteDataToFile واعطيناه الوسيط المناسب كالتالي :

Module Module1

Sub Main()

Dim Mohammed As New MyData

Mohammed.FirstName = "Mohammed"

Mohammed.FamilyName = "AL-Nabhani"

Mohammed.Age = 20

Mohammed.WriteDataToFile("C:\Users\Personals\Documents\MyData.txt")

Console.ReadLine()

End Sub

End Module

ثم قمنا بتجربة البرنامج ، لكن مهلا هناك استثناء وارد بنسبه كبيرة جدا وهو ان الملف MyData غير موجود ! قد تفكر بان عملية التحقق من وجود الملف اولا افضل وانا اتفق معك في ذلك تماما ، لكن ما هي سيناريوهات العملية القادمة ؟ اذا لم يجد الملف ماذا يفعل البرنامج ؟

في حالتي لا اريد انشاء ملف لانني اريد ان اضيف البيانات الى الملف MyData لا أن أققوم بإنشاءه في حالة عدم وجودة ، لذلك فإننا نرغب الآن بإعلام المستخدم بأن الملف غير موجود واجزم انك تتفق معي الان في ذلك ، لكن السؤال كيف سنخبر المستخدم بذلك ؟ ان كنت ستقول لنكتب سطرا مثل التالي في الطريقة المعنية :

Public Sub WriteDataToFile(ByVal FileName As String)

Dim FileContent As String

FileContent = "الإسم الأول : " & Me.FirstName & " العائلة : " & Me.FamilyName & " العمر " & Me.Age

If My.Computer.FileSystem.FileExists(FileName) = True Then

My.Computer.FileSystem.WriteAllText(FileName, FileContent, True)

Else

Console.Write("الملف غير موجود")

End If

End Sub

فسأقول لك ان الطريقة السابقة خاطئة تماما ، صحيح انها ستعطينا الناتج النهائي المطلوب كما قد تشتهيه ، ولكن في في اسلوب البرمجة الكائنيه ذلك خطأ ، فالمفترض ان الفئة التي انشاناها لا تعرض شيء على الشاشة بدون اذن الطريقة Main ، وافرض او اننا اردنا استخدام هذه الفئة في مشروع من نوع WIndowsApplication بدل ConsoleApplication فماذا ستفعل ؟ الادهى لو قمت بترجمه الفئة الى ملف Dll فكيف ستعرف نوع المشروع الحالي ؟ حتى لو عرفت من خلال الكود فهل يعجبك ان تكتب جملة شرطية للتأكد من نوع المشروع ثم اظهار رسالة الخطأ بالطريقة الخاصة بكل واحد ؟

اتمنى انك اقتنعت بذلك ، اما الحل فسيكون بتعديل الطريقة WriteDataToFile لتكون دالة Function بدل Sub وجعلها تعود بقيمة معينه ، طيب فكر معي ، ما هو النوع Type الخاص بهذه الدالة function والتي ستعيده ؟ هل ستعيد Boolean لنعرف ان حدث خطأ ام لا ؟ ام تعيد String في كل مرة ام أي نوع ؟ طيب لنفكر في كل واحدة على حده :

1- النوع Boolean : فكرة جيدة ، لجعل الدالة تعيد قيمة True ان تم تنفيذها كما يجب ، و False في الحالة المعاكسه ولكن يعيبها عدم اعادتها لرسالة الخطأ ، ففي حالة امكانية حدوث اكثر من خطأ واحد فهناك ستواجه مشكلة حول أي رسالة خطأ ستعرض او أي اجراء ستنفذ .
2- النوع String : طريقة جيدة نوعا ما ، لكن لو اردت كتابة دالة تعيد نوع معينا مثلا تقرأ ملفا معينا وتعيد الاسم الاول فكيف ستعرف ان ما اعادته هو الاسم الاول او رسالة الخطأ ؟

لا تقل لي لنضع Field ( حقل ) عام على مستوى المشروع بمثابته متغير من النوع Boolean يعرف اذا حدث خطا ام لا فهذه الطريقة تنتهك OOP من كل النواحي !

طيب ما الحل اذا ؟

الحل يتم بعمل نوع جديد خاص بنا لمثل هذه الحالات ، وهو عمل فئة Class تحمل خاصية تخبرنا ان حدث خطا او لا ، وتعطينا ايضا نص رسالة الخطأ او حتى كائن الـ Error بأكمله او أي شيء من هذا القبيل ... كما قد نطورها اكثر لتحمل قيمة ما تود ارجاعه كما في الحالة الثانية اعلاه ، وهو الحل الذي سأتبعه في هذا النطاق مع انه قد يوجد حلول افضل ولكن ذلك يعتمد على الحالات التي تواجهها في برامجك .

الفئة الجديدة والتي سنعول عليها معرفة حدوث خطأ وحمل قيمة ناتج عملياتنا اسميتها ExecutionCondition وستحمل الخصائص التالية :

HasErrors : وهي خاصية للقراءة فقط ReadOnly ومن النوع Boolean
ErrorMessage : وهي خاصية للقراءة فقط ايضا ومن النوع Strign
Value : وهي خاصية اختيارية لك ، وهي من النوع Object .

بالنسبة للطرق فقد وضعت اجرائين فقط :

SetErrorMessage : وهو الذي نستخدمه في اعطاء الخاصية ErrorMessage قيمتها وبناءا عليه تتحدد قمية الخاصية HasErrors .
Reset : يعيد الكائن الى حالته الاساسية أي بدون خطأ مع عدم المساس بقيمة الكائن المتمثل في الخاصية Value .

لن اقوم بشرح كل شيء في هذه الفئة ، فهي واضحة وضوح الشمس لكل من لديه اساسيات ولو بسيطة في OOP :

''' <summary>

''' This class is used to return an object with value and error message when error occur

''' </summary>

''' <remarks></remarks>

Public Class ExecutionCondition

#Region "Properties"

Dim _HasErrors As Boolean

''' <summary>

''' Determines if the assosiated process has an errors while executing it

''' </summary>

''' <value></value>

''' <returns></returns>

''' <remarks></remarks>

Public ReadOnly Property HasErrors() As Boolean

Get

If Me._HasErrors = True Then Me._ErrorMessage = ""

Return _HasErrors

End Get

End Property

Dim _ErrorMessage As String

''' <summary>

''' Gets the error message if the assisiated process has an erors while executing

''' </summary>

''' <value></value>

''' <returns></returns>

''' <remarks></remarks>

Public ReadOnly Property ErrorMessage() As String

Get

Return _ErrorMessage

End Get

End Property

Dim _Value As Object

''' <summary>

''' Represents the value of the ibject, it could be any type .

''' </summary>

''' <value></value>

''' <returns></returns>

''' <remarks></remarks>

Public Property Value() As Object

Get

Return _Value

End Get

Set(ByVal value As Object)

_Value = value

End Set

End Property

#End Region

#Region "Methods"

Public Sub New()

End Sub

''' <summary>

''' Sets the Error Message

''' </summary>

''' <param name="Message">"the message of the error that will be presented in Error Message property</param>

''' <remarks></remarks>

Public Sub SetErrorMessage(ByVal Message As String)

_ErrorMessage = Message

_HasErrors = True

End Sub

''' <summary>

''' resets the object so no errors are contained

''' </summary>

''' <remarks></remarks>

Public Sub Reset()

Me._HasErrors = False

End Sub

#End Region

End Class

الآن لنقم بعمل مثال عملي جديد لنجرب استخدام هذه الفئة ، اما بخصوص مثالنا السابق والفئة MyData فاعتبره تمرينا لك لحل مشكلتنا الأساسية !

في الوحدة النمطية Module1 التي تحتوي على الطريقة Main - الجزء الاساسي من البرنامج بطبيعة الحال - فقد قمت باضافة الدالة التالية فيها :

Function WriteOnTheScreen() As ExecutionCondition

Dim mExCn As New ExecutionCondition

Try

Console.WriteLine(5 / 1)

Console.ReadLine()

mExCn.Reset()

Catch ex As Exception

mExCn.SetErrorMessage(ex.Message)

End Try

Return mExCn

End Function

وفي الطريقة Main كتبت الكود التالي :

Sub Main()

'لنجرب تنفيذ الدالة

'WriteOnTheScreen

If WriteOnTheScreen.HasErrors = True Then

Console.WriteLine(WriteOnTheScreen.ErrorMessage)

End If

Console.ReadLine()

End Sub

بعد تشغيل البرنامج سيظهر كل شيء على ما يرام هذه المرة وسيطبع 5 ، لنجرب الآن تعديل الطريقة WriteOnTheScreen ولنجعل القسمة مبنية على صفر وهذا خطأ رياضي فادح جدا :

Function WriteOnTheScreen() As ExecutionCondition

Dim mExCn As New ExecutionCondition

Try

Dim x As Integer = 5

Dim y As Integer = 0

Dim z As Integer = x / y

Console.WriteLine(z)

Console.ReadLine()

mExCn.Reset()

Catch ex As Exception

mExCn.SetErrorMessage(ex.Message)

End Try

Return mExCn

End Function

الآن قم بتنفيذ البرنامج ولاحظ ماسيحدث ، سيطبع نص رسالة الخطأ مهما يكن نوع الخطأ الذي حدث ، سواء القسمة على صفر او أي خطأ آخر وتأكد من كلامي جيدا !

ختاما ارجو انني قد وفقت في لفت الانتباء الى مسألة التعامل مع الاخطاء في الكائنات المستقلة واذا وجد هنا أي خطأ فأرجو تنبيهي عليه وجل من لا يسهو .

Sharepoint: end of "exception state"

Max — Mon, 21 Jul 2008 08:46:41 +0000

Good morning,

this weeks starts brilliantly thanks to the help of Chris Winebarger. He gave me a solution to put an end to the most infamous sharepoint 0x80020009 exception when trying to activate Sharepoint Publishing Infrastructure on a site collection. Here is the solution with stsadm :

stsadm -o activatefeature -filename publishing\feature.xml -url http://URL -force stsadm -o activatefeature -filename publishingresources\feature.xml -url http://URL -force stsadm -o activatefeature -filename publishingSite\feature.xml -url http://URL -force stsadm -o activatefeature -filename publishingweb\feature.xml -url http://URL -force stsadm -o activatefeature -filename publishinglayouts\feature.xml -url http://URL -force stsadm -o activatefeature -filename navigation\feature.xml -url http://URL -force

(Obviously, replace the URL above with the URL of the site collection)

Many thanks to Chris for saving my day!
Max

Bỏ qua việc kiểm tra null pointer

Lê Mạnh Cường — Mon, 21 Jul 2008 05:07:24 +0000

Thường trong khi lập trình bạn không tránh khỏi có lúc quên không kiểm tra xem đối tượng có null không. Thế nên chúng ta sẽ tìm cách viết code thế nào để quên không kiểm tra mà vẫn không bị lỗi NullPointerException.

Ví dụ code xấu:

private boolean isNullString(String string) {
return (string.equals(""));
}

Như bạn thấy nếu ta gọi isNullString(null); thì phương thức trên sẽ tung ra exception.

Ví dụ code ngon:

private boolean isNullString(String string) {
return ("".equals(string));
}

Bây giờ ta có gọi isNullString(null) thì return ("".equals(null)) sẽ trả về false mà không bị Exception.

Income Tax Section 80C, 80CCC, 80CCD, 80CCE

amitdarda — Tue, 15 Jul 2008 05:02:04 +0000

Section 80C. - Section 80C was inserted from assessment year 2006-2007. It provides deductions from gross (total) income for qualified amounts paid or deposited by the assessee in the previous year.

Main Provisions.

The deduction is available only to an individual or a HUF from the gross total income,
The deduction is allowed irrespective of whether such amount is paid or deposited by the taxpayer out of his income chargable to tax,
The deduction is available on the basis of specified qualifying investments/contributions/payments made by the taxpayer during the previous year,
The maximum amount deductible under section 80C is Rs. 1,00,000. Also the total amount of deductions under sections 80C, 80CCC and 80CCD is Rs. 1,00,000.

Gross Qualifying Amount for the Deduction
Following nature of payments are qualifying amounts

Life insurance premium subject to 20 per cent of sum assured,
Payment in respect to non-commutable deferred annuity,
Deferred annuity deducted from Government employee (subject to maximum of 20 per cent of salary),
Contributions (not the repayment of loan) towards statutory provident fund and recognised provident fund,
Contribution towards an approved superannuation fund,
Subscription to National Saving Certificates, VIII Issue,
Contribution to ULIP (unit-linked insurance plan) of Unit Trust of India and or LIC Mutual Fund,
Payments for notified annuity plan of LIC including New Jeevan Dhara, New Jeevan Akshary, New Jeevan Dhara I, New Jeevan Akshary I, II and III.
Subscription towards notified units of Mutual Fund or UTI,
Contribution to notified pension fund set up by Mutual Fund or UTI,
Any sum paid (and accrued interest) as subscription to Home Loan Account Scheme of National Housing Bank or contribution to any pension fund of National Housing Bank,
Any sum paid as subscription to any scheme of public sector company engaged in providing longterm finance for purchase/construction of residential houses or from the housing board in India engaged in planning and development of cities.
Any sum paid as tution fees for the admission or otherwise to any university/college/educational institution in India for full time eduction for any two children of the taxpayer,
Any payment towards the cost of construction/purchase of residential property including payment of loan taken from Government bank, cooperative bank, LIC, National Housing Bank, taxpayer's employer where such employer is a public company, public sector company, university or cooperative society,
Amount invested in approved debentures of, and equity shares in, a public company engaged in infrastructure including power sector or units of mutual fund utilised for infrastructure,
Amount in fixed deposits of 5-years or more with a scheduled bank in accordance with a scheme framed and notified by the Central Government (applicable from assessment year 2007-2008),
Subscription to any notified bonds of National Bank for Agriculture or Rural Development (applicable from assessment year 2008-2009),
5-year time deposit in an account under Post Office Time Deposits Rules 1981, and
Deposit in an account under the Senior Citizen Saving Scheme Rules, 2004.

Section 80CCC. Deduction for Contribution to Pension Funds -Section 80CCC provides deductions from gross (total) income for amounts paid or deposited by the assessee to any annuity plan of Life Insurance Corporation of India or any other insurer for receiving pension from the fund referred to in clause (23AAB).

Main Provisions.

The deduction is available to an individual who is resident or non-resident, Indian citizen or foreign citizen
The deduction is allowed only if such amount is paid or deposited by the taxpayer out of his income chargable to tax,
The maximum amount deductible under section 80C is Rs. 1,00,000. Also the total amount of deductions under sections 80C, 80CCC and 80CCD is Rs. 1,00,000.
Surrender value received is taxable in the year of receipt in the hands of the assessee or nominee.

Section 80CCD. Deduction for contribution to pension scheme of Central Government. - Deduction is allowed to an individual employed by the Central Government or any other employer on or after the 1st day of January, 2004, has in the previous year paid or deposited any amount in his account under a pension scheme notified or as may be notified by the Central Government. However, the deduction is limited to 10 per cent of his salary in the previous year.

Where, the Central Government or any other employer makes any contribution to the employee’s account, the employee shall be allowed a deduction in the computation of his total income. However, the deduction is limited to 10 per cent of his salary in the previous year.

If after claiming the deduction, any amount together with interest or bonus accrued is received by the assessee or his nominee in whole or in part, in any previous year, is taxable of the assessee or his nominee, as the case may be, if it is received --

On account of the closure or opting out of the pension, or
As pension received from the annuity plan purchased or taken on such closure or opting out.

Where any amount paid or deposited by the assessee has been allowed as a deduction under section 80CCD —

No rebate with reference to such amount shall be allowed under section 88;
No deduction with reference to such amount shall be allowed under section 80C.

Explanation. For the purposes of 80CCD, “salary” includes dearness allowance, if the terms of employment so provide, but excludes all other allowances and perquisites.

Section 80CCE. - The aggregate amount of deductions under section 80C, section 80CCC and section 80CCD shall not, in any case, exceed Rs. 1,00,000.

[Doujin] Exception - Light Difficulty

Eryth — Sat, 12 Jul 2008 08:00:10 +0000

So I finally get fraps to work and i finally get the time to record my next set of videos which I decided to play Exception. I don't know why I decided to play it but I think it's a fun game.

So here is all you need to know about the game. You play as a cube. You can shoot a laser and you can also lock on and fire homing lasers at the locked on targets. You can also rotate and change your angle of fire. Everything in this game is comprised of rectangular prisms and cubes that explode and break up into smaller pieces when destroyed. The harder the difficulty the more cubes are expelled when destroyed.

I played and recorded on Light difficulty which is the easiest difficulty of the game. I will do these videos for all difficulties just to show you the game and how hectic yet fun it can be. Oh and just for the records, i did use the mouse to aim and I have played this game using a controller and it wasn't much different. I think i did worse with the mouse actually since my hand always moved over the touchpad on my laptop.

Here is the first set of videos for easy difficulty. Enjoy and comment... ^^

Error and Feedback Handling for PHP

3guineas — Thu, 10 Jul 2008 12:50:24 +0000

This is a simple way to handle your errors and warnings and provide users with a feedbackfor their actions.

The logic

Write an error handler and assign it to the php built-in error handling mechanism (set_error_handler("yourhandler")) where ever you want it to operate. In my case I put it together with the function definition in the file where I keep all my other defaults as such file gets included in all the files of my project, so I avoid to rewrite code for each other file.

The error handler will throw an exception for every error or warning encountered. So, whenever you wish your user to get a message (whether for error or success), put the critical code in a try/catch construct and in the catch body set two session variables, one "alerts" (String) containing the positive/negative messages and one called "input_errors" (Array) which contains the error parameters if any (e.g. if input from forms). Be sure you exit the script or the code that follows will be executed (usually you don't want that especially if a nasty error had occurred).

In the html pages, retrieve the content of the session variables for disaplay (if the variable "input_errors" is empty, we assume that it is a success message) and then delete them from the session.

Implementation

in the file where you keep all your settings and therefore is contained in all the others (def_inc.php susually):

<?
........
//ERROR HANDLING
//setting general error handler
function handleError($errno, $errstr,$error_file,$error_line,$errcontext)
{
$msg= "Sorry some error occurred. ";
$msg.= "<b>Error:</b> [$errno] $errstr - $error_file:$error_line";
$msg.= "<br />";
putsession("alerts",$msg);
putsession("input_errors", "some error");
throw new Exception($msg);
}
//set error handler
set_error_handler("handleError");
...........
?>

In the template for html files which display the feedback messages to the user:
<HEAD>
..........
//handle alerts
$alerts=null;
//check for alerts or errors back from the processing code (putsession('alerts','bla,bla...'),putsession('errors',parameter_errors()))
$input_rules["input_errors"][_structure]=_either_structure;
$input_rules["input_errors"][_sources]=_session;
$input_rules["input_errors"][_required]=false;
$input_rules["input_errors"][_fatal]=false;
$input_rules["alerts"][_structure]=_either_structure;
$input_rules["alerts"][_sources]=_session;
$input_rules["alerts"][_required]=false;
$input_rules["alerts"][_fatal]=false;
$parameters = validate_parameters($input_rules);
$errors = isset($parameters["input_errors"])?$parameters["input_errors"]:null;
$alerts = isset($parameters["alerts"])?$parameters["alerts"]:null;
delsession("input_errors"); //reset input errors to null
delsession("alerts"); //reset alerts to null
.......
</HEAD>

Philadelphia 76ers 2008-09 Cap Projection

Joe — Thu, 10 Jul 2008 04:49:49 +0000

Well, I have been keeping an excel file on my computer with Sixers cap information. I figure others may want to see it. So I will try to keep this page updated regularly. I will put one up for 2009-10 as well once Iguodala and Lou are at least signed.

Sixers 2008-2009 Cap Situation

Last Name	salary($)	salary($1,000,000)
Brand:	13757800	13.76	estimate
Dalembert:	10520000	10.52
Miller:	9999999	10
Iguodala:	10000000	10	estimate
Evans:	4640000	4.64
Williams:	4500000	4.5	estimate
Green:	3388000	3.39
Young:	1968120	1.97
Smith:	1326360	1.33
Speights:	1285500	1.29
Gordon:	442114	0.44
spot #12	0	0
spot #13	0	0
spot #14	0	0
spot #15	0	0

Salary Cap:	58680000	58.68
Luxury Tax:	71150000	71.15

Total:	61827893	61.83

Cap space:	-3147893	-3.15
Tax space:	9322107	9.32

A few notes...

This is not right now. This is a projection for once Andre and Lou are signed. I am using estimates for Lou and Iggy right now.

The estimates are for the first year of the contracts for Iggy and Lou. For example, Iggy could sign a deal starting at 9 with 10.5% increases and still make 10.89 million on average per year. That is the least I can see Iguodala making personally. I took the middle ground between the least and most I can see the players making year 1 in my calculations.

Jamont Gordon or another rookie have to make the team. I put him since he is on the summer league and fits a need. McClellan from Arizona is a favorite as well as Pat Carroll I would think.

Exceptions available:

None. By exercising their cap space, the Sixers lost any trade exception or mid-level exception. All they have is the minimum player exception meaning they can only sign players for the minimum.

The Sixers are going to have to do this the hard way and that is via trades and minimum salary players. Hopefully some vets find the young blood in Philadelphia appealing for their championship aspirations.

A-610: Tout ça pour... ça?

Richard3 — Mon, 23 Jun 2008 04:03:57 +0000

La naissance de l'autoroute 610, en Estrie, est pratiquement passée inaperçue, parce que tout ce qui était un tant soit peu gouvernemental, à ce moment précis, était à Laval, en train de faire des pirouettes pour convaincre les gens que le réseau routier québécois était fiable, et que le viaduc de la Concorde, ou à tout le moins le trou béant devant lequel ils se tenaient, puisque le viaduc venait de s'effondrer, ne représentait qu'un événement isolé.

Dans les faits, qu'est-ce que l'A-610, au juste? Pour ceux qui sont familiers avec les autoroutes de l'Estrie, mais qui ne passent pas souvent dans le coin, pensez au dernier tronçon de l'A-10, qui commençait à la sortie 143, et qui se rendait jusqu'à la route 112, à Fleurimont. C'est ce tronçon qui fut rebaptisé A-610. Je ne comprends toujours pas la logique derrière cette manoeuvre du MTQ. J'ai d'ailleurs écrit au ministère, afin que l'on m'explique, de façon claire, quel sera le réseau autoroutier du futur, selon leurs prévisions. À part un accusé réception, je n'ai pas eu d'autres nouvelles de cette requête.

Voyons donc voir quelques petits détails de l'A-610.

Voici le panneau indiquant le début de l'A-610, que l'on voit quand on arrive de Drummondville, via l'A-55 sud, dans un endroit situé plus ou moins à mi-chemin entre Bromptonville et le centre-ville de Sherbrooke. Comme on peut le voir, le changement de logo, sur le panneau, n'est pas des plus réussis.

L'A-610 file vers l'est, à travers la chaîne des Appalaches.

Un autre rapiéçage de panneau plutôt bâclé. Surtout que celui-ci indique qu'il n'y a plus de services, à la sortie 7, qui fut autrefois la sortie 150 de l'A-10.

Une autre preuve du rapiéçage passablement ordinaire des panneaux de l'A-610. Selon la logique actuellement appliquée par le MTQ, on devrait plutôt voir le logo de l'A-610, suivi du mot "ouest", puis des logos de l'A-10 et de l'A-55, le tout sur une même ligne, puisque c'est là que mène l'A-610. Mais bon, on s'est contenté de masquer le logo de l'A-10 avec un de l'A-610.

Dans l'autre sens, et un peu à contrejour, on voit au loin la séparation des chaussées, à environ un kilomètre à l'est de la sortie 7. Les trois derniers kilomètres de l'A-610 sont construits en super-2.

Ici, à deux kilomètres de la sortie 7, on peut voir qu'à quelques exceptions près, le terrain nécessaire à la construction de la deuxième chaussée est bien dégagé.

C'est la fin de l'A-610. Elle se termine bêtement, à la hauteur de la route 112, dans l'ancienne ville de Fleurimont, qui fait désormais partie de la ville de Sherbrooke.

Vous aimez les autoroutes aux fins toutes bêtes? À Sherbrooke, vous serez bien servis. Encore plus bête que celle de l'A-610, voici la fin de l'A-410, au boulevard de l'Université. Comme vous le voyez, on a construit une jolie courbe, plutôt accentuée, puis on a fait une belle pente, pas très longue, au bout de laquelle on a installé un feu de circulation. Tout ce qu'il faut pour se casser la gueule! On dit depuis des années que l'A-410 sera prolongée vers Lennoxville, mais il semble que les travaux pourraient débuter en 2009, pour une ouverture possible en 2013. Reste à voir si cet échéancier tiendra le coup.

J'avoue que je n'ai pas écrit beaucoup de billets depuis une dizaine de jours. À part le temps que je passe à répondre à vos commentaires (en passant, merci beaucoup à ceux qui m'écrivent, et ne vous gênez surtout pas!), j'ai procédé à quelques achats, dernièrement, dont un nouvel ordinateur, qui me fait royalement chier depuis une semaine, ainsi qu'un projet de "blogue-mobile", que je vais récupérer ce lundi, et qui prend les airs d'une vieille Jeep Cherokee Chief, de couleur bleue. Je vous tiendrai au courant des derniers développements dans les deux cas.

D'ici-là, suite à une question de Sam, je tenterai de savoir où se termine la route 155. Je vous montrerai aussi des travaux sur l'A-20, en Montérégie, sur l'A-10, dans les Cantons-de-l'Est, ainsi que d'autres bouts de routes intéressants, dont un lien inter-rives, où l'on roule sur rien de moins qu'un barrage d'Hydro-Québec! Alors n'allez pas trop loin, car les prochains jours risquent d'être captivants pour les amateurs de routes.

Firefox 3: "Codigo de error: sec_error_untrusted_issuer"

Andres Vigil Rguez. — Fri, 20 Jun 2008 11:03:29 +0000

Si usais Firefox 3, seguramente en algún momento os habrá salido este error, a la hora de identificaros en una página por ejemplo.
Llevaba desde que instalé Hardy Heron con Firefox 3, y no sabía como hacer para acceder a páginas donde me saltaba este error, para lo que abría el VirtualBox, y accedía a la página con IE...
El codigo del error es: sec_error_untrusted_issuer
No se a que se debe, pero se que para que nos os salga más el error y podais acceder a la página en cuestión, debeis agregar una nueva excepcion. Para ello se muestra un link, que debemos pulsar.
Una vez añadida la excepción, ya podremos acceder perfectamente.
Saludos!

EDITO:
Aqui una imagen del error que nos da.
Debemos clickear en el enlace que vemos rodeado de negro.

Despues, seguir los pasos para agregar la excepción.

0xC0000005

windowserrors — Sun, 20 Jul 2008 17:57:13 +0000

Finding a Solution for the 0xC0000005 error.

This is a fairly common Windows access violation error and hopefully this article will help you resolve the problems you are having:

http://www.updatexp.com/0xC0000005.html

Kind Regards

Marc Liron - Microsoft MVP