It runs fine on my GNU/Linux system though. The trouble with flash is that there was no free (as in freedom) flash plugin. However, I guess our friends at the FSF can point you to a project that is working on just that.
First off, sorry for answering to this piece of flame-bait, but I rather to try answer it decently, before the flames are all you see.
Where are the ideas about possibly allowing software patents in a limited form? I think it would be reasonable if things like compression algorithms (LZW, MP3) were allowed for like 5-8 years.
5-8 years is very very long time. Imagine if all the people that use Free software and/or Open Source software had to wait 5-8 years to listen to mp3-music, for instance! Not because they would have to pay for a mp3-player, but because it might be illegal to have one in the first place!
Look at copyright, it has been limited for a given number of years, but big companies like Disney keeps pushing the limit. Every time the copyright on Micky Mouse(tm) was about to expire, the limit on copyright has been extended. I don't believe that it is reasonable to expect it would be different for software patents.
I don't think innovation in the software business depends on patents, on the contrary, with the number of patents, its a minefield to develop software, so it hinders new innovators. Even with limited patents, it would still be hard for new innovators.
I don't believe that its very likely a limit on software patents would have any significant effect. In the EU, 40 000 patents were issued - even though software patents were illegal!
Spending my energies in duplicating the functionalities in another OS because of some stupid law is rediculas to me.
You are missing the point. Since MS-Windows split from OS/2, maybe even before that, it has been a copycat. If you doubt that, look at sunview, Mac OS or any other GUI that predates MS-Windows.
If we look at features of the GUI, I don't think you will find many features of MS-Windows has, that didn't or doesn't exist for other OS's. On the other hand, I think you will find many features that MS-Windows do lack, like "focus follows mouse", "vertical or horizontal maximise", "virtual desktops", etc. etc.
In many ways, MS-Windows is still long behind The X Window System, and no wonder. X started well before MS-Windows 3.1 was started, and has evolved continuously. Contrary to MS-Windows, most of the platforms that runs the X Window System doesn't have to deal with old 16-bit code, neither in emulation or any other way. (In other words, the command-line always is and always was on the same level as the GUI, unlike MS-Windows).
What bothers me most about MS-Windows or any other non-free OS, is this: They do not give me the freedom that a GNU system gives me. However, even if you don't want freedom my friend, you still have the freedom to let Microsoft chain you.
A general remark: The most important lack of MS-windows IMHO, is not the technical flaws or the great lack of advanced features, but rather that it is not free for all to change the source code, give changes to a friend, or even sell an enhanced specialised version. Even though it wouldn't harm you to burn a copy of the software, in many countries it is not even legal to let your friends copy the software verbatim. In other words, even if you paid a lot of money for the software, you are not allowed to do much with it. Often the license doesn't even allow you to install the program on more than one computer at a time.
Some may argue that this point is void, because they don't care about the law, and copy the software illegally, as there is little or no effective copy protection in existence today. Even if you do not consider this point flawed in its design, as I do, you still risk punishment and it seems very likely that copy protection will improve in the future.
Microsoft Windows lacks to be what the GNU Project has chosen to call "Free Software", which unfortunately due to a flaw in the English language let you believe that it is focused on no price.
GNU/HURD, GNU/Linux, OpenBSD and others are already "Free Software", which means you have a lot of freedom to do pretty much what you want with it. Some of the software, however, has a licence that restricts you from reducing this freedom for other people.
The reason Microsoft hates the "GPL", is that they want to make more money by restricting the freedom for people. The GPL does not allow them to do this. In this way, I find the GPL superior to many other licenses.
For this reason, many will argue that Microsoft and similar companies are evil. The point is however, that they make money acting the way they do. The only way this can change, is if they stop making money this way, or if they begin to make less money this way. One way to stop that, is to stop using their products, a thing I find very easy to do.
If you want to study what "Free Software" really is, and maybe find out why we are so many feels that it a wonderful thing, I guess the GNU Project web server is a good starting point.
What little game playing I do is handled just fine by the PS2. All of my development work is handled just fine by free editors, compilers, debuggers, and other tools (including embedded operating systems). The argument that I'm sacrificing some measure of usability or productivity in exchange for freedom is simply false in my case -- I'm getting the best of both worlds.
Just to mock you a little in a friendly way - I didn't know there were free (as in freedom) games for the PS2.:-P
This is not the way free/open source software should
be approached, IMO. Nobody is going to make much money by trying to
sell something that users can get for free. You can sell a service
based on the software but that's about it.
I don't think you intended to imply that Free Software or
Open Source software is
always free of charge. I'll make the point anyhow, just in case
someone misreads it. I am sure there is somebody who wants to read About
Free Software.
While it is often true that its usually easy for users to get Free
Software for no charge, it doesn't have to be like that.
A hypothetical example:
I might write a peace of software, that I chose to distribute for a
fee, but distributing it under the GNU General Public
License. Now, while you might get it for free, it might be hard.
My customers might not wanna give it away something they paid for in
full for no fee, or maybe you don't even know who to ask.
Eventually my customers might be selling the software cheaper than
I am, and I'll have to compete, maybe adjusting my price down, selling
support and the like to the end-users, but if I already sold enough
software to pay for my work when this happens, why be sad? A lot of
users will be using my software and will learn that my software is
good quality, which again will make it easier to sell them my next
product, ensuring me butter for my bread.
If you want to read more about selling Free Software, you might
want to read the article Selling Free
Software, it has even been translated
to several languages.
Dude, saying "Java isn't slow" doesn't make it run any
faster on the 5 different machines I have.
Well, personally I think I made more than one argument as to why I
think that Java being slow is a myth. I even provided links to
benchmarks and articles analysing the performance of Java.
It seems to me that you're simply biased against Java. I dunno if
you really have 5 different machines running applications of poor
performance, but mind you, it is possible to write slow code in just
about any language - even Java!
If I got it wrong, and you're really sad about the performance of
your Java applications, maybe you want to take a look as these Java
performance FAQs in order to try and improve the performance of
these applications.
I never understand claims like this. The advantage of Java's GC boils
down to not having to write delete p; when you're done with something
allocated dynamically. Since most variables in C++ aren't allocated
with new anyway, and even in the occasional code where they are you
usually use RAII to avoid the overhead of deleting them manually, how
on earth does productivity double in Java?
I wont comment on whether Java is more productive than C++, I don't
know about that, but the gain of the garbage collector cannot
be reduced to you not having to write delete p; or whatever
your language of choice wants you to write. As I mention in another
post on this topic, one of the reasons that Java is performing
well these days, is that the garbage collector makes memory allocation
cheap. In a language without Garbage Collection, you generally have to
either create something like an "object pool", or pay for expensive
calls to the OS in order to allocate memory.
Another benefit of the garbage collector is that you generally
don't have to "pay", if you "accidently forget" to delete an object.
Actually, to my knowledge, you cannot free objects in Java, save
dereferencing memory (object = null;). Now, its no silver bullet
either, but actually Java programmers does suffer much less than
programmers without a garbage collector (or similar tool, RAII?) from
having to debug memory leaks. A man with a spoon, and a man without a
spoon might both be able to eat soup, but the man with the spoon
might do better! (So maybe the real issue is whether you have a tool for
memory).
I am happy to see a post that while critical towards Java, doesn't
mention performance. I guess its becoming more widely known that
Java doesn't have the performance issues that it had back in 1995.
C is ancient and crude. Java is a padded cell and
straight-jacket. There is a middle ground.
I will not comment on your view on C, and hopefully no-one else
will, lest we want to see a full scale (OT) "language war".
When it comes to Java lacking multiple inheritance, I have never
written much code in any language where multiple inheritance was
possible, so I dare not comment much on this. However, I want to
mention that Java has the "interface"-thing, that makes it possible
to do at least some of the things you generally want to do with
multiple inheritance.
So, for the rest of this post, I will assume that your point is
that for you, Java is uncool because the compiler seems rather
pedantic to you.
I need to comment on this, since I code Java on a daily basis and
have a different experience. While its true that the Java compiler
from SUN seems rather hysterical when you first start out with Java,
the reason for this is the same as the reason that parents is usually
very concerned about whether their child/children checks for traffic
before crossing a road.
Now, 9 out of 10 times (it seems like more) when the Java compiler
keeps complaining about '<identifier> might be uninitialised error in
<line number>', I'm very happy about it the 10th time, where I
actually forgot to initialise the variable. That being said, I often
just initialise my variables early, to avoid this, but then again,
then they *are* initialised.
Some prefer to manage stuff like this themselves, "Its not the
business of a 'stupid compiler' how I write my code!", for them, C++
or even C might be a better choice. (Of course, sometimes you choose
the language for the task, but both C, C++ and Java are all general
purpose languages). Me? Well, I got used to Java, and I get much less
problems with the compiler nowadays, I guess its become somewhat a
challenge to write the code so that the compiler "eats it" as it
is. Oh, and yes, I *do* enjoy having a garbage-collector to pick up my
trash for me.
Sorry, when trying to preview the unfinished post, I hit submit by
mistake. I hope the post still makes sense, it was almost done, but I
like to read what I post a few times, before I post, just to make sure
its how I want it to be.
I agree with much of what you wrote, I realise that I in fact did
overplay the significance of JIT having runtime knowledge. I wanted
to stress the fact that Java isn't simply an interpreted language, not
even when you use the JVM from Sun.
The most important point of my post, though, is that "Java isn't slow"
anymore. When I first got to know Java, it was dreadful slow. Now,
its comparable to C++, and in some cases even faster, and has the
potential to be even faster. Now, all this fuss about performance has
really nothing to do with the Java-language, but has to do with the
Java-platform, its not unrealistic to write a compiler for C that
generates Java-bytecode for the Java-platform, but the point is that
the Java-platform today proves that it does in fact work, that it
doesn't slow performance, as seen in early stages. It has its
strengths and weaknesses.
One point I must make though, is that in my opinion, JIT is not the
single key that Java has reached the performance of C++. Of course,
JIT _does_ help a lot, esp. in CPU intensive code, but there are other
factors as well. One really important point, is that Java Bytecode
applications can allocate memory very cheap, as explained in my
previous post.
That being said, lets discuss JIT a little...
Now, C compilers have 20+ years of experience with things like loop
unrolling, eliminating common subexpressions, yada yada. C++ compilers
have a somewhat harder job because the language is more complicated,
but are rapidly catching up. Java's been way behind the pace for
years, and JIT allows it to level the playing field somewhat, since
it's finally running as a compiled rather than an interpreted
language.
(Just for the record):
Its naive to assume that the cost of JIT is free, but its also naive
to assume that Java compilers would not benefit from the last 20 years
of experience on C compilers. The Java compiler from SUN is able to
optimise the bytecode as well AOT as well as optimise the bytecode
with JIT.
Your analysis on when JIT is beneficial, is very good, I do have a few
notes though:
Now, if you're talking about an application that runs the same few
subroutines thousands of times on similar data, it might be worth the
overhead, but for most code, that simply isn't the case.
I don't think that this pose a real problem. The point is that
"Most code", doesn't need much CPU, and thus the overhead of the JIT
profiling, won't matter much, whereas the bonus from JIT-compiling
critical code in CPU-intensive code will be a great gain for the JVM.
In C, when you write CPU-intensive code, you usually hint the
compiler about optimising, in one way or another, since you know which
code you want to be optimised. You may "inline" some code, ask to get
an index variable kept in a register, and compile with flags / options
like "-funroll-all-loops", "-funsafe-math-optimizations" and
others. Usually, these hints will make the compiler able to make as
good decisions as any JIT would be able to.
On the other hand, if you write CPU-intensive code, without paying
attention to micro-optimising, chances are that the JIT-enabled code
will run slightly faster (given the same algorithm, of course). With
todays speed of CPU's, Code that is not CPU-intensive, will often seem
to run at equal speed, from the users perspective, whether its
interpreted or (JIT)compiled. (Even though they might actually be
faster in the AOT code).
Here is an example
where the JIT compiler seems to slow down the code, and how to mend
that. Note that this type of code is very rarely seen in actual real life
programs.
If we talk about really micro optimising code, I guess you would
want to either write the code in assembler, or be really creative
about how you optimise your code. As I mentioned in my first post on
this subject, Java can also be compiled with AOT compiles! Another
possibility, if you know that C is faster (or already have the
optimised code in C source), is to use JNI (Java Native Interface),
that lets you call native code. Note that this will of course
invalidate any claim as to be "Pure Java" code.
Thank you for the input, its always nice when people provide
arguments instead of merely saying "I disagree", or even "you're
wrong", like seen in other posts here on/.
Without getting into more technical detail, than I can manage right
now, I have a few comments on your post.
Mybrid wrote:
So a level of indirection is free?
Java -> VM -> system call C -> system call
What computer science class teaches this? There is no such thing as a free lunch.
Lemme start pointing out, that your argument stands, for Java JVM's
around 1995, which is still used in some older browsers, to interpret
applets on websites. That being said, I want to make a few
corrections to bring us up to date:
Java HotSpot JVM, is a not only an interpreter, its also a
compiler; a JIT compiler. A JIT compiler is a Just In Time compiler,
which means that it runtime discovers which code needs
optimising the most, and then compiles it. The JIT compiler usually
uses a cache on the disk, so when it has run your program once or
twice, it has already compiled the stuff that needs it. Thus, your
programs gets faster by use.
In case of C, its by far most common to use an "AOT-Compiler". AOT
== Ahead Of Time compiler, a compiler that produces bytecode or
machinecode from sourcecode, like Java or C. The bytecode in C's
case, is usually platform-dependent machinecode, while Java is
generally transformed into "Java bytecode", which will then be taken
care of by a JVM. Note: There is nothing hindering a compiler
transforming C-code into Java-Bytecode, or Java-code into machinecode.
In fact, as I pointed out earlier, there are more than one
AOT-compiler available for Java, Excelsior JET even offers a "Mixed
Mode", where most of your code will be compiled to machinecode, and
code that for one reason or another isn't convenient to compile, is
interpreted, and/or JIT-compiled).
Step 3: Machinecode -> System call. (Some code will be interpreted by the JVM)
C: ===
Step 1: C source -> AOT Compiler, with AOT optimising -> Machine code
Step 2: - Nothing, we already have the machine code -
Step 3: Machinecode -> System call
While you might be a very efficient C programmer, and write fairly
good optimised code, its not like that for all programmers. Esp. when
working against the clock, many tend to write code that might be a bit
sloppy, but "does the job". This is where Java in my opinion really
has an advantage: The compiler is a "JIT" (Just In Time) compiler,
which means the code is compiled while its running, and further more,
only code that the VM assumes is worth it, will be compiled. What is
really interesting here, is that the compiler at this point will have
runtime knowledge of the program, something a common C compiler
wont have. This enables the compiler to optimise better, utilising the runtime info. (Which loops are heavy-duty, and should be unrolled, which loops are merely used, etc.).
Now, I wont make the claim that really well written C-code,
optimised in every corner, and compiled for the specific platform
where the code will run, is slower than Java. In fact, I'll assume
that it will in general terms be faster, depending on the task (as I
mention in my earlier post, memory allocation is generally cheap in
Java, but of course, you could optimise C for this as well, even
though it might be quite a dazzle.) The point is, you might gain very
little from a great effort in C, since you might have to emulate the
advantage of having a clever garbage collector making memory
allocation cheap! (Read the next section for details!)
One of the reasons that some consider Java uncool, is because of
the myth that Java is slow. I call it a myth, and I will try to
explain why it is a myth. (Actually, in theory, Java will outperform
C++ soon).
Just to take a swing at another myth, while we're at it: When it
comes to size of the stack, how you want the garbage collector to use
memory etc., you CAN in fact give the JVM parameters to control this
stuff.
Java isn't slow anymore. It may be true, that (small) Java
applications generally takes a little longer to start up, if you
didn't use an AOT compiler (like for instance the "free
as in freedom" compiler GCJ or the more mature
but proprietary Excelsior JET). Its
true that early versions of Java were slow, but 1.4.x isn't
generally slower than C++, in fact, I wouldn't be surprised if it
outperformed C++ on general terms one of these days.
One of the things that makes Java "not slow", is actually the way
memory is allocated. Its rather cheap to allocate memory in Java,
compared to other languages, and its even cheaper to "free" memory,
since you don't do it, you have the cost of the garbage collector
instead. The garbage collector in Java is very fast, compared
to older garbage collectors.
(For the interested, IBM has an article
on "garbage collection in the HotSpot JVM", and another article that
explains various garbage
collection techniques, and finally they have an article that covers performance concerning garbage collection.
They have a lot of other interesting articles, but I don't want to
list all I know, if you like to check it out, here is the search
I used to "refind" these articles.)
I make the claim that Java isn't slow, but don't just take my
worth for it. (Not that I think you would). Go search on google
or whatever. A word of warning though.. since older Java's were
indeed slow, do note the version of the Java tested. It should be (at
least) 1.4.x. I don't think 1.5.x is stable yet and I dunno if its
faster or slower, but 1.4.x have a real nice enhanced garbage
collecting subsystem. (Esp. 1.4.2 and above).
(On purpose, I didn't go for SUN benchmarks, as they might be
(considered) biased, but sun does have a word to say about "Java Performance".)
Here is a couple of quotes from an article
that considers performance of Java vs. C++, analysing some benchmarks
of Java, C++ and other languages. While the article was updated this
year, I was still unable to find a link to a benchmark diagram of the
current 1.4.x JVM. It seems though, that the 1.3.x wasn't too slow,
even without latest optimised GC-subsystem, which is one of
the key factors that makes 1.4.2 faster.
Here are the quotes:
"Five composite benchmarks listed below show that modern
Java has acceptable performance, being nearly equal to (and in many
cases faster than) C/C++ across a number of benchmarks."
"Java is now nearly equal to (or faster than) C++ on
low-level and numeric benchmarks. This should not be surprising: Java
is a compiled language (albeit JIT compiled)."
This "virus"
seems to me more like a like a Trojan
horse, and it seems that the "SM(S)-feature" of this "Trojan horse"
was build into the game originally, so this particular incident is far
from typical. That being said, I think the OS pretty much does
matter in this case, to quote the article:
"The virus only works with the Symbian Series 60's OS.."
If you've been paying careful attention you will have noticed that
there has been no mention of any mechanism to prevent the traffic
from continuing on to its intended destination, i.e. the IP address
the server was using to route the traffic to the client machine. The
answer is that noiptun has no way to handle this issue and it must
be dealt with through other means if deemed important enough. Some
of the ways this can be solved is by creating an appopriate Hogwash
or inline Snort rule to drop the traffic, using firewall rules to
filter the traffic is also possible. Please note however that
noiptun makes no attempt to deal with this issue whatsoever and
it's up to you to make sure the traffic is dropped and doesn't
waste unnecessary bandwidth.
No, the release was not delayed so that security fixes could be put in it. The release was delayed, but the security fixes in it, are not related to the cracking of the Debian file servers. Some rumors say the reason was password compromise, but I still don't know for sure what the reason was.
Anyway, the delay was that when you get your file servers cracked, its should be your first priority. They had the release ready before they were cracked.
Click to get more (recent) information about the crack/compromise.
I see it happening, how could Microsoft Windows pull it off in the long run?
An article on CNet news.com suggests that "Open Source" is
catching on in China.
Now, how many people live in China? Computerworld has an article on how Red Flag GNU/Linux which I think is widely used in China, is now going international.
A majority of people might be stupid for a short period of time,
but I don't think the majority of people will be stupid in the
majority of time, at least not when it comes to wasting money for
nothing.
Now I know that some will argue that you get some value from Windows,
I wont deny that, if they think they get value, they *get* value, either
imagined value, real value or both. My point being that whatever you
can do with any commercial program, you can do with (potential) free software, and
you can do it freely!
Microsoft Windows(TM) might be able to run on
intel emulation, that will allow Microsoft
Windows to run on it, but frankly, who cares
except Microsoft, Intel, AMD and maybe a few
others?
If windows doesn't port to this processor, I am
sure some other OS will take over, and everything
will be rewritten for that OS. Alternately, you
might go with an existing OS easier to port, like
Mac OS, NetBSD or GNU/Linux. (URLs in the of
this post)
A silly OS and its platform dependence isn't
gonna stop development that much.
Kind regards,
/Spam .
URL's for possible alternatives goes here, I
am sure I miss a lot of them:
Some will charge you for GNU/Linux, and give you
support or written manuals, silver-CDs or
something in return. I probably missed a lot of links, but to mention some of the commercial distributions I missed, here
is a comparison on
price.
Slashdot Mirror
Facebook is not hosted in Europe, and therefore not governed by EU law.
It runs fine on my GNU/Linux system though. The trouble with flash is that there was no free (as in freedom) flash plugin. However, I guess our friends at the FSF can point you to a project that is working on just that.
I didn't think you intended it as flamebait. I guess I should have made that clear, but it sure could have baited some flames.
/Spam .
First off, sorry for answering to this piece of flame-bait, but I rather to try answer it decently, before the flames are all you see.
Where are the ideas about possibly allowing software patents in a limited form? I think it would be reasonable if things like compression algorithms (LZW, MP3) were allowed for like 5-8 years.- 5-8 years is very very long time. Imagine if all the people that use Free software and/or Open Source software had to wait 5-8 years to listen to mp3-music, for instance! Not because they would have to pay for a mp3-player, but because it might be illegal to have one in the first place!
- Look at copyright, it has been limited for a given number of years, but big companies like Disney keeps pushing the limit. Every time the copyright on Micky Mouse(tm) was about to expire, the limit on copyright has been extended. I don't believe that it is reasonable to expect it would be different for software patents.
- I don't think innovation in the software business depends on patents, on the contrary, with the number of patents, its a minefield to develop software, so it hinders new innovators. Even with limited patents, it would still be hard for new innovators.
- I don't believe that its very likely a limit on software patents would have any significant effect. In the EU, 40 000 patents were issued - even though software patents were illegal!
Go against patents!You are missing the point. Since MS-Windows split from OS/2, maybe even before that, it has been a copycat. If you doubt that, look at sunview, Mac OS or any other GUI that predates MS-Windows.
If we look at features of the GUI, I don't think you will find many features of MS-Windows has, that didn't or doesn't exist for other OS's. On the other hand, I think you will find many features that MS-Windows do lack, like "focus follows mouse", "vertical or horizontal maximise", "virtual desktops", etc. etc.
In many ways, MS-Windows is still long behind The X Window System, and no wonder. X started well before MS-Windows 3.1 was started, and has evolved continuously. Contrary to MS-Windows, most of the platforms that runs the X Window System doesn't have to deal with old 16-bit code, neither in emulation or any other way. (In other words, the command-line always is and always was on the same level as the GUI, unlike MS-Windows).
What bothers me most about MS-Windows or any other non-free OS, is this: They do not give me the freedom that a GNU system gives me. However, even if you don't want freedom my friend, you still have the freedom to let Microsoft chain you.
/Spam .
To the flame bait here, I can only say:
Tum podex carmen extulit horridulum!
A general remark:
The most important lack of MS-windows IMHO, is not the technical flaws or the great lack of advanced features, but rather that it is not free for all to change the source code, give changes to a friend, or even sell an enhanced specialised version. Even though it wouldn't harm you to burn a copy of the software, in many countries it is not even legal to let your friends copy the software verbatim. In other words, even if you paid a lot of money for the software, you are not allowed to do much with it. Often the license doesn't even allow you to install the program on more than one computer at a time.
Microsoft Windows lacks to be what the GNU Project has chosen to call "Free Software", which unfortunately due to a flaw in the English language let you believe that it is focused on no price.
GNU/HURD, GNU/Linux, OpenBSD and others are already "Free Software", which means you have a lot of freedom to do pretty much what you want with it. Some of the software, however, has a licence that restricts you from reducing this freedom for other people.
The reason Microsoft hates the "GPL", is that they want to make more money by restricting the freedom for people. The GPL does not allow them to do this. In this way, I find the GPL superior to many other licenses.
For this reason, many will argue that Microsoft and similar companies are evil. The point is however, that they make money acting the way they do. The only way this can change, is if they stop making money this way, or if they begin to make less money this way. One way to stop that, is to stop using their products, a thing I find very easy to do.
If you want to study what "Free Software" really is, and maybe find out why we are so many feels that it a wonderful thing, I guess the GNU Project web server is a good starting point.
Just to mock you a little in a friendly way - I didn't know there were free (as in freedom) games for the PS2. :-P
/Spam .
I don't think you intended to imply that Free Software or Open Source software is always free of charge. I'll make the point anyhow, just in case someone misreads it. I am sure there is somebody who wants to read About Free Software.
While it is often true that its usually easy for users to get Free Software for no charge, it doesn't have to be like that.
A hypothetical example:
I might write a peace of software, that I chose to distribute for a fee, but distributing it under the GNU General Public License. Now, while you might get it for free, it might be hard. My customers might not wanna give it away something they paid for in full for no fee, or maybe you don't even know who to ask.
Eventually my customers might be selling the software cheaper than I am, and I'll have to compete, maybe adjusting my price down, selling support and the like to the end-users, but if I already sold enough software to pay for my work when this happens, why be sad? A lot of users will be using my software and will learn that my software is good quality, which again will make it easier to sell them my next product, ensuring me butter for my bread.
If you want to read more about selling Free Software, you might want to read the article Selling Free Software, it has even been translated to several languages.
Well, personally I think I made more than one argument as to why I think that Java being slow is a myth. I even provided links to benchmarks and articles analysing the performance of Java.
It seems to me that you're simply biased against Java. I dunno if you really have 5 different machines running applications of poor performance, but mind you, it is possible to write slow code in just about any language - even Java!
If I got it wrong, and you're really sad about the performance of your Java applications, maybe you want to take a look as these Java performance FAQs in order to try and improve the performance of these applications.
I never understand claims like this. The advantage of Java's GC boils down to not having to write delete p; when you're done with something allocated dynamically. Since most variables in C++ aren't allocated with new anyway, and even in the occasional code where they are you usually use RAII to avoid the overhead of deleting them manually, how on earth does productivity double in Java?
I wont comment on whether Java is more productive than C++, I don't know about that, but the gain of the garbage collector cannot be reduced to you not having to write delete p; or whatever your language of choice wants you to write. As I mention in another post on this topic, one of the reasons that Java is performing well these days, is that the garbage collector makes memory allocation cheap. In a language without Garbage Collection, you generally have to either create something like an "object pool", or pay for expensive calls to the OS in order to allocate memory.
Another benefit of the garbage collector is that you generally don't have to "pay", if you "accidently forget" to delete an object. Actually, to my knowledge, you cannot free objects in Java, save dereferencing memory (object = null;). Now, its no silver bullet either, but actually Java programmers does suffer much less than programmers without a garbage collector (or similar tool, RAII?) from having to debug memory leaks. A man with a spoon, and a man without a spoon might both be able to eat soup, but the man with the spoon might do better! (So maybe the real issue is whether you have a tool for memory).
I hope that helped clearing up that point.
I am happy to see a post that while critical towards Java, doesn't mention performance. I guess its becoming more widely known that Java doesn't have the performance issues that it had back in 1995.
C is ancient and crude. Java is a padded cell and straight-jacket. There is a middle ground.
I will not comment on your view on C, and hopefully no-one else will, lest we want to see a full scale (OT) "language war".
When it comes to Java lacking multiple inheritance, I have never written much code in any language where multiple inheritance was possible, so I dare not comment much on this. However, I want to mention that Java has the "interface"-thing, that makes it possible to do at least some of the things you generally want to do with multiple inheritance.
So, for the rest of this post, I will assume that your point is that for you, Java is uncool because the compiler seems rather pedantic to you.
I need to comment on this, since I code Java on a daily basis and have a different experience. While its true that the Java compiler from SUN seems rather hysterical when you first start out with Java, the reason for this is the same as the reason that parents is usually very concerned about whether their child/children checks for traffic before crossing a road.
Now, 9 out of 10 times (it seems like more) when the Java compiler keeps complaining about '<identifier> might be uninitialised error in <line number>', I'm very happy about it the 10th time, where I actually forgot to initialise the variable. That being said, I often just initialise my variables early, to avoid this, but then again, then they *are* initialised.
Some prefer to manage stuff like this themselves, "Its not the business of a 'stupid compiler' how I write my code!", for them, C++ or even C might be a better choice. (Of course, sometimes you choose the language for the task, but both C, C++ and Java are all general purpose languages). Me? Well, I got used to Java, and I get much less problems with the compiler nowadays, I guess its become somewhat a challenge to write the code so that the compiler "eats it" as it is. Oh, and yes, I *do* enjoy having a garbage-collector to pick up my trash for me.
Sorry, when trying to preview the unfinished post, I hit submit by mistake. I hope the post still makes sense, it was almost done, but I like to read what I post a few times, before I post, just to make sure its how I want it to be.
/Spam .
Thank you for commenting!
I agree with much of what you wrote, I realise that I in fact did overplay the significance of JIT having runtime knowledge. I wanted to stress the fact that Java isn't simply an interpreted language, not even when you use the JVM from Sun.
The most important point of my post, though, is that "Java isn't slow" anymore. When I first got to know Java, it was dreadful slow. Now, its comparable to C++, and in some cases even faster, and has the potential to be even faster. Now, all this fuss about performance has really nothing to do with the Java-language, but has to do with the Java-platform, its not unrealistic to write a compiler for C that generates Java-bytecode for the Java-platform, but the point is that the Java-platform today proves that it does in fact work, that it doesn't slow performance, as seen in early stages. It has its strengths and weaknesses. One point I must make though, is that in my opinion, JIT is not the single key that Java has reached the performance of C++. Of course, JIT _does_ help a lot, esp. in CPU intensive code, but there are other factors as well. One really important point, is that Java Bytecode applications can allocate memory very cheap, as explained in my previous post.
That being said, lets discuss JIT a little...
(Just for the record):
Its naive to assume that the cost of JIT is free, but its also naive to assume that Java compilers would not benefit from the last 20 years of experience on C compilers. The Java compiler from SUN is able to optimise the bytecode as well AOT as well as optimise the bytecode with JIT.
Your analysis on when JIT is beneficial, is very good, I do have a few notes though:
I don't think that this pose a real problem. The point is that "Most code", doesn't need much CPU, and thus the overhead of the JIT profiling, won't matter much, whereas the bonus from JIT-compiling critical code in CPU-intensive code will be a great gain for the JVM.
In C, when you write CPU-intensive code, you usually hint the compiler about optimising, in one way or another, since you know which code you want to be optimised. You may "inline" some code, ask to get an index variable kept in a register, and compile with flags / options like "-funroll-all-loops", "-funsafe-math-optimizations" and others. Usually, these hints will make the compiler able to make as good decisions as any JIT would be able to.
On the other hand, if you write CPU-intensive code, without paying attention to micro-optimising, chances are that the JIT-enabled code will run slightly faster (given the same algorithm, of course). With todays speed of CPU's, Code that is not CPU-intensive, will often seem to run at equal speed, from the users perspective, whether its interpreted or (JIT)compiled. (Even though they might actually be faster in the AOT code).
Here is an example where the JIT compiler seems to slow down the code, and how to mend that. Note that this type of code is very rarely seen in actual real life programs.
If we talk about really micro optimising code, I guess you would want to either write the code in assembler, or be really creative about how you optimise your code. As I mentioned in my first post on this subject, Java can also be compiled with AOT compiles! Another possibility, if you know that C is faster (or already have the optimised code in C source), is to use JNI (Java Native Interface), that lets you call native code. Note that this will of course invalidate any claim as to be "Pure Java" code.
Thank you for the input, its always nice when people provide arguments instead of merely saying "I disagree", or even "you're wrong", like seen in other posts here on /.
Without getting into more technical detail, than I can manage right now, I have a few comments on your post.
Mybrid wrote:
Lemme start pointing out, that your argument stands, for Java JVM's around 1995, which is still used in some older browsers, to interpret applets on websites. That being said, I want to make a few corrections to bring us up to date:
Java HotSpot JVM, is a not only an interpreter, its also a compiler; a JIT compiler. A JIT compiler is a Just In Time compiler, which means that it runtime discovers which code needs optimising the most, and then compiles it. The JIT compiler usually uses a cache on the disk, so when it has run your program once or twice, it has already compiled the stuff that needs it. Thus, your programs gets faster by use.
In case of C, its by far most common to use an "AOT-Compiler". AOT == Ahead Of Time compiler, a compiler that produces bytecode or machinecode from sourcecode, like Java or C. The bytecode in C's case, is usually platform-dependent machinecode, while Java is generally transformed into "Java bytecode", which will then be taken care of by a JVM. Note: There is nothing hindering a compiler transforming C-code into Java-Bytecode, or Java-code into machinecode. In fact, as I pointed out earlier, there are more than one AOT-compiler available for Java, Excelsior JET even offers a "Mixed Mode", where most of your code will be compiled to machinecode, and code that for one reason or another isn't convenient to compile, is interpreted, and/or JIT-compiled).
While you might be a very efficient C programmer, and write fairly good optimised code, its not like that for all programmers. Esp. when working against the clock, many tend to write code that might be a bit sloppy, but "does the job". This is where Java in my opinion really has an advantage: The compiler is a "JIT" (Just In Time) compiler, which means the code is compiled while its running, and further more, only code that the VM assumes is worth it, will be compiled. What is really interesting here, is that the compiler at this point will have runtime knowledge of the program, something a common C compiler wont have. This enables the compiler to optimise better, utilising the runtime info. (Which loops are heavy-duty, and should be unrolled, which loops are merely used, etc.).
Now, I wont make the claim that really well written C-code, optimised in every corner, and compiled for the specific platform where the code will run, is slower than Java. In fact, I'll assume that it will in general terms be faster, depending on the task (as I mention in my earlier post, memory allocation is generally cheap in Java, but of course, you could optimise C for this as well, even though it might be quite a dazzle.) The point is, you might gain very little from a great effort in C, since you might have to emulate the advantage of having a clever garbage collector making memory allocation cheap! (Read the next section for details!)
Let's get to the juicy stuff!
One of the reasons that some consider Java uncool, is because of the myth that Java is slow. I call it a myth, and I will try to explain why it is a myth. (Actually, in theory, Java will outperform C++ soon).
Just to take a swing at another myth, while we're at it: When it comes to size of the stack, how you want the garbage collector to use memory etc., you CAN in fact give the JVM parameters to control this stuff.
Java isn't slow anymore. It may be true, that (small) Java applications generally takes a little longer to start up, if you didn't use an AOT compiler (like for instance the "free as in freedom" compiler GCJ or the more mature but proprietary Excelsior JET). Its true that early versions of Java were slow, but 1.4.x isn't generally slower than C++, in fact, I wouldn't be surprised if it outperformed C++ on general terms one of these days.
One of the things that makes Java "not slow", is actually the way memory is allocated. Its rather cheap to allocate memory in Java, compared to other languages, and its even cheaper to "free" memory, since you don't do it, you have the cost of the garbage collector instead. The garbage collector in Java is very fast, compared to older garbage collectors.
(For the interested, IBM has an article on "garbage collection in the HotSpot JVM", and another article that explains various garbage collection techniques, and finally they have an article that covers performance concerning garbage collection. They have a lot of other interesting articles, but I don't want to list all I know, if you like to check it out, here is the search I used to "refind" these articles.)
I make the claim that Java isn't slow, but don't just take my worth for it. (Not that I think you would). Go search on google or whatever. A word of warning though .. since older Java's were
indeed slow, do note the version of the Java tested. It should be (at
least) 1.4.x. I don't think 1.5.x is stable yet and I dunno if its
faster or slower, but 1.4.x have a real nice enhanced garbage
collecting subsystem. (Esp. 1.4.2 and above).
(On purpose, I didn't go for SUN benchmarks, as they might be (considered) biased, but sun does have a word to say about "Java Performance".)
Here is a couple of quotes from an article that considers performance of Java vs. C++, analysing some benchmarks of Java, C++ and other languages. While the article was updated this year, I was still unable to find a link to a benchmark diagram of the current 1.4.x JVM. It seems though, that the 1.3.x wasn't too slow, even without latest optimised GC-subsystem, which is one of the key factors that makes 1.4.2 faster.
Here are the quotes:
This "virus" seems to me more like a like a Trojan horse, and it seems that the "SM(S)-feature" of this "Trojan horse" was build into the game originally, so this particular incident is far from typical. That being said, I think the OS pretty much does matter in this case, to quote the article:
From the README of Noiptun:
OK, this might be redundant by now (there wasn't any replies when I started writing this), but I post it anyhow in case it has additional information:
Debian GNU/Linux always has at least three releases in active maintenance: "stable", "testing" and "unstable".
There is different ways of getting Debian. A new way of installing is prepared for Sarge, but works for other versions too I think.
In reponse to "DOH!! correction"
No, the release was not delayed so that security fixes could be put in it. The release was delayed, but the security fixes in it, are not related to the cracking of the Debian file servers. Some rumors say the reason was password compromise, but I still don't know for sure what the reason was.
Anyway, the delay was that when you get your file servers cracked, its should be your first priority. They had the release ready before they were cracked.
Click to get more (recent) information about the crack/compromise.
/Spam .
An article on CNet news.com suggests that "Open Source" is catching on in China.
Now, how many people live in China? Computerworld has an article on how Red Flag GNU/Linux which I think is widely used in China, is now going international.
A majority of people might be stupid for a short period of time, but I don't think the majority of people will be stupid in the majority of time, at least not when it comes to wasting money for nothing. Now I know that some will argue that you get some value from Windows, I wont deny that, if they think they get value, they *get* value, either imagined value, real value or both. My point being that whatever you can do with any commercial program, you can do with (potential) free software, and you can do it freely!
--
/Spam .
Microsoft Windows(TM) might be able to run on intel emulation, that will allow Microsoft Windows to run on it, but frankly, who cares except Microsoft, Intel, AMD and maybe a few others?
If windows doesn't port to this processor, I am sure some other OS will take over, and everything will be rewritten for that OS. Alternately, you might go with an existing OS easier to port, like Mac OS, NetBSD or GNU/Linux. (URLs in the of this post)
A silly OS and its platform dependence isn't gonna stop development that much.
Kind regards,
/Spam .
URL's for possible alternatives goes here, I am sure I miss a lot of them:
Mac OS:
Mac OSX
GNU/Darwin
NetBSD:
NetBSD
GNU/Linux:
Red Hat GNU/Linux
Debian supports several platforms.
SuSE GNU/Linux
Mandrake GNU/Linux is a distribution from France.
Slackware GNU/Linux is a classic.
Some will charge you for GNU/Linux, and give you support or written manuals, silver-CDs or something in return. I probably missed a lot of links, but to mention some of the commercial distributions I missed, here is a comparison on price.