From the BBC article:
In the 50 years of European antitrust policy, it's the first time we've been confronted with a company that has failed to comply with an antitrust decision," a Commission spokesman said. When dealing with anti-trust suits, Microsoft's tactic seems to just ignore the verdict in the hope it'll go away. The strange thing is, it actually appears to work...
Do you have proof / have you seen any example what-so-ever of a mutation being beneficial to any species? Like genes that increase antibiotic resistance in bacteria species?
Most mutations will not cause death, and will not effect reproductivity, but will cause entropy in the gene pool. The 99% overwhelms the 1%. I've read through your post several times now, and have yet to understand what you're trying to get at. The original poster already demonstrated that a even trait with only a small beneficial effect will be found in the majority of the population a sufficient number of generations down the line, and clearly the reverse would also be true. I don't see how your argument refutes that.
Another is irreducible complexity. Most functions are highly complex interdependent systems. Typically, systems that appear irreducibly complex are actually the result of systems that were performing a different function being adapted to a new usage. To prove irreducible complexity, one would have to find a biological system with components that are interdependent, and which could not have been adapted from another system. Clearly, no-one has yet succeeded in doing so.
But earlier you complained about NullPointerExceptions, which seems to be a problem with predicting values Types are just a way of restricting values. In many languages, such as Haskell and OCaml, there is no null value in the same way that Java supplies it. Instead, they have a type wrapper to provide the same functionality. In Haskell:
data Maybe a = Nothing | Just a
In OCaml:
type 'a option = None | Some of 'a
The advantage with this approach is that a value can only be "null" when placed in a wrapper. In order to call a function that does not allow nulls with this value, you first have to extract it from the wrapper, which means you have to explicitly check that the value isn't null before sending the value to the function. NullPointerExceptions are thus impossible under Haskell or OCaml, as non-nullness is checked at compile time.
Incidentally, the JVM based language, Nice, also checks nullness at compile time, so there's no technical reason why Java couldn't do this.
a (very smart) friend worked with O'Caml for a semester project and complained about trying to get the language to infer types correctly. Problems with type inference occur when the types used are ambiguous, and in such cases, have to be specified manually (and in such cases, you're no worse off than with Java). I've very rarely come across such situations, though, and I suspect it was more an error on my part than that of the language. I haven't used OCaml as much as Haskell, but I suspect the type inference systems are more or less the same.
Can you recall any specific functions he was having problems with?
"yes" and "no" are the most useless, though; they seem to pop up whenever there is a question in the summary. What if you wanted to search for an article that asks a question in the summary?:)
What Java and any other modern high level language allows for are people who aren't necessarily the best programmers to still do their jobs. Do I see you wanting to go out and build business apps, or are you more likely to make super-cool widget X? Not all high level languages are as easy to get to grips with as Java. Also, are you inferring that Java is only a useful tool for poor programmers?
It seems to me that the search system can already find articles via keywords. Tags are most useful when they add meta-information that cannot be inferred by a keyword search. Whilst it's unlikely "proofyourfuckingheadlines" is going to be useful for many people, tags like "haha" and "doh" might be conceivably useful, as they give information beyond a search for words in the article summary could provide.
But what happens in Haskell when you try to pass an argument with no sort() method? The "extends Comparable" part in the Java code catches that at compile-time, but I don't see how the Haskell version could do the same. The Haskell code is a little misleading, as it uses function composition (the . operator), which isn't found in Java. Here's the same function expanded out a bit to make it clearer:
maxN n xs = take n (sort xs)
Or, in C-like pseudocode:
maxN(n, xs) {
return take(n, (sort(xs)); }
Haskell isn't an object orientated language. The take and sort functions do not belong to any particular object. However, aside from that, the functions work more or less the same to subList and Collections.Sort in Java. In Java, you need to inherit from Comparable. In Haskell, you need to have a type deriving Ord. Same thing.
The Haskell compiler knows that xs must derive from Ord, by looking at the arguments the sort function expects. Likewise, it knows that n must be a Integer, by looking at the arguments that the take function expects. From the functions and operators referenced, it can infer the type of the enclosing function.
Apples and oranges. What is knowable at compile-time in a functional language like Haskell is not the same as what is knowable at compile-time in an imperative language like Java. There is nothing in the Java code snippet that could potentially known at compile time. Consider the following pseudocode, representing the Java example with all types removed (I'm using.clone() instead of new Vector() to that end):
The first line tells us that xs must be Clonable, and that out is the same type as xs. The next line tells us that out is at least a Collection<T>, where T extends Comparable<? super T>, and therefore xs is also a Collection<T>. The third line narrows this down further, and tells us that out is a List<T>, and thus xs is a List<T>, and that n is something that can be boxed into an int. Finally, we can deduce that the return value must be List<T>, because that's what out.subList returns.
Therefore, everything in the example can be deduced just as easily in a Java-like syntax than in a functional one.
Type inference has been around for over two decades. There are well understood algorithms for deducing type. Applying such inference to an imperative object orientated language like Java is not particularly more difficult than applying them to a functional language.
Now, duck typing in a statically-typed compiled language would be interesting. Anyone know of any examples? Boo (an OO.NET language based on Python) uses duck typing, and OCaml (a mostly function OO language) uses a variant of it as well.
Not fishing for flamewars, but what's wrong with Java's typesystem as it is? I think it's pretty good for a static typesystem.. Compared to other statically typed languages, Java's type system is extremely rudimentary, and before generics, it was positively primaeval.
For instance, take the following Java code snippet:
public static <T extends Comparable<? super T>> List<T> maxN(List<T> xs, int n) {
Vector<T> out = new Vector<T>(xs);
Collections.Sort(out);
return out.subList(0, n); }
And the equivalent in Haskell:
maxN n = take n . sort
Both Haskell and Java are statically typed, and both functions have equivalent typing, yet there is a clear difference between their respective type systems.
Not only is the Java hugely more verbose, as it lacks any sort of type inference, the type system also fails to catch null values. In Haskell, there is no equivalent of the infamous NullPointerException.
It was Microsoft's way of telling Java developers, "Hey, we've got an easy to use language with C-style formatting!" In the grand scheme of things, there was no need to create it. Microsoft and Sun seem to have different aims for their particular languages. Sun tends to be very conservative about adding new features to Java, and so Java is a comparatively basic language with a very limited feature-set. Microsoft seem to be taking a slightly different approach, adding in any feature that looks like it could be useful. This makes C# a relatively more complex and faster evolving language, and has already diverged fairly far from Java.
Now if only either language had a half-decent type system...
Performance isn't everything, but then again, when you are 400 times slower than Java... performance starts to matter. Sure, if you're interested in generating mandelbrot fractals or the spectral norm of a matrix. However, Ruby typically isn't used for such computationally intensive tasks.
Does it have rights? Does it have a soul? Many would say "No" to one or both counts. For that matter, would a fully synthetic intelligence be granted the same rights? Whether you or I think that matters is irrelevant: believe me, the controversy will never end. So, I wouldn't automatically assume "yes" to any of the above, if I were you. People who decide to upload their minds into synthetic brains would have the advantage of being able to outlive their detractors, and slavery fell out of fashion some time ago, so I suspect they'd find themselves having at least some rights. The lure of effective immortality would, I think, mean that you'd get at least some people willing to make the transfer.
Yes, creating colonies of people is important, if you consider the survival of our species important (another open question, actually.) What kind of legacy would you like to leave behind you: grandchildren or grandrobots? I know which I would prefer, but then again, I'm old-fashioned about such things. I don't see that there's any difference. If it's got the mind of a human being, why does it matter whether the body is natural or artificial?
Downloading stored human minds into a human brain will probably never be possible: human brains aren't writable like RAM, and long-term data are stored in synaptic patterns that grow over time. You're probably right, or at least, it would be easier to grow a body without a brain in it, and then attach an artificial brain to the spinal cord.
Building an interstellar vessel of any kind would be Mankind's greatest effort to date, but trying to get the people on this planet to agree upon how the AI should raise those children would be task of even greater magnitude. Cynicism aside, I think that building the interstellar vessel would probably be the trickiest part:)
Yes, but frankly I'm not interested in sending out a colony of robots. I thought the idea here was to plant colonies of people. Is a person any less of a person if their mind has been precisely simulated by an advanced computer, rather than using their original biological one?
And if creating colonies of people is really important, then any civilization advanced enough to send a ship across 10.5 light-years to another star system would have the capacity be able to assemble bodies at the other end, and download the stored minds into them.
So now we are living probably at the end of another one of those progress surges. It is understandable if we make the mistake and assume that the rate of acceleration will stay just as rapid as it has been in the last 50 years. The idea behind the singularity hypothesis is not so much that process is accelerating at an exponential rate, more that certain technologies will mean that it will do in future. The conditions the hypothesis depends upon are (a) it is possible to build computers at least as intelligent as a human being, and that (b) progress is proportional to the size of the population. (a) seems quite likely, as nature has already managed it, (b) is a more difficult to judge, but it's not a unreasonable assumption to make. Even if a doubling of the population results in only a 10% increase in technological progress, you're still going to wind up with exponential returns.
Re:We already send probes into our solar system.
on
Interstellar Ark
·
· Score: 1
And they already report back all kinds of data that the scientific community sifts through. I don't think that's the point of this. In fact, I'm not sure what the point would be of this mission, except that it isn't to send a computer somewhere, since we already do that. I thought that was the point of all space missions, manned or otherwise. Whether the computer is silicon based or a squishy ball of neurons, space travel is still all about strapping computers to rockets and firing them off into the unknown. Why should the materials the computer is made from matter?
I don't mean to be existential about this but why? We don't have a mission from God to spread and conquer. It seems a little strange how atheists are very keen to strike down the pointless values of religion, yet still believe in many aspects which have no basis. Atheism is simply the absence of belief in a god. That doesn't mean they lack belief, nor necessarily that they lack religion.
What's the goal here? After billions of years the human race is all over the galaxy, few billion years later and its all over the universe. And then what? We cling on for dear life as we exploit the last few sources of energy as black holes swallow up any traces of our fantastic achievements. Unless you subscribe to a religion, there is no ultimate goal. Everyone has their personal aims and ambitions, and trying to subscribe some overall meaning to existence is, I feel, somewhat missing the point. In the absence of an absolute authority, meaning is relative and personal.
It seems to me that there is a 4th solution, assuming that it is possible to build a computer powerful enough to simulate a human mind, and that it is possible to upload a human consciousness into such a structure. Sending a machine across interstellar distances is likely going to be significantly more practical than trying to transport billions of tonnes of habitat. You don't have to worry about setting up complex biospheres; all you need is a computer significantly robust to survive in interstellar space, and we have more experience in this field than in self-supporting biospheres.
Likewise, it doesn't seem like it'll be too many decades before we have the technology construct a computer powerful enough to simulate (to a reasonable degree of accuracy) the trillions of parallel interactions that occur every second in our brains. Figuring out a way of mapping neurons to 1s and 0s is likely to be a far more difficult problem, but it seems to me that this would be a relatively simple problem compared to creating some manner of ark-ship. Research into this is likely to be relatively inexpensive by comparison as well, as we could start by mapping brain structures of simpler animals (such as Lobsters), and then work our way up.
I suspect that when humanity does visit the stars, it'll be as lumps of silicon (or some more exotic material) strapped onto a dirty great big rocket. Ships that lug their own biosphere around with them are just too costly and complex by comparison.
I personally believe that both should be taught, with an explanation of the controversy. Sure, but not in the same classroom. Evolution is science; creationism is not.
The major problem is the use of XML. At least with HTML, the tag names were kept short. But both standards use rather long element names, often in excess of eight characters, plus eight or more namespace characters beyond that. For some of the XML element names of each format, we're looking at over 16 characters overhead! When such tags are used repeatedly, especially in a large or heavily-formatted document, a lot of space ends up being wasted. The size of the element names are largely irrelevant, since OpenDocument files are normally compressed ZIP files. Very little space is wasted.
That's easy enough to do on a system like Linux, that comes with gzip, unzip, and other decompress programs by default. But on Windows it's a massive pain in the ass. Last I checked, Windows XP could open ZIP files without any third party software. Simply changing the file extension to ".zip" does not seem a massive pain in the ass to me.
No, but saying that the distribution of non-GPL code that is not derived from any sort of GPL code, such as the binary blob of the nvidia driver, is against the terms of the GPL, and is thus illegal to distrubte (remember, kids, licenses are binding legal agreements), and so trying to force distribution developters to conform to this precept and not distribute them (the binary drivers)/is/ a bully tactic. And who, exactly, is forcing distribution developers not to distribute them? It can't be the FSF, because they don't retain copyright over the Linux source. Linus and the majority of the kernel hackers have repeatedly dismissed ideas that NVidia might be violating the license. So actually, no-one's forcing anyone to do anything.
Indeed, many Linux distros do distribute the NVidia binary blob, including Ubuntu. It's not in a default install, but it does exist in the official Universe repository.
nVidia has said that the blob contains no GPL code, and is used in every operating system they support along with a translation layer similar to the GPL part of the Linux driver. The part that interfaces with the kernel (and is derived from the kernel, which is GPL code) is licensed under the GPL. This satisfies the terms of the GPL. The blob is not derived from GPL code, and so does not have to be licensed under the GPL. It's a grey area. It depends whether the binary blob provided by NVidia counts as a "derivative work" of the Linux kernel. The people actually holding the copyright on the kernel seem to think not, so NVidia is safe to do what it wants, and likewise Linux distributes are free (from a legal perspective, at least) to do as they please.
It'd be one thing if the problems were mostly technical, because then I (and I'm sure others) would be more than willing to help out. Alas, as this and other stories show, the biggest problems are all cultural, religious, and political, and most of them will probably never be fixed. In the case of Beryl and Compiz the problems are plainly technical in nature. I don't think it'll be too long before some manner of stable hardware accelerated desktop arises for Linux, especially since it's a rather interesting problem, and development in this area is very rapid.
To me, at least, this arguement mirrors the DRM arguement. The RMS-minded software "purists" are trying to take away my right to have fully-functioning 3d capabilities on my Linux computers, much the same as the *IAA are trying to take away my rights to play my media on whatever device I wish. Please explain how software purists are taking away this right.
Both the FSF and the *IAA should stop trying to use bully tactics to get others to follow their ideals... For the FSF, this means encouraging the release of hardware specs, the development of viable alternatives to binary-blob drivers, such as the open radeon 3d driver (although even that is nowhere near truely viable, yet, although I believe it will be soon), and continuing to tell the benefits of open-sourcedness. So encouraging the release of hardware specs, developing viable alternatives and telling people about the benefits of open source count as "bully tactics"?
Slashdot Mirror
Incidentally, the JVM based language, Nice, also checks nullness at compile time, so there's no technical reason why Java couldn't do this. a (very smart) friend worked with O'Caml for a semester project and complained about trying to get the language to infer types correctly. Problems with type inference occur when the types used are ambiguous, and in such cases, have to be specified manually (and in such cases, you're no worse off than with Java). I've very rarely come across such situations, though, and I suspect it was more an error on my part than that of the language. I haven't used OCaml as much as Haskell, but I suspect the type inference systems are more or less the same.
Can you recall any specific functions he was having problems with?
It seems to me that the search system can already find articles via keywords. Tags are most useful when they add meta-information that cannot be inferred by a keyword search. Whilst it's unlikely "proofyourfuckingheadlines" is going to be useful for many people, tags like "haha" and "doh" might be conceivably useful, as they give information beyond a search for words in the article summary could provide.
The Haskell compiler knows that xs must derive from Ord, by looking at the arguments the sort function expects. Likewise, it knows that n must be a Integer, by looking at the arguments that the take function expects. From the functions and operators referenced, it can infer the type of the enclosing function.
Therefore, everything in the example can be deduced just as easily in a Java-like syntax than in a functional one.
Type inference has been around for over two decades. There are well understood algorithms for deducing type. Applying such inference to an imperative object orientated language like Java is not particularly more difficult than applying them to a functional language. Now, duck typing in a statically-typed compiled language would be interesting. Anyone know of any examples? Boo (an OO
I think it's pretty good for a static typesystem.. Compared to other statically typed languages, Java's type system is extremely rudimentary, and before generics, it was positively primaeval.
For instance, take the following Java code snippet: And the equivalent in Haskell: Both Haskell and Java are statically typed, and both functions have equivalent typing, yet there is a clear difference between their respective type systems.
Not only is the Java hugely more verbose, as it lacks any sort of type inference, the type system also fails to catch null values. In Haskell, there is no equivalent of the infamous NullPointerException.
Now if only either language had a half-decent type system...
And if creating colonies of people is really important, then any civilization advanced enough to send a ship across 10.5 light-years to another star system would have the capacity be able to assemble bodies at the other end, and download the stored minds into them.
Whilst fertilized ova are easier to transport than fully grown humans, it's still a greater transportation cost than a lump of silicon.
It seems to me that there is a 4th solution, assuming that it is possible to build a computer powerful enough to simulate a human mind, and that it is possible to upload a human consciousness into such a structure. Sending a machine across interstellar distances is likely going to be significantly more practical than trying to transport billions of tonnes of habitat. You don't have to worry about setting up complex biospheres; all you need is a computer significantly robust to survive in interstellar space, and we have more experience in this field than in self-supporting biospheres.
Likewise, it doesn't seem like it'll be too many decades before we have the technology construct a computer powerful enough to simulate (to a reasonable degree of accuracy) the trillions of parallel interactions that occur every second in our brains. Figuring out a way of mapping neurons to 1s and 0s is likely to be a far more difficult problem, but it seems to me that this would be a relatively simple problem compared to creating some manner of ark-ship. Research into this is likely to be relatively inexpensive by comparison as well, as we could start by mapping brain structures of simpler animals (such as Lobsters), and then work our way up.
I suspect that when humanity does visit the stars, it'll be as lumps of silicon (or some more exotic material) strapped onto a dirty great big rocket. Ships that lug their own biosphere around with them are just too costly and complex by comparison.