Of course Unix wasn't a single target, it was a whole family of operating systems. Linux was no more different from those Unix systems than the Unix systems from each other.
Of course, if someone steals my laptop while I'm logged in, unless he drags it away from under my hands, he'll be presented with the screen saver's password screen.
One important difference is that you can write a concept after a class that is a model of that concept is already written, and don't have to rewrite that class to refer to that concept. You just have to tell the compiler that the class fulfils the concept, and the compiler then checks whatever it can check (like existence of certain members). Of course the correct semantics cannot be checked by the compiler (nor can it be with Java interfaces). Indeed, you can even tell the compiler that a certain built-in type fulfils the requirements. Optionally you also can tell the compiler that any type fulfilling the structural requirements shall automatically considered a model (that's especially meaningful for concepts like CopyAssignable, where the semantics of the corresponding function is more or less required by the language).
Another important difference is that it is checked at compile time during template instantiation, and therefore the full type information is available. Therefore you don't get type erasure as with interfaces. Consider the poster child of generic programming, but this time with using concepts:
template<Comparable T> T max(T a, T b) {... }
On first view, this seems equivalent to the Java code
IComparable max(IComparable a, IComparable b) {... }
Bot check that the arguments are actually comparable.
However imagine you have two types which model Comparable, say Length and Velocity, and consider the following code:
Length l =...; Velocity v =...; return max(l,v).toDouble();
With Java interfaces, you'd derive both types from IComparable. At the call to max, the compiler would convert both values to IComparable, and therefore won't complain. Whether this fails at runtime depends on the details of how the types are implemented (with some bad luck, ultimately toDouble() for both types is compared, and the nonsensical comparison is not caught at all).
With concepts, you'd declare that each type models the concept Comparable. However since there's no conversion involved, the compiler will notice that the two arguments are not the same, as required by the definition, and therefore will reject the call, despite both being a model of Comparable. On the other hand, if both types are the same, the call will succeed.
Of course if you explicitly want to allow different types, you can do that, too:
template<Comparable T, comparable U> foo(T a, U b) {... }
I started programming on a ZX61 with a whole 16KB RAM (which was a BIG memory expansion pack on the back; per default it came with 1KB). With programs recorded on tape (and not very reliably). And a whopping 32x24 character display (but the bottom 2 lines were reserved for input). It had even graphics: 64x44 pixels, black&white on a TV.
The next step was learning machine code. Stored in a REM statement in the first line of the BASIC program...
Have you ever been to Germany? No? Because there are a lot of beers you won't get outside Germany (indeed, most you'll not get outside a specific small region). Equating German beer to the few big brands is like equating American beer to Budweiser.
He should have not only registered the domain, but also the trademark. Then he'd either gotten better protection (because if you can prove that you own the trademark, you should have a much better standing on such lawsuit), or he would have learned about the problem early on (namely by being refused that trademark) at a time where choosing another name was still cheap.
Microsoft Word, which is a main part of Office, was first released in 1983. Microsoft Excel, which is also a main part of Office, was first released 1985. The fact that only in 1989 they decided to market those programs together as part of a suit is irrelevant to the question of how long they were in development (indeed, I''d guess that Microsoft reused quite some code from their earlier Multiplan spreadsheet application, so it could be argued that the time of development was even longer).
Also note that development already happened before the first release (otherwise they wouldn't have had anything to release). So one can safely say that Office was more than 30 years in development.
Slashdot Mirror
Windows 95 was already Win32. The last 16 bit version of Windows was WfW 3.11.
Of course Unix wasn't a single target, it was a whole family of operating systems. Linux was no more different from those Unix systems than the Unix systems from each other.
You probably forgot to install libmalware.
Of course, if someone steals my laptop while I'm logged in, unless he drags it away from under my hands, he'll be presented with the screen saver's password screen.
So you're saying adding the repository malware.org/debian and running sudo apt-get install rootkit was not a good idea? :-)
What's troll about the above comment?
Testing? Isn't that what the customers are for? :-)
Nuke it from orbit. It's the only way to be sure.
That's completely up to the implementation.
You mean, WTL programs run without MSVCRT.DLL?
One important difference is that you can write a concept after a class that is a model of that concept is already written, and don't have to rewrite that class to refer to that concept. You just have to tell the compiler that the class fulfils the concept, and the compiler then checks whatever it can check (like existence of certain members). Of course the correct semantics cannot be checked by the compiler (nor can it be with Java interfaces). Indeed, you can even tell the compiler that a certain built-in type fulfils the requirements. Optionally you also can tell the compiler that any type fulfilling the structural requirements shall automatically considered a model (that's especially meaningful for concepts like CopyAssignable, where the semantics of the corresponding function is more or less required by the language).
Another important difference is that it is checked at compile time during template instantiation, and therefore the full type information is available. Therefore you don't get type erasure as with interfaces. Consider the poster child of generic programming, but this time with using concepts:
On first view, this seems equivalent to the Java code
Bot check that the arguments are actually comparable.
However imagine you have two types which model Comparable, say Length and Velocity, and consider the following code:
With Java interfaces, you'd derive both types from IComparable. At the call to max, the compiler would convert both values to IComparable, and therefore won't complain. Whether this fails at runtime depends on the details of how the types are implemented (with some bad luck, ultimately toDouble() for both types is compared, and the nonsensical comparison is not caught at all).
With concepts, you'd declare that each type models the concept Comparable. However since there's no conversion involved, the compiler will notice that the two arguments are not the same, as required by the definition, and therefore will reject the call, despite both being a model of Comparable. On the other hand, if both types are the same, the call will succeed.
Of course if you explicitly want to allow different types, you can do that, too:
He's quoting Mr. Scare, I think.
Perl6
So how many years remain until it's ready? ;-)
Comments are for the stuff you can't read from the code.
Bad comment:
Good comment:
I started programming on a ZX61 with a whole 16KB RAM (which was a BIG memory expansion pack on the back; per default it came with 1KB). With programs recorded on tape (and not very reliably). And a whopping 32x24 character display (but the bottom 2 lines were reserved for input). It had even graphics: 64x44 pixels, black&white on a TV.
The next step was learning machine code. Stored in a REM statement in the first line of the BASIC program ...
Have you ever been to Germany? No? Because there are a lot of beers you won't get outside Germany (indeed, most you'll not get outside a specific small region). Equating German beer to the few big brands is like equating American beer to Budweiser.
Except that the cost is probably a large multiple of the win you can get from fracking. So why would this be considered an acceptable solution?
Oh, right, because those who get the profits are not the same as those who have to pay the cost.
He should have not only registered the domain, but also the trademark. Then he'd either gotten better protection (because if you can prove that you own the trademark, you should have a much better standing on such lawsuit), or he would have learned about the problem early on (namely by being refused that trademark) at a time where choosing another name was still cheap.
Microsoft Word, which is a main part of Office, was first released in 1983. Microsoft Excel, which is also a main part of Office, was first released 1985. The fact that only in 1989 they decided to market those programs together as part of a suit is irrelevant to the question of how long they were in development (indeed, I''d guess that Microsoft reused quite some code from their earlier Multiplan spreadsheet application, so it could be argued that the time of development was even longer).
Also note that development already happened before the first release (otherwise they wouldn't have had anything to release). So one can safely say that Office was more than 30 years in development.
You needed 3 minutes to write that code?
They are termed document classes in LaTeX, not themes.
That's because Facebook wasn't written in Java. ;-)
What? You say that an application developed in 30 days is not as good as one developed in 30 years? Heretic!
I think it is much more expensive to accept Visa payments than to accept Bitcoin payments.
Knowing the weather of tomorrow already is a great advantage. Especially if that weather might include a hurricane.