theory

In the database world, we have normalisation. You can start with a design, crank the steps and end up with a normal form of the database. This is done on the basis of the semantics of the data and can be thought of as a series of design refactorings. In object orientated design, we have the SOLID principals and various other adhoc guidelines towards good design. Do you think it is possible to define the equivalent of normal forms for OO, such that a series of refactoring steps could move a procedural piece of code (or poorly factored OO design) into a correct (in some well-defined sense)

Possible Duplicate: What is the difference between a ‘function’ and a ‘procedure’? I searched online for an answer to this question, and the answer I got was that a function can return a value, modify a value, etc., but a subroutine cannot. But I am not satisfied with this explanation and it seems to me that the difference ought to be more than just a matter of terminology. So I am looking for a more conceptual answer to the question. A function mirrors the mathematical definition of a function, which is a mapping from 1 or more inputs to a value. 1 A subroutine is a general-purpose term for

I use C# ? operator when I have if-statements that affects one row and it's all good. But lets say I have this code (using classic if-statements): if(someStatement) { someBool = true; //someBools value is unknown } else { //Do nothing } This can be achieved on a one-liner by doing: someBool = (someStatement) ? true : someBool; But why can't I do something like this: someBool = (someStatement) ? true : ; //or possibly someBool = (someStatement) ? true; Is this possible in some way? If it is, is there any benefits of using one method over the other? And if not, why shouldn't you be able to do it

Given a subset of edges of a graph G = (V,E), how can we check whether it is a valid cut-set of the graph or not? Note: A cut is a partition of the vertices of a graph into two disjoint subsets. So, cut-set of the cut is the set of edges whose end points are in different subsets of the partition. I am interested to find an algorithm for this problem A simple algorithm would be to remove the suspected cut-edges from the graph, and see if you can still get from a node of a removed edge to its counterpart. If you still can, it was not a full cut. So if you remove E2 which had nodes A and D, you

People who read C.J.Date's Introduction to Database System or books of similar level should not have problems with definition of normalization and denormalization. However, memory is not what it used to be and I find myself often looking at some design and saying that it is not normalized even though I can not find which of the normal forms it is breaking. The actual example that illustrate it is: If we have relations r1 (A, B, C) and r2 (A, D) with FDs: AB->C and A->D and r1 represent detailed data, while r2 is summary of that data (in another words each instance of D is a function of values