Cornell has quotas currently, though they tend to be along the lines of "don't be in the top 1% of bandwidth usage when things get tight, or we'll cut you down". The difference is that here you can get pretty much as much bandwith as you want, if you're willing to pay.
This is quite true. I was a member of a focus group on this idea, and they said that use of the internal campus network was consistently at about 2% of capacity. External capacity has hit 100% in the past, causing them to limit Resnet traffic to a certain percentage of capacity. They would be quite happy if file-sharing were more internal. (Happy, that is, to the extent allowed by law. Cornell complies (somewhat grudgingly) with the DMCA.)
and the one to which "kt" refers is described here. Truly ingenious. Even looking at every part of the source yourself can't protect you in a case like that.
I once disliked Java for that very reason, but I have since realized that enum is not as essential as you might think in an object-oriented language. Basically the main purpose of enum in a language like C is to provide support for polymorphism. (Please forgive any syntax errors or the like in the following, it has been a long time since I've written in C.) If you were writing a calculator along the lines of dc or whatever, you might have at some level:
struct expr { enum type {NUM, OPER}; enum binop {PLUS, MINUS, TIMES, DIVIDE}; type t; union { enum binop b; double value; } data; struct expr *left; struct expr *right; }; double evaluate(struct expr *e) { if (e->t == NUM) return e->data.value; switch(e->data.b) { case PLUS: return evaluate(left) + evaluate(right); case MINUS: return evaluate(left) - evaluate(right); case TIMES: return evaluate(left) * evaluate(right); case DIVIDE: { int x; x = evaluate(right); if (x == 0.0) return 0.0; return evaluate(left) / x; } } } void print(struct expr *e);/* an analogous recursive function */</ECODE>
Now, I would argue that this is pretty ugly in and of itself; beyond aesthetics, though, it also leads to bugs. Suppose you later add to your calculator an exponentiation operator. You call it whatever you like in the enum, and add it as one of the statements in the switch. You compile and the evaluation still works fine, but when try printing the original expression you print nothing or crash. Oops, you forgot to add the operator to the print function... In a big enough program, you invariably forget to make the change somewhere that is not tested. A bigger problem of the same kind lies in the way you are handling different types of expressions. Suppose you decide to add variables to the language. If you don't change evaluate, you'll treat the data member as a binop (rather than as a variable) and end up doing random unpleasant things. Contrast that example with this one in Java:
abstract class Expression { public abstract double evaluate(); public abstract void print(java.io.PrintStream s); } class NumericValue extends Expression { public NumericValue(double value) {v = value;} public abstract double evaluate() {return v;} public abstract void print(java.io.Printstream s) {/*...*/} double v; } abstract class Binop extends Expression { public Binop(Expression left, Expression right) { l = left; r = right; } public void void print(java.io.PrintStream s) { s.print(l); s.print(this.toString()); s.print(r); } Expression l; Expression r; } public class Plus extends Binop { public Binop(Expression left, Expression right) { super(left,right); } public String toString() { return "+"; } public double evaluate() { return l.evaluate() + r.evaluate(); } } /* et cetera */
It's more lines of code, I'll grant that. But it's also considerably easier to maintain. Useful commonality is much easier to factor out, with the print function here for instance. And if you forget to write evaluate() for some class, the compiler will complain about it. You give the examples of java.awt.Color and java.util.Calendar. Take another look at Color. The constants defined there are actual Color objects, not just ints. You can't pass 8675309 to a function that expects a Color object, as you sometimes can with C-style enums. In fact, an enum wouldn't be very useful here, as a Color seems to be in essence a 4-tuple. You *could* possibly have an enum that just defined those several colors and handled them specially from a standard 32-bit color, but this would be somewhat inefficient. Having a constant in a class like Color does allows the constant to be initialized when the class is loaded and thereafter treated as any other Color is treated. Calendar, on the other hand, is just a very bizarre class altogether. One advantage an enum can have over inheritance that I didn't address here is the ability to use numerical properties of the enumerated type. For instance, you can have a for loop over all types, or define a set of properties that you can use binary operations on.
In most of Europe, the broadcasting laws allow only child-friendly programming during the day, but pretty much anything (sometimes porn) at night. I assume that's what they're referring to when they say "watershed".
Now that I look at it again, I wonder what exactly a "means for generating the test" is. Suppose you had a Java applet on the client, and you sent it some data, the order of which the applet then randomized; which computer would be "generating" the test then?
Re:Breadth: Doesn't cover all online tests
on
Online Testing Patented
·
· Score: 2, Interesting
In claim 13:
wherein a test-maker and a proprietor of the first computer share the revenues generated by the test-taker taking the test.
There must be at least two parties making money of the testing. The first being the test maker and the second being the person who owns testing computer.
Wouldn't this also mean that a test taker using his own computer would be exempt?
In my local paper, they replaced your column with one about sex. Have you considered the possibility of broadening your appeal by including weekly advice on cunnilingus?
My solution is to have one password for most of my accounts, which I share with nobody.
This is a pretty bad idea for anything with a security level you actually care about, because if one password is cracked (which can come about through a variety of ways) all of them are.
I believe cond is older than if, being part of the original syntax of Lisp. (This is back in the day when programs were written in a different language than data.)
The Y operator has an essential function in that it is the only way to have recursion in pure lambda calculus. If you've ever tried to write an interpreter for a functional language, you run up against the problem that a recursive call essentially forces you to refer to the function before it is defined. So one way of doing it is to put in a pointer to nothing, and later modify it to point to the function itself. But assignment is annoying because it is temporal (see chapter 3 of SICP for more).
Also see this lecture, which does about as good of a job explaining Y as can be.
To answer your question about the modification of control structures:
The language that comes closest to what you want is probably Scheme. This is because the language is extremely small, and the syntax is trivial. The level of freedom the language gives you is such that you are not able to tell whether the form "if" is implemented as part of the "language" (whatever that means) or as a procedure in the same way any user could write it.
I didn't really see anything like the description implied at the linked site. The only way in which their algorithms became more complex was by assuming the people walking around could store a fair amount of state and perform arithmetic, branching, and repetition - in short, the people were Turing devices themselves.
I am going to think some more about some constraints that could be put on the problem so that it becomes more interesting.
Debatable. I go to Cornell, and I think of Princeton and Cornell as roughly equal in engineering, and significantly different from the rest of the Ivy League. I have a CS-centric view of things though.
Penn is certainly not a bad school for anything, and Penn State is respectable for engineering. I think of their engineering programs as roughly equal.
Disclaimer: I go to Cornell.
Blind adherence to the rankings is stupid. The main reason why Cornell's rating is relatively low is that a significant number of classes have more than 50 students, and according to US News & World Report, this is BAD. Apparently it is always better to have 10 classes of 30 students rather than one class of 300 students, regardless of teaching style.
My personal experience has been that classes taught "in parallel" are on average not taught as well. Given ten professors (or TAs, as is more likely the case), all of them would teach the class if the lecture sizes were small, but only the best one would teach the class if there were one lecture. In addition, there are communication and coordination problems, because everyone has to cover the same curriculum.
The factors that make someone choose one school instead of another are varied and complex. I did not even apply to Penn because I wanted to go to school at least a hundred miles or so away.
Evidently moderators go into Godwin mode at the mention of Hitler. The point of that post was to show that the argument "x caused y, and y is good, therefore x is good" is stupid.
Slashdot Mirror
Cornell has quotas currently, though they tend to be along the lines of "don't be in the top 1% of bandwidth usage when things get tight, or we'll cut you down". The difference is that here you can get pretty much as much bandwith as you want, if you're willing to pay.
This is quite true. I was a member of a focus group on this idea, and they said that use of the internal campus network was consistently at about 2% of capacity. External capacity has hit 100% in the past, causing them to limit Resnet traffic to a certain percentage of capacity. They would be quite happy if file-sharing were more internal. (Happy, that is, to the extent allowed by law. Cornell complies (somewhat grudgingly) with the DMCA.)
and the one to which "kt" refers is described here. Truly ingenious. Even looking at every part of the source yourself can't protect you in a case like that.
ELC platform spec will expand use of EPSWEUOE
Suddenly there is a use for those things!
No, it was because everyone already knows that bind handles DNS lookups.
I once disliked Java for that very reason, but I have since realized that enum is not as essential as you might think in an object-oriented language.
/* an analogous recursive function */</ECODE>
Basically the main purpose of enum in a language like C is to provide support for polymorphism. (Please forgive any syntax errors or the like in the following, it has been a long time since I've written in C.) If you were writing a calculator along the lines of dc or whatever, you might have at some level:
struct expr {
enum type {NUM, OPER};
enum binop {PLUS, MINUS, TIMES, DIVIDE};
type t;
union {
enum binop b;
double value;
} data;
struct expr *left;
struct expr *right;
};
double evaluate(struct expr *e) {
if (e->t == NUM)
return e->data.value;
switch(e->data.b) {
case PLUS:
return evaluate(left) + evaluate(right);
case MINUS:
return evaluate(left) - evaluate(right);
case TIMES:
return evaluate(left) * evaluate(right);
case DIVIDE:
{
int x;
x = evaluate(right);
if (x == 0.0)
return 0.0;
return evaluate(left) / x;
}
}
}
void print(struct expr *e);
Now, I would argue that this is pretty ugly in and of itself; beyond aesthetics, though, it also leads to bugs. Suppose you later add to your calculator an exponentiation operator. You call it whatever you like in the enum, and add it as one of the statements in the switch. You compile and the evaluation still works fine, but when try printing the original expression you print nothing or crash. Oops, you forgot to add the operator to the print function... In a big enough program, you invariably forget to make the change somewhere that is not tested.
A bigger problem of the same kind lies in the way you are handling different types of expressions. Suppose you decide to add variables to the language. If you don't change evaluate, you'll treat the data member as a binop (rather than as a variable) and end up doing random unpleasant things.
Contrast that example with this one in Java:
abstract class Expression {
public abstract double evaluate();
public abstract void print(java.io.PrintStream s);
}
class NumericValue extends Expression {
public NumericValue(double value) {v = value;}
public abstract double evaluate() {return v;}
public abstract void print(java.io.Printstream s) {/*...*/}
double v;
}
abstract class Binop extends Expression {
public Binop(Expression left, Expression right) {
l = left;
r = right;
}
public void void print(java.io.PrintStream s) {
s.print(l);
s.print(this.toString());
s.print(r);
}
Expression l;
Expression r;
}
public class Plus extends Binop {
public Binop(Expression left, Expression right) {
super(left,right);
}
public String toString() { return "+"; }
public double evaluate() { return l.evaluate() + r.evaluate(); }
}
/* et cetera */
It's more lines of code, I'll grant that. But it's also considerably easier to maintain. Useful commonality is much easier to factor out, with the print function here for instance. And if you forget to write evaluate() for some class, the compiler will complain about it.
You give the examples of java.awt.Color and java.util.Calendar. Take another look at Color. The constants defined there are actual Color objects, not just ints. You can't pass 8675309 to a function that expects a Color object, as you sometimes can with C-style enums. In fact, an enum wouldn't be very useful here, as a Color seems to be in essence a 4-tuple. You *could* possibly have an enum that just defined those several colors and handled them specially from a standard 32-bit color, but this would be somewhat inefficient. Having a constant in a class like Color does allows the constant to be initialized when the class is loaded and thereafter treated as any other Color is treated. Calendar, on the other hand, is just a very bizarre class altogether.
One advantage an enum can have over inheritance that I didn't address here is the ability to use numerical properties of the enumerated type. For instance, you can have a for loop over all types, or define a set of properties that you can use binary operations on.
In most of Europe, the broadcasting laws allow only child-friendly programming during the day, but pretty much anything (sometimes porn) at night. I assume that's what they're referring to when they say "watershed".
Now that I look at it again, I wonder what exactly a "means for generating the test" is. Suppose you had a Java applet on the client, and you sent it some data, the order of which the applet then randomized; which computer would be "generating" the test then?
In my local paper, they replaced your column with one about sex. Have you considered the possibility of broadening your appeal by including weekly advice on cunnilingus?
Will it be patched to work in space?
The Y operator has an essential function in that it is the only way to have recursion in pure lambda calculus. If you've ever tried to write an interpreter for a functional language, you run up against the problem that a recursive call essentially forces you to refer to the function before it is defined. So one way of doing it is to put in a pointer to nothing, and later modify it to point to the function itself. But assignment is annoying because it is temporal (see chapter 3 of SICP for more).
Also see this lecture, which does about as good of a job explaining Y as can be.
(if a b c)
can be thought of as syntactic sugar for
The language that comes closest to what you want is probably Scheme. This is because the language is extremely small, and the syntax is trivial. The level of freedom the language gives you is such that you are not able to tell whether the form "if" is implemented as part of the "language" (whatever that means) or as a procedure in the same way any user could write it.
I am going to think some more about some constraints that could be put on the problem so that it becomes more interesting.
Debatable. I go to Cornell, and I think of Princeton and Cornell as roughly equal in engineering, and significantly different from the rest of the Ivy League. I have a CS-centric view of things though. Penn is certainly not a bad school for anything, and Penn State is respectable for engineering. I think of their engineering programs as roughly equal.
Disclaimer: I go to Cornell. Blind adherence to the rankings is stupid. The main reason why Cornell's rating is relatively low is that a significant number of classes have more than 50 students, and according to US News & World Report, this is BAD. Apparently it is always better to have 10 classes of 30 students rather than one class of 300 students, regardless of teaching style. My personal experience has been that classes taught "in parallel" are on average not taught as well. Given ten professors (or TAs, as is more likely the case), all of them would teach the class if the lecture sizes were small, but only the best one would teach the class if there were one lecture. In addition, there are communication and coordination problems, because everyone has to cover the same curriculum. The factors that make someone choose one school instead of another are varied and complex. I did not even apply to Penn because I wanted to go to school at least a hundred miles or so away.
I thought only dead rappers could make new material.
Maybe we won't see the PlayStation 5 after all.
A paper about genetic algorithms, written by a guy named Gene.
Evidently moderators go into Godwin mode at the mention of Hitler. The point of that post was to show that the argument "x caused y, and y is good, therefore x is good" is stupid.
it weren't for MS, we would still be paying an arm and a leg for PCs.
Okay, but if it weren't for Hitler, the digital computer might never have been invented.
You can make this possible in the US, too, by donating to moonthewhitehouse.com.