“Although the .NET vs. Java war is basically over for control of the Windows desktop, where .NET is sure to become the managed language of choice for new Windows desktop applications, there is a new battle brewing. That battle is for the Linux desktop. Now that Java has been open sourced under the GPL, even the most strict of the ‘free software only’ distributions can start bundling it and integrating it into their Linux distributions out of the box.”
Python/Gtk seems like a pretty strong choice given that there are quite a few applications using it (Gajim for example).
I’d actually be more strongly tempted by C# and Gtk than Java and Swing or Java and SWT. SWT is pretty nice, but I still prefer Gtk and simple Gtk bindings (it’s sort of home field for me, and I know I’m not losing drawing primitives because they’re not available cross platform). I don’t consider Swing a viable toolkit: D&D on Linux issues, Mac issues with dual monitors, too clunky in general, the object decomposition seems like it was done by an OO purist, it seems unlikely to take advantage of gpu drawing anytime soon, etc…
My feeling is that today, on Linux, Mono may be the strongest choice. Especially given the Gnome bindings for it (I’ve heard they’re quite complete?).
Perhaps Qt Jambi (as QT on java) will make java more tempting for me.
But Gtk# with C# on linux is truly a nice option.
> Python/Gtk seems like a pretty strong choice
I wouldn’t consider Python to be a strong choice for a full blown desktop application due to its lack of strong typing and such.
> Mac issues with dual monitors
What issues? I run Swing apps on my PowerMac G5 with dual monitors, and I have no issues at all.
> it seems unlikely to take advantage of gpu
> drawing anytime soon
Java has been using the GPU for 3D since Java 5, and in Java 6, which has been out for awhile now, it also uses it for 2D drawing.
(http://weblogs.java.net/blog/chet/archive/2005/05/graphics_accele.h…)
> My feeling is that today, on Linux, Mono may be
> the strongest choice. Especially given the
> Gnome bindings for it (I’ve heard they’re quite
> complete?).
I see several problems with Mono on Linux, which are pointed out in the article. Compared to Java, it is very immature, it does not have nearly the amount of open source library support that Java does, and it is doomed to always lag behind the official .NET implementation. That and because of the fact that Mono’s class libraries use the MIT license, there are potential software patent traps. (http://www.newsforge.com/article.pl?sid=02/02/19/1651244)
Since Java is GPL, and Sun has made clear that Java will adopt GPLv3 once it becomes finalized, there are no patent traps for Java.
Edited 2007-03-08 00:00
That and because of the fact that Mono’s class libraries use the MIT license, there are potential software patent traps.
Not entirely true; the core classes along with GTK#, Cairo# and friends are ok – the problem with occur with the .NET compatibility like Winforms.
Then again, its no more troubling than Wine, which probably treads on a number of patents and yet, there isn’t a single bit of protest.
Microsoft know that ultimately Mono will always be playing catch up; the VM of mono alone is immature and no where near the capabilities of Microsofts own .NET or Sun’s Java VM – and given that the development is done by only one company, Novell, and a cheapskate organisation at that (unwilling to spend money when required) Microsoft know that its always going to nothing more than a novelty.
> Then again, its no more troubling than Wine, which
> probably treads on a number of patents and yet, there
> isn’t a single bit of protest.
Actually not quite correct. Everyone recognizes that WINE and Winelib are temporary (imperfect) solutions, not permanent ones, so the effect of a patent trap is less because few people rely too heavily on WINE. If worse comes to worse and the trap is sprung, you can always use VMWare/Xen/KVM/QEMU.
When Corel ported Wordperfect to Winelib, people balked, so I wouldn’t say there isn’t a single bit of protest for WINE.
The key difference between WINE/Winelib and Winforms/ASP.NET/ADO.NET is that the later is billed as a permanent solution to writing portable apps that can be developed on Windows first while the former is not.
Edited 2007-03-08 20:57
Although I’d like to see Wine as a temporary solution, the reality is anything but that.
When you have lazy software companies like Adobe not getting off their ass porting their software to Linux, knowing full well that that there is a massive demand, both by Windows and MacOS X users looking at migrating, Wine unfortunately by the nature of laziness of software companies, will become a perminant fixture on the Linux desktop.
Now, I’m not trying to scare people, but it does open up a big can of worms, and worse still, due to the crap portable nature of Wine – the fact that its severly broken on any platform outside Linux – try running it on FreeBSD or Solaris for example, you’ll always end up getting locked into a single operating system – hence my preference for an opensource replacement; atleast then I can move and take the application with me, if I move from Linux to FreeBSD, as long as the application as been ported, I can continue on running the same one – with wine, its the roll of the dice as to whether something that might have run under wine on Linux runs under wine on FreeBSD or Solaris.
Python is strongly typed, it’s not statically typed. And I agree, I also believe it poses a problem when developing complex software. However, a lot of desktop software doesn’t appear to be entirely complex in the way that static typing helps but in other ways where rapid changes help (user interactions are complicated because of users, not the nature of the calculations or data so an easily modified code base is more helpful than a statically typed one).
Obviously mileage will vary from programmer to programmer and problem to problem.
It is good to hear that Swing will be moving forward and making use of that extra hardware for drawing where possible, that’s encouraging news. As I tried to communicate before, I didn’t have the feeling that Swing was moving forward (other than trying to act more native). Maybe my feeling is wrong.
Start an app with only one display connected. Connect the display. Move the app to the second display. Try to use a combo box. The combo box should fail to display a menu (it does here).
Also, menu’s don’t do the proper animation after selecting (really minor).
I’m sure I’ll find more as time goes on though, I’m new to Mac.
If you’ve watched Microsoft’s take over of application software you should note one thing: It’s not about what you can do, it’s about what you can promise to do and if you can make people believe you’ll get there. In a sense, it’s about momentum (or at least perceived momentum) and not about assets.
Java is more mature, that’s for sure and that’s a great asset. Mono is new and shiny and partially due to its newness and partially due to its openness (not just the source, but the developers talking openly) it appears to have a lot of momentum.
Patent traps are probably going to hurt Mono as well. But I believe that’s actually a much smaller group of developers than the group who doesn’t think a lot about it; and I’m only talking about Linux application developers (the ones we’re concerned with).
>
>Python is strongly typed, it’s not statically typed.
>And I agree, I also believe it poses a problem when
>developing complex software.
>
How do we define complex software? How does static typing make developing complex software easier?
http://pygtk.org/applications.html
On that page you’ll find a list of applications ranging for UML editors, auditor editors, video editors, audio streamers, to full blown games all written in Python. Python is excellent for written any kind of software regardless of complexity. The whole “dynamically typed languages is not good for writing ‘complex’ software” is a silly myth.
Static type checking makes developing complex software easier because it establishes statically (compiler) checked contracts at all of your interfaces.
On a local level it makes software a bit more clear by defining what types of inputs and what type of output a function has. With dynamic type checking you can receive any type of object into your function and pass it down the line until it gets to a point where the duck typing (this is runtime now, and it’s usually duck typing as it is in python) causes an error (it can’t find some attribute on that object that it expected).
Static type checking forces you to think these things through before you can even compile your program. Some people can do entirely without it and many people substitute extensive unit tests (which do a lot more than check type issues, which is why they’re used in static type checked languages as well). But the errors still leak through and you end up doing a lot of work to figure out at what point you’re really sending an invalid object into the mix.
To state that static type checking doesn’t aid in writing software is to call dozens of prominent language designers wrong… I doubt even Guido would argue that static type checking isn’t helpful.
In fact, I do believe Guido agrees with me
.
http://www.artima.com/weblogs/viewpost.jsp?thread=86641
There’s actually a tool for doing some static type checking in Python: http://pychecker.sourceforge.net/
Static type checking is much more difficult in a language like Python, which is why so many modern statically typed languages add syntax to aid in the enforcing. The difficulty of the check, coupled with Python’s “run from source code” workflow, is likely why it’s not in the compiler itself.
Static type checking is overrated. And does almost nothing to alleviate software complexity or reduce bugs in typical software programs. When was the last time a type error brought a project to a hault? In my experience writing programs with both statically and dynamically typed languages, type errors have been the least of my concerns. And I only realized that after writing a medium scale project in a dynamically typed languages.
What static type checking does is give impressionable developers a false sense of security. The reality is that disasterous bugs in software are only found via testing. Unit automated testing, regression testing, user testing and manual testing are the scientifically proven ways to ferret out bugs in software, not fanatically checking data types whether or not it makes sense. Type errors are cheap to discover and fix in about every language I know. Python, in particular, points you to exact function and line a possible type error may have occurred, albeit during testing.
The errors most developers have nightmares over are the ones related to design, semantics, threading (race condition, dead locks, etc), inadequate understanding of the problem space or inexperience, bugs in third party libraries, poor or lack of documentation among many others. I have yet to a see a developers grow gray hair over type errors.
Static typing is something smart compilers should manage for programs. In fact, some smart compilers already do that. Haskell’s compiler has an impressive inference engine that many statically typed languages should emulate. The single significant advantage of static typing is optimization and performance tuning. Errors with respect to types are almost always insignificant and cheap to discover. A programmer’s greatest challenge should be design, not fighting around needlessly with compiler errors or language semantics.
I feel that both, static and dynamic typing, can be a pain if they’re forced on you. That’s a problem that I encountered in C++ for example:
I’m writing some sort of function and don’t yet know what sort of input it’s going to take but I need some sort of temp variable. Problem: I need to declare the variable AND it’s type at the same time – all squeezed into one tiny statement. Yes, I know there are templates but they’re just a pain in the a**!
On the other hand, sometimes you WANT to give type information. As a comment, to increase performance and, last but not least, for polymorphism types are imho essential.
But they should be dynamic so that you could e.g. first use something as a vector with vector addition and multiplication and then use it as a list like this:
my a, b
a=(1, 2, 3)
b=(-1, 1, 0)
(a, b) are vectors
a+=b // a is now (0, 3, 3)
a/=3 // a is now (0, 1, 1)
(a, b) are lists
a+=b // a is now (0, 1, 1, -1, 1, 0)
That’d be sweet!
Some statically typed languages are introducing inferred types which you might find interesting (although I think you’d need to be dilligent in replacing their use once you’re done experimenting). C# is an example, I believe in 3.0 the “var” keyword now means to use an inferred type.
Static type checking is a minor general form of testing. By giving it up you’re simply adding one more test onto your unit test requirements… I see no reason to rewrite this over and over when general algorithms have been _mathematically proven_.
You admit you’re going to test the typing anyway so why not just have the compiler do it?
As I pointed out before, Python has a similar tool: PyChecker. You might try reading posts before you spout off self-righteously as if we told you your favorite language was bad, which I don’t think anyone has.
Python is one of my favorite languages, I use it quite often. And not just on tiny problems.
Your claim that dynamically typed languages is not good for “complex” projects/problems is bogus. I could care less if Python is your most or least favored language.
> Your claim that dynamically typed languages is not good
> for “complex” projects/problems is bogus.
I can’t speak for the guy making that claim (or for anyone else for that matter), but I personally think types add readability, a lot.
E.g., consider these two lines:
var perms = getPerms()
Map<User, Set<Permission>> perms = getPerms()
Which one conveys more information?
The added information brings with it the burden of having to write more (although good code completion support helps a lot). If typing is optional many people don’t use it, so as long as I don’t have complete control over all code I use I want the language to have static typing.
If by readability, you mean more noise and clutter in source code, then I agree. If by readability, you mean the ability to decipher code, then I disagree.
Programmers don’t decode code linearly, or one line at a time. Code is decoded in context of modules, classes, functions, blocks and surrounding code. Lets take your example:
perms = getPerms()
As far as I’m concerned “perms” is just a reference to data containing information about permissions. Cognitively speaking, that’s perhaps all I need to know. Information about its type, size, properties, methods, attributes or behavior is almost likely irrelevant and thus a cognitive burden or distraction.
What’s most important is if I can figure out the purpose of “perms” in the context it is being used. I don’t see how prepending type information before “perms” makes code easier to decipher. Does it really matter whether “perms” is a float, string, list, vector, integer or custom object? Or is all we need to know that “perms” is just data containing information about permissions? My response to the last two questions is No and Yes for most situations.
The reality is that type information in source code has historically and conventionally been used to aid archaic compilers (especially for performance and optimizations), not to promote readability. The good news is that Modern sophisticated compilers can now determine, or “infer”, type information without you having to litter source code with noise and largely irrelevant information (e.g. type information). Hopefully, the next generation compilers will have this as a mandatory feature.
I just don’t see the correlation between adding type information in source code and improved readability. In fact, I see just the opposite.
> > I personally think types add readability
>
> If by readability, you mean the ability to decipher code,
> then I disagree.
Who are you to have an opinion on how I perceive things? How incredibly arrogant of you!
> Information about its type, size, properties, methods,
> attributes or behavior is almost likely irrelevant
Well, “almost likely” implies “not likely”, so I guess I agree. Seriously, if you have to use the permissions data (and you probably do since you called getPerms()) then you need to know what it is.
> Does it really matter whether “perms” is a float, string,
> list, vector, integer or custom object? […] No
Sure it does. I have to know if perms is a set of permissions or a map of sets or what. And once I know that it’s a map I have to know if the keys are user IDs or user objects or groups or what. It could be almost anything. And then I need to know how to interpret the values, so I have to know if they are sets of permission IDs or permission objects or what, so that I can do with them what I need them for.
All this information has to be somewhere. If it’s not in the semantics enforced by the language syntax then it’ll have to be in the docs or some comments or somewhere. I personally prefer to have it in the language.
>>>Who are you to have an opinion on how I perceive
>>>things? How incredibly arrogant of you!
I don’t see how disagreeing with your opinion is arrogant.
>>>Seriously, if you have to use the permissions data (and you probably
>>>do since you called getPerms()) then you need to know what it is.
Programmers who call functions are supposed to know what to do with the result the function returns.
>>>Sure it does. I have to know if perms is a set of permissions or a
>>>map of sets or what. And once I know that it’s a map I have to know
>>>if the keys are user IDs or user objects or groups or what. It could
>>>be almost anything. And then I need to know how to interpret the
>>>values, so I have to know if they are sets of permission IDs or
>>>permission objects or what, so that I can do with them what I need
>>>them for.
This is information that can easily the deciphered if the assignment statement is in the context of surrounding code. And since getPerms is a public function, it is probably documented.
Also having type information in source code does not mean one knows how to use the object associated with the type. For example, if “perms” is of type “Permission”, the type information is useless because I still don’t know the characteristics of the “Permission” type. I have to read documentation or code to figure that out.
In brief, when reading code, contextual information is more important than type information.
Edited 2007-03-11 05:59
> > > > I personally think types add readability
> > >
> > > If by readability, you mean the ability to decipher code,
> > > then I disagree.
> >
> > Who are you to have an opinion on how I perceive things?
> > How incredibly arrogant of you!
>
> I don’t see how disagreeing with your opinion is arrogant.
I wrote that I find types more readable. You are in no position to disagree. At most you can say that you refuse to believe that I find it more readable.
Now, maybe you tried to tell me that you don’t find types more readable, but that’s irrelevant to the point, which was that there is someone who finds types more readable. Unlike you, I’m not trying to tell anyone that one of the ways is better.
> > Seriously, if you have to use the permissions data (and you
> > probably do since you called getPerms()) then you need to
> > know what it is.
>
> Programmers who call functions are supposed to know what to
> do with the result the function returns.
Exactly, that’s why I prefer to have much of the needed information enforced (and verified) by the language/compiler.
> This is information that can easily the deciphered if the
> assignment statement is in the context of surrounding code.
> And since getPerms is a public function, it is probably
> documented.
I prefer less deciphering and more plain in-your-face information. I also prefer having to rely less on documentation (which is optional). You obviously prefer differently and that’s fine. We don’t have to prefer the same thing, just don’t try to claim that one thing is categorically better than the other.
>>>I wrote that I find types more readable. You are in no position to
>>>disagree. At most you can say that you refuse to believe that I find
>>>it more readable.
>>>Now, maybe you tried to tell me that you don’t find types more
>>>readable, but that’s irrelevant to the point, which was that there is
>>>someone who finds types more readable. Unlike you, I’m not trying to
>>>tell anyone that one of the ways is better.
I disagree about your opinion between the correlation of type
information in source code and readability. There’s nothing arrogant
about that. If you can’t stand differing opinions, don’t get involved in
arguments.
>>>Exactly, that’s why I prefer to have much of the needed information
>>>enforced (and verified) by the language/compiler.
Type information does not give one all the information needed to manipulate objects. I still don’t know how to use “perms” regardless of the presence of type information in your C++ example.
>>>I prefer less deciphering and more plain in-your-face information.
Programming is not for you then.
>>>I also prefer having to rely less on documentation (which is
>>>optional).
More or less type information does not mean relying on more or less documentation.
>>>You obviously prefer differently and that’s fine. We don’t have to
>>>prefer the same thing, just don’t try to claim that one thing is
>>>categorically better than the other.
One is categorically better than the other. If I didn’t think so I won’t be having this discussion.
He’s stating his opinion and arguing one point and you’re arguing another point entirely: He says “one person finds explicit types more readable, me.” You say “explicit types can’t be more readable your opinion is wrong.”
He’s then calling you arrogant for assuming that your reasoning for implicit types is good enough for everyone and everyone should find that explicit types don’t help regardless of the fact that he just said he didn’t. And so he’s calling you arrogant for being completely closed to the other side of the argument and assuming that not only are you right about some small thing (how implicit types could be just as good) but you’re right about something much bigger (how implicit types definitely are just as good and explicit typing is bad).
And yes, less type information means you need the documentation even more to tell you what each function returns. You’ve done pygtk programming, surely you’ve noticed that it’s takes some extra time when the return parameter isn’t very well documented on those api docs? In the standard bindings the type of the return is always documented because that’s a minimum for compilation.
Thankfully both sets of developers are pretty thorough and it’s usually not much of a problem on either side. However, I do find myself looking to the C docs on Gtk occasionally to figure out what type a function is dealing with on the pygtk docs.
Maybe those are always obvious to you?
>>>He’s stating his opinion and arguing one point and you’re arguing
>>>another point entirely: He says “one person finds explicit types more
>>>readable, me.” You say “explicit types can’t be more readable your
>>>opinion is wrong.”
>>>He’s then calling you arrogant for assuming that your reasoning for
>>>implicit types is good enough for everyone and everyone should find
>>>that explicit types don’t help regardless of the fact that he just said
>>>he didn’t. And so he’s calling you arrogant for being completely closed
>>>to the other side of the argument and assuming that not only are you
>>>right about some small thing (how implicit types could be just as good)
>>>but you’re right about something much bigger (how implicit types
>>>definitely are just as good and explicit typing is bad).
The issue is whether or not type information in source code improves readability. He thinks it does. I think it doesn’t. I’m providing arguments to support my findings. Apparently, that’s arrogant and insulting to him.
>>>And yes, less type information means you need the documentation even
>>>more to tell you what each function returns.
If the function returns an object or a structure, I still need docs to figure out how to use the object or structure, regardless of whether or not type information is present.
>>>You’ve done pygtk programming, surely you’ve noticed that it’s takes
>>>some extra time when the return parameter isn’t very well documented
>>>on those api docs?
Python supports introspection. I don’t need docs to figure out the type of any object. I need docs to figure out how to use the object. And this is true for any language not just dynamically typed ones.
>>>However, I do find myself looking to the C docs on Gtk occasionally
>>>to figure out what type a function is dealing with on the pygtk docs.
And therein lies my argument. You are still looking at docs. Because a language is statically typed doesn’t mean your going to look at docs lesser than one that isn’t. I don’t understand why anyone would assume so.
>>>Maybe those are always obvious to you?
I don’t understand why you need docs to figure out the type a function returns. Or the type of any object for that matter. I use docs to figure out the characteristics of objects/structures (i.e. the attributes they expose and how to manipulate them).
My Point:
=========
My argument is that when reading source code, contextual information is more important than type information.
msundman provided an example of code written in VB and C++. He said the C++ one is more readable because it contained type information. That’s sexy. But the type information just added more clutter and noise. Because even though the type of the object in question is now obvious, nobody knows how to use it. At least not in the context it was provided.
Readability is akin to usability, if any element has no point or purpose or little significance, remove it!
I’m using the C api docs to find out types while using pygtk… Because occasionally pygtk is unclear about what kind of objects are needed for a function (which is one of the things I need to know in order to use it).
Runtime introspection is not good enough. It doesn’t help me find out what kind of object I need to pass to a function, it only tells me what kind I get when it returns: And even there it’s not an efficient way to find out.
If your language doesn’t mandate that you document anything about the parameters going into a method than you must provide those inside your documentation in order to make decent api docs (and most python libraries do this). You’re going to end up doing it anyway within method definitions.
I’ve had no problems with the pygtk documentation. The types and parameters of all functions and classes that I have used are well documented. If you find one that isn’t, file a bug report.
They’re documented because someone manually typed them in independent of the code. They entered them regardless of the language requirement to add readability. Pygtk does actually do an excellent job of documenting what types are required for each parameter within the description of the method.
That’s right, they used explicit types in method signatures (documentation inclusive) to add readability.
I was under the impression they used gtk-doc which automatically generates documentation from comments in source code. I believe the same is true for the GTK C binding. At least, that’s what they used to do some years back. Maybe things have changed.
Yea I’m not disagreeing there I’m actually stating it so I’m not sure what you’re talking about.
The point is that the types are written right under the method signatures, and in gtk-doc’s eyes are part of the signatures. It’s rather similar to writing them into the language except you put it in free-form text where it’s harder to decipher instantly and you don’t have to put it in.
The amount of information you get from documented source code is a lot more encompassing and useful than what you’ll get from type information in source code. Even when I read the GTK+ source code, (one of the best written projects I’ve come across), I find I spend most of my time reading the gtk-doc tags more than anything else. If the GTK+ source code wasn’t documented I would have found it challenging to grok. I don’t feel good documentation is a substitute for type information in dynamic languages. Good documentation is essential for all projects regardless of the language being used or whether or not the language is dynamically or statically typed.
It’s not a good substitute for type information in dynamic languages but you don’t think type information should be in the language either.
Are you saying then that all of your type information should be drawn out using type inference mechanisms? If not, where are you wanting the type information to come from?
>>>Are you saying then that all of your type information
>>>should be drawn out using type inference mechanisms?
For statically typed languages, that’s the best that can be done, I think. Haskell already does this.
>>>If not, where are you wanting the type information
>>>to come from?
I don’t understand this question. But I think compilers should be smart enough to figure out types. And as you know dynamic languages already do that.
Ok. So you prefer dynamic typing to static type inference?
In general I prefer dynamic typing and late binding. I wouldn’t mind static typing if the language/compiler could infer types, so I don’t have to deal with them in source code.
So is the main issue, for you, the types written explicitly into the source code?
The main issue for me is reading Java or C++ source code and spending a significant amount of cerebral energy decoding type information. And for no good reason too. If any information can be done without, and type information can be, it should be removed from the source code.
> The main issue for me is reading Java or C++ source code and
> spending a significant amount of cerebral energy decoding
> type information.
Exactly when do you need to “decode” type information when reading java code?
> type information can be [done without]
Why then do you “decode” it instead of ignoring it? If you find it hard to ignore it when it’s there “in your face” then why not just adjust the syntax highlighting to make it very faint?
>>>Exactly when do you need to “decode” type information
>>>when reading java code?
Every time it appears in source code.
>>>Why then do you “decode” it instead of ignoring it?
>>>If you find it hard to ignore it when it’s there “in
>>>your face” then why not just adjust the syntax
>>>highlighting to make it very faint?
The answer is human nature. Distractions will always be distracting regardless of how hard you try to tune them out or ignore them.
> > Exactly when do you need to “decode” type information
> > when reading java code?
>
> Every time it appears in source code.
Why do you need to “decode” them, and what does “decoding” even mean in this context?
> > Why then do you “decode” it instead of ignoring it?
> > If you find it hard to ignore it when it’s there “in
> > your face” then why not just adjust the syntax
> > highlighting to make it very faint?
>
> The answer is human nature. Distractions will always be
> distracting regardless of how hard you try to tune them out
> or ignore them.
OK, so why not make them the same color as the background? Certainly you wouldn’t be “decoding” something you can’t see, right? You’d have gaps, but they would hardly require “significant amount of cerebral energy” to jump over, right?
>>>Why do you need to “decode” them, and what does
>>>”decoding” even mean in this context?
— Map<User, Set<Permission>> perms = getPerms()
It took me a few minutes to understand why the perms object needed to be placed in a map object with user as keys and a set object as permission. The next thing my brain wanted to do was draw and imagine how the data structure looked like. Next my brain started debating why a set object was used for the values of the key in the map object instead of an array of numbers. Then I had to spend some time interpreting that syntax. After about four or five minutes, I figured perms is a dictionary-like object with User object as keys and a Set of permission object as values. My mode of thinking always shifts to that whenever I read java source code.
Reading Python source code is much different, because we generally don’t care about type information. It just doesn’t matter. That’s why if you put Java and Python source code side by side, people will almost always tell you Python is a lot more readable. And part of the reason for that is no type information and more spartan syntax.
Even in English, sentences that are overqualified with adjectives, adverbs and needless phrases are more difficult to interpret than sentences that are brief and succinct.
>>>OK, so why not make them the same color as the
>>>background? Certainly you wouldn’t be “decoding”
>>>something you can’t see, right? You’d have gaps, but
>>>they would hardly require “significant amount of
>>>cerebral energy” to jump over, right?
Because it’s neither prudent nor practical. Java will always be the bureaucratic, bondage and discipline language and I have come to terms with that. When I’m reading Java source code, I just readjust my mode of thinking.
> > Why do you need to “decode” them, and what does
> > “decoding” even mean in this context?
>
> — Map<User, Set<Permission>> perms = getPerms()
>
> It took me a few minutes to understand why the perms object
> needed to be placed in a map object with user as keys and a
> set object as permission.
You don’t need to understand the reason why it was designed the way it was, unless you plan on modifying the data structure.
[slight re-ordering]
> Then I had to spend some time interpreting that syntax.
You don’t have to spend time interpreting that syntax. Once you get familiar with it (which was a very short time for me) you automatically jump over the type unless you’re interested in it.
> The next thing my brain wanted to do was draw and imagine
> how the data structure looked like. Next my brain started
> debating why a set object was used for the values of the key
> in the map object instead of an array of numbers.
Now this is very enlightening. I completely understand that you can’t stand any extra information if your brain automatically starts to perform complex reasoning about commonly ignorable details. Is it like that with everything? E.g., do you call your variables “a”, “b”, “c”, etc. so that you won’t be spending “cerebral energy” on needlessly reasoning why variables are named as they are?
>>>You don’t need to understand the reason why it was
>>>designed the way it was, unless you plan on modifying
>>>the data structure.
Exactly. So why is this information littering the code to begin with.
>>>Now this is very enlightening. I completely
>>>understand that you can’t stand any extra
>>>information if your brain automatically starts to
>>>perform complex reasoning about commonly ignorable
>>>details. Is it like that with everything? E.g., do
>>>you call your variables “a”, “b”, “c”, etc. so that
>>>you won’t be spending “cerebral energy” on
>>>needlessly reasoning why variables are named as they
>>>are?
I don’t need to decode the type of “a”, “b” or “c” if it’s not given. All I need to know is that it’s a reference to an object.
> > You don’t need to understand the reason why it was
> > designed the way it was, unless you plan on modifying
> > the data structure.
>
> Exactly. So why is this information littering the code to
> begin with.
Um… are you just arguing (as suggested by using a loaded word like “litter”) or do you really want to know?
(If I don’t need to understand how my TV’s remote control works then why does it have one to begin with?)
You don’t have to understand why a data structure is made the way it is made just to use it. However, you (ar at the very least I) often do need to know its structure to be able to use it. That’s why it’s there, and that’s why I prefer to have it there, and I don’t think it’s “littering”.
> > do you call your variables “a”, “b”, “c”, etc. so that
> > you won’t be spending “cerebral energy” on needlessly
> > reasoning why variables are named as they are?
>
> I don’t need to decode the type of “a”, “b” or “c” if it’s
> not given. All I need to know is that it’s a reference
> to an object.
Why do you talk about the type of “a”, “b” and “c”?
Also, you didn’t answer my question.
You just don’t get it. And I don’t blame you. I too was in the “static-typing-is-more-readable” cult for years until I saw the light. I’m wasting my time talking so I’ll use code instead. Then you can draw whatever conclusion you wish.
JAVA CODE
——————————————————-
public Vector aList = new Vector;
public int aNumber = 5;
public int anotherNumber;
aList.addElement(new Integer(aNumber));
anotherNumber = ((Integer)aList.getElement(0)).intValue();
——————————————————
PYTHON CODE
——————————————————-
aList = []
aNumber = 5
aList.append(aNumber)
anotherNumber = aList[0]
——————————————————-
It’s the same code doing the same thing, but the Java code is so verbose a typical person would spend more time decoding it relative to the Python code.
Why is the Java code less readable? Well because it is riddled with type information and needlessly so.
Now multiply this by 1000 when you are reading actual source code and then you’ll begin to see what I’m talking about.
And you’d never realize this until you write a sizable project in either languages. If you haven’t done this, then I’m just talking to a wall.
> until I saw the light.
Oh, OK, then I guess my feelings and perceptions are incorrect, and I now clearly see how having less information at hand and instead having to hunt for that info from a lot of nonstandard, non-enforcable places is vastly better than having it clearly right in front of me (and my editor).
Seriously, just stop trying to convert me unless you have some information you haven’t already said many times and which I find either bad or insignificantly better.
> JAVA CODE
> […]
Ahem.. this is java:
List<Integer> aList = new Vector<Integer>();
int aNumber = 5, anotherNumber;
list.add(aNumber);
anotherNumber = list.get(0);
Not only does the type information not bother me, I would like to have much more of it. 😉 Well, not actually more, just finer grained type information. E.g., I’d like to be able to make a function like addUser(FirstName f, LastName l) easily without having to write the classes FirstName and LastName (which, although not very hard, could just as well be tagged strings, which would be much easier) or writing addUser(String firstName, String lastName) (and risking someone (me?) calling addUser(“Wayne”, “John”)).
I could live with inferred types, as long as I can see them whenever I want. I could not live with python-like code where you often have no idea what type of object some variable will point to, without running the code to that point or going deep down the function call rabbit hole.
I also refactor my code a lot whenever requirements change, and so I need my editor to know exactly what’s what to be able to move and rename methods, variables and constants and reorder parameters and change return types etc. with perfect accuracy.
And no, I won’t write a gazillion unit tests. Since my programs almost never have the type of bugs that are cought with trivial unit tests.
I can write a program for a week before I compile it and a few minutes after my editor indicates there are no errors/warnings I have it running and working perfectly. The only non-trivial bugs I have when I code are complex multithreading problems where something goes slightly wrong after a week of uptime. Maybe some queue that should be empty but isn’t because of some weird race condition or some cache coherency problems that are manifested only on powerpc multi-cpu machines because some vaariable should be declared volatile but isn’t. Or some problem that arise only when over 1000 clients try to access something at the same time and some fifo buffer is filled and some locks aren’t released in the proper order so some clients get timeouts or something.
Also, I almost never read any docs except for the auto-popup method/parameter descriptions. I sometimes look at the source code of some method I call, but that’s quite rare. That’s when I write java code, and the resulting code works. When I write python code I read a lot of docs all the time, and yet the resulting code doesn’t work properly. And many of my errors in python are type errors, which in turn turns out to be either logical errors or outdated-code-errors. I’m not going to unit-test every method with some code coverage unit testing framework, and I simply can’t afford to have errors in seldom used methods on a production system.
I never, ever have type errors in java. My editor constantly shows a list of all current errors and warnings in my code. This way I see the problems very soon after I make them, which means I have the relevant code in fresh memory. I don’t have to wait until I run the program or some unit tests (after writing them) or whatever.
I’m not going to give up my types unless I can see the minuses clearly outweight the plusses. You have shown me nothing that indicates dynamic types would be better in any significant way. In my opinion “I can’t bother to type so much” and “it won’t catch all possible errors in the universe, nor will it walk my dog and bake cakes” are definitely not outweighting the plusses I see in my code stability and clarity.
I’m not trying to convert you to use explicit types. However, I’m trying to get you to understand that there exists at least one person who do find explicit types better, and even more readable.
Edited 2007-03-12 10:07
>>>Ahem.. this is java:
But alas, I have to maintain legacy Java code.
>>>I could live with inferred types, as long as I can
>>>see them whenever I want. I could not live with
>>>python-like code where you often have no idea what
>>>type of object some variable will point to, without
>>>running the code to that point or going deep down
>>>the function call rabbit hole.
Python is strongly typed. I don’t know what your are talking about. Type information is not needed to write programs.
>>>I also refactor my code a lot whenever requirements
>>>change, and so I need my editor to know exactly
>>>what’s what to be able to move and rename methods,
>>>variables and constants and reorder parameters and
>>>change return types etc. with perfect accuracy.
Of course, you have to rely on your editor to do a lot of this bolier plate nonsense in Java.
>>>And no, I won’t write a gazillion unit tests. Since
>>>my programs almost never have the type of bugs that
>>>are cought with trivial unit tests.
Unit testing is used to catch semantic bugs not type bugs. These are bugs neither your editor nor compiler can catch. And no below average programmer has bugs relating the type errors. I’ve never seen it.
>>>When I write python code I read a lot of docs all
>>>the time, and yet the resulting code doesn’t work
>>>properly.
You should not blame Python for your incompetence.
>>>And many of my errors in python are type errors,
>>>which in turn turns out to be either logical errors
>>>or outdated-code-errors.
Learn to write good code then.
>>>I’m not going to unit-test every method with some
>>>code coverage unit testing framework, and I simply
>>>can’t afford to have errors in seldom used methods
>>>on a production system.
You can’t afford to have errors, so you don’t write unit tests?
>>>I never, ever have type errors in java.
I don’t know anyone who has type errors in strongly typed languages.
>>>My editor constantly shows a list of all current
>>>errors and warnings in my code. This way I see the
>>>problems very soon after I make them, which means
>>>I have the relevant code in fresh memory. I don’t
>>>have to wait until I run the program or some unit
>>>tests (after writing them) or whatever.
Nobody write unit tests to catch Type errors. Python already does that for you. So I don’t know what you are talking about. Unit tests are written to catch errors your compiler or editor has no hope of catching.
>>>The only non-trivial bugs I have when I code are
>>>complex multithreading problems where something goes
>>>slightly wrong after a week of uptime. Maybe some
>>>queue that should be empty but isn’t because of some
>>>weird race condition or some cache coherency
>>>problems that are manifested only on powerpc
>>>multi-cpu machines because some vaariable should be
>>>declared volatile but isn’t. Or some problem that
>>>arise only when over 1000 clients try to access
>>>something at the same time and some fifo buffer is
>>>filled and some locks aren’t released in the proper
>>>order so some clients get timeouts or something.
You mean the bugs unit testing catches.
>>>I’m not going to give up my types unless I can see
>>>the minuses clearly outweight the plusses
Increased productivity
Less verbosity
Way less code to maintain and thus less bugs
Better readability
More Powerful Constructs
More Powerful Programming Paradigms
Better Flexibility in Design
Rapid prototyping
and more…
You remind of the ASM programmer who thinks he’s more productive than the C programmer because he can play with registers.
>>>In my opinion “I can’t bother to type so much” and
>>>”it won’t catch all possible errors in the universe,
>>>nor will it walk my dog and bake cakes” are
>>>definitely not outweighting the plusses I see in my
>>>code stability and clarity.
The presence or absence of type information does not make code stable or clear. Otherwise, you won’t be having the bugs you mentioned.
> > Ahem.. this is java:
>
> But alas, I have to maintain legacy Java code.
So it’d be OK for me to claim that python is bad because it had some silly limitations 5 years ago?
> > I could live with inferred types, as long as I can
> > see them whenever I want. I could not live with
> > python-like code where you often have no idea what
> > type of object some variable will point to, without
> > running the code to that point or going deep down
> > the function call rabbit hole.
>
> Python is strongly typed. I don’t know what your are talking
> about. Type information is not needed to write programs.
Of course type info is needed. If you have your getPerms() method that returns a map you have to know if the keys are user-IDs or User instances or what. Assuming it doesn’t use a generic data type then the type info is precisely 100% exactly what you need. You have said that you can decipher this info from surrounding code and looking inside getPerms(), and I’ve said that I prefer to not have to do that.
> > I also refactor my code a lot whenever requirements
> > change, and so I need my editor to know exactly
> > what’s what to be able to move and rename methods,
> > variables and constants and reorder parameters and
> > change return types etc. with perfect accuracy.
>
> Of course, you have to rely on your editor to do a lot of
> this bolier plate nonsense in Java.
So methods, variables, constants and parameters are “boiler plate nonsense” now?
OTOH, AFAIK there exists no python editor that can do perfectly accurate refactoring.
> Unit testing is used to catch semantic bugs not type bugs.
> These are bugs neither your editor nor compiler can catch.
> And no below average programmer has bugs relating the type
> errors.
And I’m telling you that semantic errors very often (in my experience) lead to type errors. Then my editor catches these type errors and then I notice the semantic error. Python will also catch these, but at runtime. I’d rather catch them when I’m editing the related code.
> > When I write python code I read a lot of docs all
> > the time, and yet the resulting code doesn’t work
> > properly.
>
> You should not blame Python for your incompetence.
I’m not blaming python, I’m just saying explicit typing works better for me. Why do you refuse to accept that? Whenever I say something I don’t like about python you say I have to change and whenever I say something I like about e.g. java you say I have to change. Why would I have to change just to support your obviously incorrect hypothesis that dynamic typing is categorically better? Just let me be the way I am if that’s what works for me!
One think I do blame python for is the awful “there are two string types, and they aren’t compatible”-horror it has. Almost everything in my system uses utf-8 so I want to use the unicode string type in python. This leads to a world of pain since I have to adjust everything slightly to make things work. I also can’t use libraries that use the “a character is 8 bits”-nonsense strings. For a language in which, according to you, type info doesn’t matter, or is unimportant, I have to be surprisingly aware of the type of string some object/method/variable/library uses.
(Ruby is even worse with its “the string ‘kö’ has 3 characters”-BS.)
> > And many of my errors in python are type errors,
> > which in turn turns out to be either logical errors
> > or outdated-code-errors.
>
> Learn to write good code then.
Huh? I already write good code, just not in python. Why should I switch to python, that works worse for me, instead of e.g. java, that works well for me? Because you say so? Are you back in that “I know what’s best for you and what you think and what you mean much better than you do”-arrogance mode again?
> > I never, ever have type errors in java.
>
> I don’t know anyone who has type errors in strongly typed
> languages.
I saw one just the other day, in one of the ubuntu packages that used python in its postrm script. It assumed something was of a type it wasn’t and spewed out a runtime error when I tried to remove the package. I had to manually go and edit the script to fix it. Had it used explicit typing the dev would have caught the bug way before it was on my computer.
> > The only non-trivial bugs I have when I code are
> > complex multithreading problems where something goes
> > slightly wrong after a week of uptime. Maybe some
> > queue that should be empty but isn’t because of some
> > weird race condition or some cache coherency
> > problems that are manifested only on powerpc
> > multi-cpu machines because some vaariable should be
> > declared volatile but isn’t. Or some problem that
> > arise only when over 1000 clients try to access
> > something at the same time and some fifo buffer is
> > filled and some locks aren’t released in the proper
> > order so some clients get timeouts or something.
>
> You mean the bugs unit testing catches.
Yeah, it’s sooo easy to write unit tests that run for weeks and use a network of hundreds of distributed clients on different CPU architectures. Yup, sounds like typical unit tests to me..
I have never seen unit tests catch race conditions or cache coherency problems.
> > I’m not going to give up my types unless I can see
> > the minuses clearly outweight the plusses
>
> Increased productivity
I haven’t noticed this. Only that more of the total time is spent debugging and testing.
> Less verbosity
Has done no good for me, except saves a little bit of time where it doesn’t count. (Well, doesn’t count in my book.)
> Way less code to maintain and thus less bugs
I don’t mind having more code as long as I can find what I want faster and have a good structure on everything, which is the case.
> Better readability
I disagree, which should be abvious by now.
> More Powerful Constructs
Which would that be?
> More Powerful Programming Paradigms
Which would that be?
> Better Flexibility in Design
Such as?
> Rapid prototyping
I agree. In fact, I’ve used python for these kinds of small prototypes wherre it doesn’t matter if it spews out a runtime error in the “final” version.
> and more…
I haven’t seen anything significantly better thus far, so just keep ’em coming..
> You remind of the ASM programmer who thinks he’s more
> productive than the C programmer because he can play with
> registers.
They think explicit register handling add readability or are they just control freaks? If the former then I agree, if the latter then I don’t.
And you remind of jehova’s witnesses, although they are much more polite and actually quite nice people.
> The presence or absence of type information does not make
> code stable or clear.
It certainly makes it more clear to me. Also, in my experience it makes it more stable. You have shown nothing that would make me think otherwise.
> I disagree about your opinion between the correlation of
> type information in source code and readability. There’s
> nothing arrogant about that. If you can’t stand differing
> opinions, don’t get involved in arguments.
You just don’t get it, do you? My stance wasn’t an opinion. I stated the fact that I find typed code more readable. I have tried both. Take a step back and try to understand what I’m telling you instead of just arguing pointlessly.
> Type information does not give one all the information
> needed to manipulate objects.
So if the police can’t prevent all crime it shouldn’t prevent any?
It’s true that explicit typing might not provide all needed information, but it certainly provides some of it. In my experience it provides what _I_ usually need. None of this is my opinion. You can’t disagree with this. You can have different experiences and needs and wants, but that’s logically irrelevant.
> I still don’t know how to use “perms” regardless of the
> presence of type information in your C++ example.
So?
If you need more info about the Permission instances then you can get it from the class definition. A good editor will also have code completion and quick-helps and what have you.
(Also, the code wasn’t necessarily C++. I personally prefer languages that easily support more detailed information. E.g., “def ID int:1-max” and then use “ID” instead of just using “int”. This is quite irrelevant to the discussion, though.)
> > I prefer less deciphering and more plain in-your-face
> > information.
>
> Programming is not for you then.
That’s an opinion, and I disagree with it.
> More or less type information does not mean relying on more
> or less documentation.
That’d be true only if type information would provide exactly no information at all. This is false both theoretically and in my experience.
> One is categorically better than the other.
I have already stated the fact that explicit typing helps me, so therefore your statement has to be false. This is not an opinion, it’s a logical fact.
Edited 2007-03-11 16:17
>>>You just don’t get it, do you? My stance wasn’t an opinion. I stated
>>>the fact that I find typed code more readable. I have tried both. Take
>>>a step back and try to understand what I’m telling you instead of just
>>>arguing pointlessly.
You are entitled to your opinion. I am entitled to disagree with them and state the reason why. If you are scared of people criticizing your opinion, don’t share them. Or better yet, share them only with people who agree with them. Feeling offended because I disagree with your stance is childish.
>>>It’s true that explicit typing might not provide all needed
>>>information, but it certainly provides some of it. In my experience it
>>>provides what _I_ usually need. None of this is my opinion. You can’t
>>>disagree with this. You can have different experiences and needs and
>>>wants, but that’s logically irrelevant.
Based on the example you provided, the type information did not provide what you needed. Which is how to use “perms”. Doesn’t that render that your “infallible” opinion null and void.
>>>If you need more info about the Permission instances then you can get
>>>it from the class definition. A good editor will also have code
>>>completion and quick-helps and what have you.
Either way, you still have to look up the docs or source code. Which lends credence to my point on documentation with regards to static or dynamic typing. You are going to eventually look up docs regardless of type information.
>>>(Also, the code wasn’t necessarily C++.
Ah, I thought as much. It looked like psuedo-C++. But I thought it was one of those template syntax I hadn’t seen before.
>>>That’s an opinion, and I disagree with it
OH, THE ARROGANCE!
>>>That’d be true only if type information would provide exactly no
>>>information at all. This is false both theoretically and in my
>>>experience.
I’m arguing type information is almost always irrelevant. Take the example you provided, the type information was just noise. It wasn’t useful. At least not in the context it was provided.
>>>I have already stated the fact that explicit typing helps me, so
>>>therefore your statement has to be false. This is not an opinion, it’s
>>>a logical fact.
You are confusing your opinion with facts and hiding under the classical “it’s-my-sacred-opinion” veil.
> > My stance wasn’t an opinion. I stated the fact that I
> > find typed code more readable.
>
> You are entitled to your opinion.
What opinion?!? I’m telling you no opinion. It’s a fact that I find it more readable. It’s not an opinion, it’s a perception. “Static typing is more readable” would be an opinion. That’s not what I’m saying. Get it already!
> Based on the example you provided, the type information
> did not provide what you needed. Which is how to use “perms”.
Sure it did. I wanted to display all permissions (using my displayPerm(Permission)-function) of the user pointed to by usr. Without any further documentation I now, thanks to the explicit typing, know everything I need to do this. Here:
for each p in perms.get(usr): displayPerm(p)
Now, if getPerms() had returned a Map<UID,Set<PID>> I would have known to write this instead:
for each pid in perms.get(usr.id): displayPerm(getPerm(pid))
Of course I would have had to know that User has an id attribute, but that’s orthogonal to the issue since neither having type info nor not having it helps. That is, except if you try to pass a User instance to the Map<UID,?>.get(UID x) method with a statically compiled language you’ll always get a compiler error instead of possibly a runtime error. (And I happen to prefer the former.)
> > > > I prefer less deciphering and more plain in-your-face
> > > > information.
> > >
> > > Programming is not for you then.
> >
> > That’s an opinion, and I disagree with it
>
> OH, THE ARROGANCE!
Why is it arrogant of me to think programming is for me even if I’d rather spend time thinking about the algorithm than deciphering type information?
> I’m arguing type information is almost always irrelevant.
> Take the example you provided, the type information was
> just noise. It wasn’t useful.
It wasn’t noise to me, and it was useful to me. I know how to use a map and a set and thanks to the type information I know what the map and set contains so that I can actually use the map to get to the set.
> > I have already stated the fact that explicit typing helps
> > me, so therefore your statement has to be false. This is
> > not an opinion, it’s a logical fact.
>
> You are confusing your opinion with facts
No, I’m not. It’s a fact that _I_ find explicit typing more readable. If you claim that _I_ don’t find explicit typing more readable you’re extremely arrogant in thinking you know me better than I know myself. OTOH if you don’t claim that then your claim that nobody finds it more readable is logically wrong, since _I_ find it more readable. So which one is it? (Or if you think there’s an error in my reasoning then point out the exact error instead of throwing vaguely related accusations.)
> “it’s-my-sacred-opinion”
Exactly which opinion would that be? Please provide an exact quote.
You seem to be very confused and very unwilling to try to understand what anyone is saying to you.
Edited 2007-03-12 00:23
>>>What opinion?!? I’m telling you no opinion. It’s a fact that I find it
>>>more readable. It’s not an opinion, it’s a perception. “Static typing
>>>is more readable” would be an opinion. That’s not what I’m saying. Get
>>>it already!
You wrote the following:
“I personally think types add readability”
If that is not an opinion, then I don’t know what is. Saying that I have no right to disagree with that statement is silly. A fact is a statement that is true, objective and obvious to everyone. Your opinion is not a fact, it’s a subjective preference. It’s like me saying the following:
“I personally think text editors are more productive than IDEs”
You have every right to disagree with my statement and provide reasoning to show that my “opinion” is completely flawed or weak. And disagreeing with that statement does not make you arrogant. I’m not going to belabor the semantics of what an opinion is again.
>>>for each p in perms.get(usr): displayPerm(p)
>>>for each pid in perms.get(usr.id): displayPerm(getPerm(pid))
Now you add more context. Which further shows that I don’t need to know the type of “perms”. From your snippet it is obivous to any programmer that “perms” is a mapping (or dictionary-like) object. With more code and more context, type information becomes irrelevant with regards to readability.
Hindsight is always 20/20. You say you know how to use sets and maps, but what if getPerm() returns a customized mapping object. How does
MySpecialMappingPermsObject perms = getPerm()
aid your readability?
How does the type information tell you that this special “perms” object has the “get_perm_from_user” method? And you’d be hard pressed to find statically typed languages that provide introspection capabilities found in dynamically typed languages where you can recover such information without looking up docs.
> > What opinion?!? I’m telling you no opinion. It’s a fact
> > that I find it more readable. It’s not an opinion, it’s
> > a perception. “Static typing is more readable” would be
> > an opinion. That’s not what I’m saying. Get it already!
>
> You wrote the following:
>
> “I personally think types add readability”
>
> If that is not an opinion, then I don’t know what is.
Assuming that’s my original statement (which it should be) the quote is out of context. See the bolded italics below for the context.
Anyway, as I’ve said, and what you even quoted me saying above, that’s not an opinion but a perception. When I look at code with explicit typing I think it looks more readable than without the typing. This is how I perceive code. It’s a fact and you can’t possibly disagree with it. (Similarly you couldn’t possibly disagree with the fact that I like some strawberry ice cream.)
I’m not claiming that anyone else will find explicitly typed code more readable, only that I do. I am the foremost authority on how I perceive things.
The fact that you totally ignore my every statement that the statement you quoted above is not my opinion shows how very arrogant you are. I can’t even begin to understand how you could think that you are the authority of what I mean by what I say.
> A fact is a statement that is true, objective
It is definitely true that I think typed code looks more readable. This is objective, even though at the moment I’m the only one who can know this. If I were to participate in a code readability study then this might be at least partly revealed to others, too, without me having to communicate this fact directly.
> and obvious to everyone.
Uh.. a fact most certainly does not have to be obvious to everyone, or even to anyone. E.g., there are many mathematical facts that are quite the opposite.
> [an opinion is] like me saying the following:
>
> “I personally think text editors are more productive
> than IDEs”
If you make that claim categorically then it’s indeed an opinion, but if you only mean that you find them more productive then it’s merely a perception. Without any context it is impossible to know which one you mean. OTOH, I have given you plenty statements that my “opinion” wasn’t categorical but only my own perception.
It should be extremely obvious that I’m only speaking of my own perception if you read my original statement:
“I can’t speak for the guy making that claim (or for anyone else for that matter), but I personally think types add readability”
> How does
> MySpecialMappingPermsObject perms = getPerm()
> aid your readability?
It tells me immediately the class of perms and if I know the details of that class I immediately know what properties perms has. I don’t have to decipher anything. If it happens that I don’t know the MySpecialMappingPermsObject class enough to use it as I want then it still helps me find the information I need, which is in the MySpecialMappingPermsObject class definition.
> How does the type information tell you that this special
> “perms” object has the “get_perm_from_user” method?
It doesn’t tell me that directly. However, I might remember that MySpecialMappingPermsObject has that method. Even if I don’t I still know exactly where to look for what methods perms has if I need to, again without having to decipher anything. (Furthermore, my editor also knows where to look, so I only have to type “perms.get” and it’ll show me a list of all members of MySpecialMappingPermsObject beginning with “get”. This is also possible in some situations where dynamic typing is used, though. Especially if the typing is inferred.)
> you’d be hard pressed to find statically typed languages
> that provide introspection capabilities found in dynamically
> typed languages where you can recover such information
> without looking up docs
First of all this is exactly the kind of information I want when I write the code, not when I run it.
Anyway, I’m currently writing a lot of java, which is statically typed and still has quite capable introspection/reflection. In the example above I could write e.g. perms.getClass().getMethods() to get an array of all methods in MySpecialMappingPermsObject.
You’re being aggressive and you’re trying to mask it under a victim routine. I hope anyone reading recognizes this.
Unfortunately you’re good enough at it and the thread is too old so you can avoid being voted down (I won’t even vote you down, it’s not belligerent enough).
You are entitled to your opinion. I am entitled to disagree with them and state the reason why. If you are scared of people criticizing your opinion, don’t share them. Or better yet, share them only with people who agree with them. Feeling offended because I disagree with your stance is childish.
>>>You’re being aggressive and you’re trying to mask it
>>>under a victim routine. I hope anyone reading
>>>recognizes this.
Can you elaborate more on this?
>>>Unfortunately you’re good enough at it and the thread
>>>is too old so you can avoid being voted down (I won’t
>>>even vote you down, it’s not belligerent enough).
I don’t contribute to threads to get voted up or down.
>You are confusing your opinion with facts and
>hiding under the classical “it’s-my-sacred-opinion”
>veil.
Mystilleef, I do not want to get tied up in this debate but it seems it is you who is confusing your opinion with facts. Msundman has repeatedly said that he finds explicit variable typing easier to read. For him I am sure it is true, and there are others who feel the same way.
You argue that dynamic typing is better. For you I am sure it is true, and I am sure there are others who feel this way as well.
Personally I find dynamically typed languages better for rapid prototyping and smaller projects, but find code written in statically typed languages easier to maintain. I can see your side of the argument but do not agree that dynamic typing is inherently better.
Msundman is simply stating that statically typed languages are easier for him to read, and I will add to that he is not alone in this opinion. You are arguing that dynamically typed languages are inherently better and that anyone who disagrees with you is wrong and should reconsider being a programmer?
The difference is he is stating an opinion and calling it such. You are stating an opinion and calling it fact and questioning the competence of anyone who disagrees with you. Try and live with the fact that opinions vary and yours is not inherently right.
Edited 2007-03-12 02:50
>>>The difference is he is stating an opinion and calling it such
He stated an opinion that I disagree with. I never said he was wrong or I was right. I said I disagree with his opinion and gave my reason why. But alas, he says I have no right to disagree with his opinion, because his opinions are facts. Have you read the last few comments?
Actually yes I have. I actually have read and been following the whole thread
>>>>I prefer less deciphering and more plain in-your-face information.
>Programming is not for you then.
and
>One is categorically better than the other.
>If I didn’t think so I won’t be having this discussion.
etc… You write as if your opinions were statement of fact and that anyone who disagrees with you is inherently wrong. This is not the first time that you have come across a bit solipsistic, nor do I imagine it will be the last. Your ability to debate is flawed by your inability to agree to differ.
What you have provided, over and over, is an opinion and a matter of debate. You are not debating it though, merely attacking while acting the martyr and honestly it gets tiring.
I’m not going to indulge in your pissing contest.
http://en.wikipedia.org/wiki/Ad_hominem
[Retracted, his earlier statement was pretty vicious.]
He’s not trying to disprove you, he’s actually trying to help you to be a better person…
It might be nice of him to do it in private chat, but OSNews, TMK, doesn’t have that feature.
Edited 2007-03-12 03:24
I don’t feel helped, I feel insulted.
Yea, that’s why I said I retracted it. I read a later comment he had first and it wasn’t very insulting. But his original comment was and he hasn’t yet backed up what he said with quotes from yourself.
I understand you think I am attacking you. I am not. What I am attacking is your method of debate. I have no vested interest in either side, however your posts and verbage made me enter this debate.
What I am trying to point out is that your debating style is not conducive of a constructive conversation. As a person who really does not have a firm opinion in either direction I found your tone and tact lacking.
When someone says “I prefer less deciphering and more plain in-your-face information.” to say “Programming is not for you then” you are insulting another person’s opinion and competence. Programming is a very literal and precise thing, it is not a guessing game or a puzzle.
The nature of a debate is that there are two sides. You hold yours very dearly and I can see that. However if you want to achieve anything beyond argument you need to soften your edge and understand that others do not hold the same opinion. More than that you need to understand, and express in your writing, that your words are your opinion and not a statement of fact. Ultimately it is best if you can come to understand a differing opinions point of view even if you do not agree with it. By the simple act of saying “I see where you are coming from and how it might hold true for you, however I disagree and here is why…” the majority of this thread would have been much more constructive.
The nature of a debate is that there are two sides. You hold yours very dearly and I can see that. However if you want to achieve anything beyond argument you need to soften your edge and understand that others do not hold the same opinion. More than that you need to understand, and express in your writing, that your words are your opinion and not a statement of fact. Ultimately it is best if you can come to understand a differing opinions point of view even if you do not agree with it. By the simple act of saying “I see where you are coming from and how it might hold true for you, however I disagree and here is why…” the majority of this thread would have been much more constructive.
That’s very good advice.
In brief, you don’t like my style of writing. Because it’s not filled
with phrases like “In my humble opinion”, “As far as I know”, “This is
just my perspective”, “In my experience” etc. Perhaps adding one or two
emoticons may have helped.
My writing style is brief and direct, and that may appear “arrogant”. But
because it is not littered with fluff, emoticons, compliments and needless
auxiliary grammatical helpers has little to do with the real
issues which are:
1). “Whether or not dynamic languages are good for writing complex
software”
2). “Whether or not type information in source code aids readability”
People should be free to argue these issues without being reproached for their writing style, looks, or the number of emoticons embedded in the arguments. And better yet, when someone disagrees with a stance nobody
should feel insulted as a result.
Of course, opinions on these issues are based on experiences. But the point of an argument is to seek the truth. It is not to please the sensibilities third parties. You don’t like my writing style. That’s fine. You may not even like the way I look. Again, that’s fine. But neither of these matter.
>>>When someone says “I prefer less deciphering and more
>>>plain in-your-face information.” to say “Programming is not for you
>>>then” you are insulting another person’s opinion and competence.
Programming is inherently about deciphering code! That’s like a bee saying it hates honey. In this business, deciphering and detective work is all you do. Nothing is “in-your-face”. You’ll also be reading a lot of documentations whether or not you like it. So saying “I don’t like reading documentation”, will be equally laughable.
>>>Programming is a very literal and precise thing, it is not a guessing
>>>game or a puzzle.
Are you serious?
Argument is not solely about seeking the truth it’s also about persuading people. You can’t very well persuade someone if you’re offending them because you’ve failed to learn polite discourse.
What you call fluff others call replacing the 70-90% of human communication lost in writing, that being: Body language, tone, and eye contact.
You’ve likened your being reproached for your writing style to being insulted for your looks: This type of reasoning is why you’re being accused of making yourself a martyr.
>>>Argument is not solely about seeking the truth it’s
>>>also about persuading people. You can’t very well
>>>persuade someone if you’re offending them because
>>>you’ve failed to learn polite discourse.
If disagreeing with an opinion is offensive to you or anyone, that’s not my problem.
>>>What you call fluff others call replacing the 70-90%
>>>of human communication lost in writing, that being:
>>>Body language, tone, and eye contact.
Fluff is needless phrases in statements.
>>>You’ve likened your being reproached for your
>>>writing style to being insulted for your looks:
There are parallels. If I had an oral argument with you and your counter argument laments about my accent or speaking patterns, won’t you agree it is best for me to ignore you?
>>>This type of reasoning is why you’re being accused
>>>of making yourself a martyr.
That’s funny. Do you know what a martyr is?
If disagreeing with an opinion is offensive to you or anyone, that’s not my problem.
The offensive part, this time, is that you completely ignored everything I said. I said that argument is about persuasion as much as seeking the truth and so offending people isn’t going to help you. You said that’s their problem for being offended without addressing the fact that it does make it rather hard to convince them when they don’t like you…
Fluff is needless phrases in statements.
Once again, you ignore the argument. I say that what you call fluff others use to indicate things they can’t straight out say due to the realities of human interaction. You ignore that and tell me what you think fluff (a word that means little as a noun) means.
There are parallels. If I had an oral argument with you and your counter argument laments about my accent or speaking patterns, won’t you agree it is best for me to ignore you?
No. If I were telling me some grand scheme and you told me that the gesture I just made is morbidly offensive in your country I would apologize and try to stop making the gesture. In like, if you told me that you feel I’m disrespecting you in my comments (and I wasn’t intending to disrespect you) I would apologize and try to stop doing that.
That’s funny. Do you know what a martyr is?
Obviously you think I don’t. So why don’t you enlighten us all about your definition of martyr.
>>>The offensive part, this time, is that you completely
>>>ignored everything I said. I said that argument is
>>>about persuasion as much as seeking the truth and so
>>>offending people isn’t going to help you. You said
>>>that’s their problem for being offended without
>>>addressing the fact that it does make it rather hard
>>>to convince them when they don’t like you…
I don’t get paid for being liked. And convincing some stranger over the Internet does make me sleep better at night. When knowledge if made available, you have the choice to seek it or ignore it. If you are looking for me to convince you or anyone to seek the truth, you are wasting your time.
>>>Once again, you ignore the argument. I say that what
>>>you call fluff others use to indicate things they
>>>can’t straight out say due to the realities of human
>>>interaction. You ignore that and tell me what you
>>>think fluff (a word that means little as a noun)
>>>means.
I’m not in the mood to argue what fluff is or is not.
>>>No. If I were telling me some grand scheme and you
>>>told me that the gesture I just made is morbidly
>>>offensive in your country I would apologize and try
>>>to stop making the gesture. In like, if you told me
>>>that you feel I’m disrespecting you in my comments
>>>(and I wasn’t intending to disrespect you) I would
>>>apologize and try to stop doing that.
Fantastic! I’m not you. I’m me. I disagreed with you when you said Python is not great for writing complex software. My intention was not to insult or offend you. My intention was to make you aware that there are and have been very complex software written in Python. That’s clearly not an offense by any standards I know off.
Another person said he found type information in source code aided readability. In fact, he jumped into our thread of argument. I didn’t ask for his opinion, but he gave it nonetheless. Well, I responded to his opinion and disagreed with it. Again, I didn’t say anyone was a moron for their beliefs, or that anyone is stupid for their beliefs. I gave reasons I why I disagreed with his opinion. In response, he and you are labeling me as an arrogant insensitive person. Why? Because I disagree with your opinion.
>>>Obviously you think I don’t. So why don’t you
>>>enlighten us all about your definition of martyr.
A martyr is a person who dies for a cause or philosophy (usually a religious, social or political one). As of this moment, I’m still alive, I hope.
> Another person said he found type information in source
> code aided readability.
I’m basing this post on my interpretation that I’m that other person. If I’m not then just stop reading now.
> In fact, he jumped into our thread of argument. I didn’t
> ask for his opinion, but he gave it nonetheless.
I proved that explicit typing does not categorically make code less readable. I did it by providing one example of where it’s more readable, namely in my head.
> Well, I responded to his opinion and disagreed with it.
I have already shown that what you apparently thought was an opinion wasn’t one. Claiming now that it was an opinion is a lie.
> he and you are labeling me as an arrogant insensitive
> person. Why? Because I disagree with your opinion.
I think this is a lie, too, although I’m not 100% sure. I’m 100% certain that _I_ have not labelled you as arrogant because of you disagreeing with any opinion. I won’t comment on what ma_d may or may not have labelled you as and why.
I don’t think he went so far as to seriously question the credibility of anyone who’d disagree with him. He seems to be pretty careful to avoid straight out insulting people (which is a good thing).
Maybe I missed the part where he questioned someone’s competence? I’d love a link if you have one.
I said it posed a problem, that’s a very different statement. However it’s good to know that you are all knowing. Thank you for your grand wisdom, it has truly enlightened me.
As Ma_d already pointed out python is strongly typed. One point I would make is that a combination of unit testing and pyDoc gets rid of many of the “risks” that a non statically typed language may introduce.
Also python now has the option of using Windows Forms or Swing Via IronPython or Jython respectively
Java is heavy and uses much RAM.
for small apps it might be a bit heavy but larger apps its about the same as its native counter parts.
Edited 2007-03-08 00:03
I share the sentiment about the GTK bindings. Sadly, even though there used to be decent ones at http://java-gnome.sourceforge.net/, lately the new maintainers have started a rewrite which seems very closely coupled to GNOME. Might be worth informing them that really a lot of people would like to use Java and GTK but not GNOME…
“I share the sentiment about the GTK bindings. […] lately the new maintainers have started a rewrite which seems very closely coupled to GNOME. Might be worth informing them that really a lot of people would like to use Java and GTK but not GNOME…”
Yes, Gtk is fine, especially with C. Java offers a lot of higher level functionalities than C does, and Gtk is a viable and fast toolkit. So I hope there will be an improvement that does not rely strictly on Gnome, but will be more generic.
That’s probably true. A lot of people do choose Gtk because of how nicely it can be integrated into a non-Gnome desktop.
Python/Gtk seems like a pretty strong choice given that there are quite a few applications using it (Gajim for example).
The problem is that Python is a bit slow compared to java and C#. As for java and Gtk bindings I would prefer if the Gtk swing look&feel was improved so that java apps didn’t stick out like a sore thumb rather than focus on Gtk bindings.
The java swing class libraries are very well designed, and there are probably a lot more developers that know how to use swing than ones that know Gtk, as java is used as first programming language in many universities round the world.
Why not make a swing Gnome and KDE look&feel as well, that way we could have apps that looked resonably good on both Gnome and KDE.
The only downside I see with Java is that it currently is a bit hungry for RAM.
There still needs to be better communication between the JVM and the VMM. Now when the JVM starts doing a full sweep GC it starts accessing a lot of pages that might be swapped out to disk. This thrashing often causes delays of several seconds, which isn’t acceptable in a normal desktop application where the reaction-within-0.1-seconds UI rule holds.
(In fact, I’ve seen IDEA do a GC for one hour, but I guess that’s another story.)
There should be a way to dynamically communicate amount of free system memory to VM so that swapping heap out can be completely avoided.
VMM should be able to ask VM for garbage collection before resorting to swapping.
Besides, VM should be able to “borrow” free memory for caches implemented using weak references. When in need VMM would ask VM to give it back.
More dynamic interaction could be implemented like kernel asking VM to temporarily pin down references to data in some pages before swapping them out so that GC can work without making them dirty.
This would make -Xmx redundant.
These interactions are not really specific to java VM. Any garbage collected system could benefit from such user space interface to VMM.
“Although the .NET vs. Java war is basically over for control of the Windows desktop”
Have you heard about imageJ / jlGui / Jdistro (not developed anymore sighh!!!) and a bunch of useful apps. There is Harmony / BlueTooth APIs and you can wrap many native things in java. And you have good mingw+java cooperation. C# is crap. And there is no Project Looking Glass for it. I must admit Visual Hash and Paint dot.net are useful, but couldn’t they be written in Java?
The war has never started because MS and Slave Companies are forced to use C#. They will also use D#,E#,F#,G# and H# if MS orders it. But open source developers is the battlefield, and freshmeat/sourceforge give an indication.
Java 1.6 + Scriping interfaces is just a dream for a Windows developer. I wish hardware was also crossplatform like Java.
You do realize that 90+% of the software written for the desktop takes place in businesses and not in the consumer realm, right? And in almost all of those cases, desktop software is written using a MS provided framework/language.
> You do realize that 90+% of the software written
> for the desktop takes place in businesses and not
> in the consumer realm, right?
Yes I do.
> And in almost all of those cases, desktop software
> is written using a MS provided framework/language.
That is where you are wrong. A survey conducted by Evans Data Corporation found that Java + Swing is actually the most popular toolkit at least in North America. (http://www.psynixis.com/blog/2005/10/19/java-swing-is-dominant-gui-…)
The reason people don’t see this is exactly the reason you give. Because most of the applications that make Java and Swing the most popular GUI platform are internal business applications, so the general public never sees these Swing applications.
That is complete bunk..where did you get this??? I have been working in Enterprise IT for 12 years and just about everything is written in Java. I would say you are backwards.. most consumer applications I see are written in C++, VB, or .NET, but most business applications are written in C++ or Java. I can’t think of a single application I have used at work since the inception of .NET that is actually written in a .NET language.
C# is a nice language, get over it. I’m not saying “better” or “worse” than java, it’s just a great language, and people is going to use it. And not just because Microsoft forces them, but because -again- C# is a great language. And mono is open source, just like java (not GPL, but open source)
> C# is a nice language, get over it.
I’m not saying it’s not a nice language. It is. But that doesn’t change the fact that mono has serious problems which it is unlikely to ever overcome.
> And mono is open source, just like java (not GPL,
> but open source)
Yeah, it is open source. But like I said, because the class libraries use the MIT license, there is a software patent trap, since any company that makes improvements to the class libraries, or modifications, can patent their changes. With Java, and the GPL, you can’t do that–especially not with version 3 of the GPL which Java will adopt once it becomes finalized. So in the end, for open source, Java is a safer choice. Again, there are no software patent traps with Java like there are with mono.
Potential MIT software patent trap? Then the same happens in X and in BSD-licensed libraries, of which there are many (isn’t TCP/IP?), and the BSD kernels …
What do you mean “especially not with version 3”? Is there, or is there not a risk with GPL2? Because if there is one — because there IS one — all GPL2 code, which includes the Linux kernel, GTK+, Gnome, Qt, KDE and most open source is also in danger. Java, to start with.
The problem of potential software patent trap in MIT-licensed Mono is pure bullshit: software patents are as much of a liability for everything else. You cannot stop using code for fear of software patents, unless you revert to pen and paper (and even then …)
It’s an USA-only problem. The rest of the world (especially Asia) will just keep on enhancing software, leaving USA in the dust when it comes to IT.
Claiming there are or will be no patent traps in Java is silly, since it is entirely possible for Sun to unknowningly implement functionality patented by somebody else. There will always – no matter the license – be a patent trap, if patents are a possibility.
We all know what he meant by “patent trap”. The problem is not accidentally implementing a patented functionality — that can happen with anyone. The problem is that Mono follows .NET, so MS can use its .NET-related patent portfolio anytime.
It’s different with java, as it will use GPLv3.
Edit: and software patents are not be a USA-only problem while there is a constant threat of them being introduced to Europe.
Edited 2007-03-08 16:52
And none of the patents are valid in Europe
They get granted alright but they are not valid in Europe. However patents granted in Europe are valid in USA
The war has never started because MS and Slave Companies are forced to use C#. They will also use D#,E#,F#,G# and H# if MS orders it. But open source developers is the battlefield, and freshmeat/sourceforge give an indication.
There are no such thing as “slave companies.” Java had it’s chance for it’s place in desktop apps and Sun blew that it. All those years of encountering Java applets them made the average user dislike Java. And reinforce the notion that Java is slow as molasse. Don’t go blaming another for Sun’s grotesque incompetence.
And about MS and what people program in… Visual BASIC caught on like wildfire because it was/is the best out there. It still is unmatched. MS took an unknown product and turned it into a tour de force. Most VB’s competitors (CA-Realize, IBM Visual Age for BASIC) gave up. Delphi is MIA. For languages/compilers, no one outdoes MS. They’re still the best.
*shakes head* Sun just doesn’t get it – they keep pushing swing knowing full well the suckage factor that goes with using an interpreted GUI – the speed at which Swing applications are at, you might as well use GTK + Perl for all its worth.
GTK is now the GUI kit of choice on *NIX’s; phone manufacturer’s are now swooning around GTK and Linux for their future phones – so what is the point of Swing when the better choice would simply to move to SWT and be done with it?
Sure, you don’t have perfect ‘write once, run everywhere’ but better to have something that actually has a decent level of integration with the operating system in regards to the GUI than trying to emulate all the operating systems in a half assed manner.
As for the ‘example’ with the calculator, the difference was pretty obvious – massive gaps between the border and widgets, lacking of inherieting the font settings etc.
As for his comparison between C# and Java, its plain stupid, it would be like me claiming that because there are more VB developers than Java ones, it some how makes VB a superior platform?
If Sun want to start making Java the language of choice for future Linux (or *NIX in general) development, then they need to stop pushing the dogma of ‘write once, piss everyone off in the process” and instead realise that when something sucks, drop it, and god forbid, if IBM does actually make a damn good framework like Eclipse, then embrace it!
Heck, why doesn’t Sun drop Netbeans, port the good stuff to Eclipse and work out an arrangement with IBM to bring Notes 8.0 to OpenSolaris? Its about being pragmatic which unfortunately Sun doesn’t have a very good habit of doing – and when they do make that decision, its normally because on the bones of their ass – recent example of that is their final caving in to reviving Solaris x86 in face of the reality that SPARC royally sucks on anything less than an 8 way machine.
> They keep pushing swing knowing full well the
> suckage factor that goes with using an interpreted
> GUI – the speed at which Swing applications are at,
> you might as well use GTK + Perl for all its worth.
You haven’t used Swing lately have you? And you are dragging up and old argument that has not been true for several years now. Java does something called JIT, which compiles byte code down to native code based on intelligent runtime analysis. Swing is no slower these days that any other toolkit.
> phone manufacturer’s are now swooning around GTK
> and Linux for their future phones
They are? Last time I checked, I can count on one hand the number of phones that run Linux. And I can’t even think of one that uses GTK.
> Sure, you don’t have perfect ‘write once,
> run everywhere’ but better to have something
> that actually has a decent level of integration
> with the operating system in regards to the GUI
> than trying to emulate all the operating systems
> in a half assed manner.
First of all, GTK is not even close to perfect write once run anywhere. In fact, it is basically a unix only toolkit. The Windows port of GTK is a joke that is for the most part, unmaintained. Serious bugs don’t even get looked at for over a year, etc. And when it comes to Mac, GTK is non-existent unless you want to run X.
> As for the ‘example’ with the calculator,
> the difference was pretty obvious – massive
> gaps between the border and widgets, lacking
> of inherieting the font settings etc
All of which could be fixed with a little bit of tweaking. The reason the font was different is not because Swing didn’t inherit the system font, but because the GNOME calculator does not use the system font. The GNOME calculator is using a custom font and custom font style, something Swing is fully capable of doing as well.
> it would be like me claiming that because there
> are more VB developers than Java ones
Except there aren’t more VB developers than Java developers. Java is the most popular language in the world. And VB is actually experiencing a sharp decline in popularity–both of these statistics from an Evans Data survey. (http://cld.blog-city.com/evans_survey__visual_basic_and_vbnet_in_st…)
> then they need to stop pushing the dogma of
> ‘write once, piss everyone off in the process”
> and instead realise that when something sucks,
> drop it, and god forbid, if IBM does actually
> make a damn good framework like Eclipse, then
> embrace it!
Swing actually does a better job of looking native than SWT does these days. Even an IBM DeveloperWorks article admits that. And besides, SWT is not the ideal answer either. Because when bugs show up in SWT, you have to fix them on every platform that SWT runs on. And no, SWT is not any faster than Swing.
> Heck, why doesn’t Sun drop Netbeans
Because in many ways, Netbeans has surpassed Eclipse. And again, even an article on IBM Developerworks admits this.
> Its about being pragmatic which unfortunately
> Sun doesn’t have a very good habit of doing
That’s been true in the past. But ever since Jonathan Schwartz took the helm at Sun, he has been turning it on it’s head. Jonathan Schwartz is a strong believer in open source. OpenSolaris will be relicensed under GPLv3 as well. And they revived Solaris x86 because A: Customers wanted it big time. And B: They recognized that Sparc is dead, just like Alpha is dead, and PowerPC is basically dead now as well (with the exception of embedded systems and gaming consoles).
You might want to give Sun another change now that Jonathan Schwartz is at the helm. Even Richard Stallman did. In fact, I quote directly from Richard Stallman: “Richard Stallman: “I think Sun has, well with this contribution, have contributed more than any other company to the free software community, in the form of software. And it shows leadership – it’s an example I hope others will follow.”
Here’s the link the video where he says this, in case you want to watch it for yourself: http://sun.feedroom.com/?skin=oneclip&fr_story=FEEDROOM166554&rf=bm
Edited 2007-03-08 01:54
You haven’t used Swing lately have you? And you are dragging up and old argument that has not been true for several years now. Java does something called JIT, which compiles byte code down to native code based on intelligent runtime analysis. Swing is no slower these days that any other toolkit.
Yes, I know about JIT, its nothing new – but Swing is still slow, still lacking snappiness and still overly complex to create applications with.
Try assigning some widgets to a form, double clicking, assigning code and compiling – you can’t do that with Java; thats how bloody painful Java is in its current form. Little or none have been to make Java a RAD tool, its still overly complex and slow.
They are? Last time I checked, I can count on one hand the number of phones that run Linux. And I can’t even think of one that uses GTK.
Obviously you *DIDN’T* read what I posted – what is it with OSNEWS.COM people not actualy *READING* what people write? I said *FUTURE PHONES!* you know, phones that *MIGHT* be released in the future *SINCE* the development of a Linux industry development group for phones.
First of all, GTK is not even close to perfect write once run anywhere. In fact, it is basically a unix only toolkit. The Windows port of GTK is a joke that is for the most part, unmaintained. Serious bugs don’t even get looked at for over a year, etc. And when it comes to Mac, GTK is non-existent unless you want to run X.
Then what is wrong with having GTK-SWT, Win32-SWT and Carbon-SWT – better that than the ugly mess that is swing and the crap performance that comes with it.
As for ‘not any faster’ – I’ve used Azeurus and Limewire; use them yourself and come back and claim which one is more ‘teh snappy’.
You might want to give Sun another change now that Jonathan Schwartz is at the helm.
I’ll give them 2 years; like I said last year, I’ll give them to the end of 2008 to turn Solaris around; if it is still the same ugly mess along with Java, then I’ll be better off hoping for mono to improve along with FreeBSD.
Like I said previously, when you have software developed by part time coders with better hardware support than Solaris, and development tools developed by enthusiasts which is easier to code with and perform better than Java, one really has to ask what the hell are they doing at Sun.
I’ll give them 2 years; like I said last year, I’ll give them to the end of 2008 to turn Solaris around; if it is still the same ugly mess along with Java, then I’ll be better off hoping for mono to improve along with FreeBSD.
As usual, you persist in making unprovable claims about Solaris such as “ugly mess.” If you were willing to list specific, valid, verifiable, and undeniable issues that can prove that Solaris is an “ugly mess” that are based on fact and not on anecdotal evidence (such as why your wireless or specific laptop doesn’t work), I might believe you.
As usual, you persist in making unprovable claims about Solaris such as “ugly mess.” If you were willing to list specific, valid, verifiable, and undeniable issues that can prove that Solaris is an “ugly mess” that are based on fact and not on anecdotal evidence (such as why your wireless or specific laptop doesn’t work), I might believe you.
Latest stable version of Solaris (Solaris 10 11/06) and my complaints so far – numbered so you can answer to each one of them:
1) Intel 3945 a/b/g support – NDIS does not support it as there is a known issue with it; promises are of plenty in regards to when its going to arrive.
The alternative is waiting for the OpenBSD driver to be ported – it has alread been/currently ported to NetBSD and FreeBSD, with a couple of revisions so far to address WPA support and so forth.
Where is Sun on this? This is one of the biggest selling wireless chipsets on the market – and yes, there are IT people out there who do want to run Solaris on their x86 laptop, and you know, these people might also wish to show off the capabilities of Solaris to their clients.
2) Audio card is not supported; OpenSound is a drama of pain and missery; I can’t hear sound from audio files as they keep skipping around when playing them, no audio comes from cds being played.
3) Ancient version of GNOME is included; not just “oh, its one release behind”, hell, I could put up with that, I don’t expect the bleeding edge, but when a user wants to download CODEC support for mp3 play back, one shouldn’t need to have to download the whole damn toolchain and muddle through only to find that none of it compiles – which goes onto my forth point.
4) How come I can go ./configure on my Fedora box, and I don’t have constant conflicts between the GNU version and one included with Solaris – sorry, there is no way to specify that I want the GNU version rather than the Sun one to be used when compiling.
Paths not being setup correctly right from the beginning, I shouldn’t need to setup weird and obscure paths; if I have installed my development tools in the standard location, I expect to be able to drop down to bash and go ‘make’ or ‘cc’ or ‘c++’ and find that everything just works – I can do that on Linux or FreeBSD, why can’t I do it on Solaris?
Want me to expand more? Maybe I should put up an elaborate ‘whinge and bitch’ section on my blog to point out all the failings of Solaris? this is actually an honest question, would you like that, so then you can address those deficiences.
Latest stable version of Solaris (Solaris 10 11/06) and my complaints so far – numbered so you can answer to each one of them:
I can create a much longer numbered list for Linux. I recently installed it after using Solaris. With the exception of not supporting my sound card, I had fewer issues getting Solaris installed than Linux (I was genuinely surprised). My system isn’t anything fancy, just a home assembled set of stock components, so it is a bit amusing that Solaris was easier to install.
If you wan’t to run Solaris on your desktop, use Solaris Express (think of it in the same way as the relationship between Fedora and Red Hat Enterprise Linux). The express edition comes with proper NVidia drivers, unlike most linux distros. Perhaps that’s why you find Swing slow?
Edited 2007-03-08 09:44
Actually I routinely use Java apps on linux and for about 3 years swing has most redraw issues resolved (at least when using default theme).
In numerous cases I have actually noticed it beating gtk when using similar widgets with scrolling text area being the most glaring example (try comparing large text in jedit to gedit).
If only somebody wrote a working QT backend for SWT…
I know this is more of a testament of gtk architectural problems that swing snappyness but still having reasonably snappy toolkit with so rich architecture, fully drawn by jit vm is a monumental achievement.
I can only fear how decision to use gtk to draw its widgets will affect performance. Hopefully this can be turned off by default.
1) Intel 3945 a/b/g support
Which as I pointed out before, is anecdotal. The support of one piece of hardware cannot in any way prove solaris is an “ugly mess.” It means nothing in the grand scheme of things.
2) Audio card is not supported;
Which again means nothing about Solaris as a platform. The SoundBlaster X-Fi isn’t supported on Linux either, I fail to see the relavance of this to “ugly mess.”
3) Ancient version of GNOME is included;
Which again is irrelevant to “ugly mess” as a platform. Remember that Sun has a business commitment to their customers to binary compatibility, documentation, etc. which all place certain constraints and limitations on versions of software included. Sun has been upgrading and working on integrating the latest versions of GNOME in their internal development versions. However, they are not yet ready to be integrated into Solaris 10.
4) How come I can go ./configure on my Fedora box, and I don’t have constant conflicts between the GNU version and one included with Solaris – sorry, there is no way to specify that I want the GNU version rather than the Sun one to be used when compiling.
Here I know you don’t know what is actually happening. There are no conflicts between Solaris and GNU versions of utilities since anywhere there is a conflict the GNU versions are prefixed with a ‘g’ in their name.
And actually, there is a way to specify which version you want. It’s called using path properly, or using the correct ./configure options. There is also little reason to use the GNU versions with ./configure since it properly support a true UNIX environment. I have compiled many open source programs on Solaris without using any GNU tools at all.
There are many ways for you to setup a completely GNU based build environment if you so choose.
Paths not being setup correctly right from the beginning
Paths are setup exactly as they are supposed to be setup at the beginning. Therefore they are setup correctly. Paths are supposed to be set by the user based on the work they are performing and the type of environment they want to use. Therefore it is your responsibility to configure them as appropriate for your needs.
Users that want to compile and build their own tools are expected to select the appropriate environment using the path. This meets with UNIX and POSIX standards as well as Solaris backwards compatibility and other requirements.
Want me to expand more?
Yes, since so far everything you’ve had is a matter of personal preference, something that is not a problem or bug, or something that is merely anecdotal evidence. Nothing you said has in any factual way made me believe that Solaris is an “ugly mess.” In fact, you have only proven that you don’t understand the UNIX platform. Linux is NOT UNIX, and therefore does not provide a true UNIX development environment; nor is it fully POSIX compliant, unlike Solaris.
“Try assigning some widgets to a form, double clicking, assigning code and compiling – you can’t do that with Java; thats how bloody painful Java is in its current form. Little or none have been to make Java a RAD tool, its still overly complex and slow. ”
what the hell does this have to do with Java as a language or platform?
However all of this is possible in matisse.
what the hell does this have to do with Java as a language or platform?
However all of this is possible in matisse.
Again, you seem to suffer from osnews-a-litus – the affliction of replying to posts with out actually reading the bloody thing.
I said that Java as a language was complex and over engineered – and gave an example of how its gotten to the point that you can’t do something as basic as assigning code to widgets.
I said that Java as a language was complex and over engineered – and gave an example of how its gotten to the point that you can’t do something as basic as assigning code to widgets.
Except for the obvious that your claims are bogus. Kids in programming 101 can put together an app in Java. Perhaps you need to get some training
Yes, I know about JIT, its nothing new – but Swing is still slow, still lacking snappiness and still overly complex to create applications with.
It sounds like kaiwai needs to upgrade his 486!
I have had no problems running swing on any recent hardware. It you are finding it slow then you either have an old machine without much RAM, an old JDK, or very inefficient display drivers.
If you “know” about JIT why do you still keep talking about “interpreted GUI”?
Try assigning some widgets to a form, double clicking, assigning code and compiling – you can’t do that with Java; thats how bloody painful Java is in its current form. Little or none have been to make Java a RAD tool, its still overly complex and slow.
We’ve had that feature in Netbeans since version 5.0 (over a year ago). Perhaps if you weren’t so obsessed with Eclipse…
And like a large number of people on osnews.com, you never read the post or the follow up posts relating to what I write.
Here is a tip; read, think, think, think, and think again THEN think about what you’re to write, write it, read it, then think think think, then post.
JIT still results in the delay between excution and the result – the result is a sluggish gui no matter how the problems are coded around.
As for “Netbeans since version 5.0” I doubt it, I’ve used 5.0 and its just as bad as previous versions; I can’t stand Eclipse but atleast there is something being yielded out of it in the way of a decent collaboration tool vs. the out of date rubbish bundled with Solaris.
And here is a tip for kaiwai : Please engage brain before typing a reply.
JIT still results in the delay between excution and the result – the result is a sluggish gui no matter how the problems are coded around.
JIT occurs at startup, not everytime you click on a control. .NET, Mono, and Java all use JIT.
I doubt it, I’ve used 5.0 and its just as bad as previous versions
I find your claims hard to believe. Anyone who can use VB 6 can put together a GUI with netbeans 5.0.
*shakes head* Sun just doesn’t get it – they keep pushing swing knowing full well the suckage factor that goes with using an interpreted GUI – the speed at which Swing applications are at, you might as well use GTK + Perl for all its worth.
Just because Swing doesn’t meet your purposes does not mean that it doesn’t meet Sun or other people’s purposes.
I think Sun “gets it” just fine.
As far as SWT? That has its own fair share of criticisms which I won’t bother covering since many other people have already more than adequately stated what its problems are.
Heck, why doesn’t Sun drop Netbeans, port the good stuff to Eclipse and work out an arrangement with IBM to bring Notes 8.0 to OpenSolaris?
Maybe because there are a lot of people using NetBeans that really like it, like *their* customers? You do realise that the usage of NetBeans has *grown* significantly the past few years, right?
Why would they drop a product that is very popular, has a growing community, and that their customers want? That makes no sense.
…recent example of that is their final caving in to reviving Solaris x86 in face of the reality that SPARC royally sucks on anything less than an 8 way machine.
“caving in” ? I fail to see how a decision that made *years* ago now can be defined as a “recent example”, nor do I see how you qualify it as caving in.
You also seem to be severly outdated in your performance analysis of Solaris and Sparc if you believe that Solaris “SPARC royally sucks on anything less than an 8 way machine.”
The right tools for the right job.
I think Sun’s significant turn around not only in image, but in hardware and otherwise proves that they’re doing better than you claim.
You also seem to be severly outdated in your performance analysis of Solaris and Sparc if you believe that Solaris “SPARC royally sucks on anything less than an 8 way machine.”
Look at the Specint and specfp benchmarks of SPARC vs. AMD64/Intel Core 2, and compare prices; x86 still give the best bang for the buck, especially when it comes to workstations.
http://shop.sun.com/is-bin/INTERSHOP.enfinity/WFS/Sun_NorthAmerica-…
$2895 for a low end, single core UltraSPARC IIIi workstation that gets its ass handed to it on a platter by a lower priced Opteron machine being sold by Sun? please. Price performance wise, UltraSPARC always come out worse.
Maybe if they shaved $1500 off the price, it would be in the realms of being realistic in regards to price/performance, but the amount demanded is simply unrealistic – wake up Sun, the days of expensive UNIX stations are long gone.
Compare the servers, an Opteron 4 way dual core machine to a similarly configured UltraSPARC machine – the x86 like the workstation will always outperform – the only saving grace for UltraSPARC is the fact can scale, but when you performance sucks that badly, you need all the scaling you can get your hands onto.
“*shakes head* Sun just doesn’t get it – they keep pushing swing knowing full well the suckage factor that goes with using an interpreted GUI – the speed at which Swing applications are at, you might as well use GTK + Perl for all its worth. “
Interpreted GUI??? Java has used a JIT compiler since the late 90’s. It beats Microsoft’s CLR 2 (used by .NET 3.0). Mono has the worst JIT compiler around.
Look at the benchmarks. Java smokes Mono into the ground:
http://www.shudo.net/jit/perf/
For the record Swing painting has had hardware acceleration since JDK 1.4 released in early 2002. Swing on JDK 6 for Linux has a very efficient OpenGL drawing pipeline.
Please refrain from making comments about something you clearly know very little about.
Edited 2007-03-08 09:05
These benchmars are at least 1.5 year old. As all VMs are doing a constant optimization overhauls, they are meaningless today.
Heck, why doesn’t Sun drop Netbeans, port the good stuff to Eclipse
Are you high??
*Groan*. Eclipse is a pain, it doesn’t provide half the features of Netbeans, unless you go shopping for endless commercial, proprietary plugins.
Eclipse is surviving on its reputation from 2001, when Netbeans used to suck. Since the release of Eclipse, Netbeans has improved dramatically, it has now surpassed Eclipse in terms of features and usability. The dramatic rise of Netbeans (triple digit annual growth in user numbers) should give you a hint about its popularity! I don’t want to use Eclipse, I don’t like Eclipse, and in 2007 it’s primitive compared to Netbeans.
With the open sourcing of Java under the GPL, Sun has removed that final barrier to entry, since all of the performance, or “it doesn’t look native” arguments are no longer valid.
How does a switch to GPL invalidate performance issues?
And this “Mono lagging behind MS .NET” logic doesnt make sense to me either. Just write for Mono an be assured that your code runs on Mono and .NET.
Slightly biased . . .
He didn’t say that. He said that it was solved and that licensing was the last barrier to entry, they’re independent of each other.
Mono is going to lag behind MS .Net. I’ll be surprised if they ever get to the point where they’ve implemented 99% of what MS has and the 1% they’re missing isn’t something crucial to a huge number of people.
Assuming Microsoft stays with .Net at the pace they have for the last 6 years.
He didn’t say that. He said that it was solved and that licensing was the last barrier to entry, they’re independent of each other.
Thanks for clearing that.
Though I wonder if the performance issues are really invalid. Imagine a window manager, session manager, and all other components of the desktop written in Java. 🙂
Mono is going to lag behind MS .Net. I’ll be surprised if they ever get to the point where they’ve implemented 99% of what MS has and the 1% they’re missing isn’t something crucial to a huge number of people.
Assuming Microsoft stays with .Net at the pace they have for the last 6 years.
Mono is always going to lag behind .NET but thats not going to be a problem. Lets look at the situation now. Write code for .NET 1.1 and theres no need to care that MS .NET is at 3.0 and Mono is at 2.0.
> Though I wonder if the performance issues are
> really invalid. Imagine a window manager,
There actually are a few window managers written in Java. And really, there are no performance issues with them at all. Again, keep in mind Java does intelligent runtime analysis and looks for areas of code that are too slow, and then compiles those down to native code.
Remember that a typical computer program spends 95% of its time running 5% of its code. So the deal is optimize that 5%, and don’t worry much about the rest of it.
Like project looking glass?
Here are a couple more traditional window managers written in Java than project looking glass. They aren’t full blown desktop environments, and most of them are in early stages. But they are examples:
JD4X: http://jdx.sourceforge.net/
Jesktop: http://www.jesktop.org/
Hello,
As it turns out, you do not need to implement 100% of Microsoft.NET to port a lot of applications. We found out with Moma (google our web site) we will be able in the next three months to bring 700 applications to Linux that have been reported to us through Moma (this is without making any changes to the apps).
From the remaining half of the applications (based on the sample of 1,700 or so results that have been submitted), its roughly 1/3rd split over less than 10 changes, between 10 and 40 changes, and more than 20 changes (by changes I mean, P/Invokes that will have to be redone).
So one sixth of the .NET applications today wont ever be ported, another sixth will require a strong commitment to port, another sixth trivial changes and the other half would port with trivial changes to Mono.
The numbers are estimates from memory from the results that I collected for my FOSDEM presentation.
Miguel.
> So one sixth of the .NET applications today wont
> ever be ported, another sixth will require a
> strong commitment to port, another sixth
> trivial changes and the other half would port
> with trivial changes to Mono.
The only problem with this, is a lot of those applications that will require “trivial” changes, will be closed source. Expect a lot of the software written for .NET to be closed source. So you won’t be able to port it even it would only require trivial changes. Don’t count on MS Office.NET running on mono any time soon.
I wouldn’t count on MS Office.Net anytime soon.
Yea that’s great and I’m not arguing against it. I’m just pointing out that Microsoft has a head start on features anytime they want to have one and they’ve got a lot more resources than Novell.
And right now Mono is finishing up 2.0 compatibility while Microsoft is rolling out 3.0, correct?
It does seem that Mono will forever be a step behind. Which is fine.
Mono is a copy of a copy.
Java is where the action is in Computer Science.
Microsoft is dead last in implementation.
Examples:
– CheckedExceptions? — Dot Net still waiting for that Spec sharp.
– Unix File permissions — Windows has none, the Windows trolls TALK about ACL’s but NEVER Impliment them, Even with the ORACLE install the Oracle Windows team let EVERYBODY Walk All Over the Oracle Data area.
In OS X, Linux and Solaris you create an Oracle User and Group and NOBODY can touch the Oracle data areas.
– OS X ( su ) temp root user privilege — Windows? We can Turn It OFF, and Windows Geeks are RECOMMENDING turning it off.
– Visual Studio 2005, STILL can’t mix C# and VB in the same project!!!
Here’s the real “Innovation” in C#
Java throws an InvalidIOException
C# throws an IOException.
C# was designed for and by THE GUYS WHO WON’T LEARN TO TYPE.
I think it’s a hiring requirement, if you know how to type you can’t get a job in the Microsoft Language Department.
Java has getter and setter methods, C# has properties, again, quicker to type, but getter and setter methods SORT TOGETHER yielding day to day Better Productivity! Java was designed by professionals ( who can type ).
But, the real fun is running Solaris 64bit and Java on a Mac with VMware Fusion. Actually WinXP-64bit runs nicely as well.
You can sort based on more than alphabetical order…
I do believe one of the features on the list for the next version of Java is syntax for quick access to getters and setters a la properties
.
Java also has an IOException: http://java.sun.com/j2se/1.4.2/docs/api/java/io/IOException.html
The results from that particular Evans survey seem bogus, the same results placed “Avalon” at two digit usage in the Spring of 2005 (???).
The report has other anomalies, for instance Windows.Forms does not appear on the table of GUI toolkits used (where Swing comes ahead) but GTK+ shows up in the list. Probably the question was “GUI toolkit s for cross platform development”.
In the actual cumulative table the results for Swing are not very good (page 195), and the results are pretty consistent.
Miguel.
Yeah Mono is crap, look all this crap software…
http://beagle-project.org/Main_Page
http://banshee-project.org/index.php/Main_Page
http://f-spot.org/Main_Page
http://www.gnome.org/projects/tomboy/
Java is cool! We have.. Ahn.. Limewire? Azureus? Eclipse? Netbeans?
> Java is cool! We have.. Ahn.. Limewire?
> Azureus? Eclipse? Netbeans?
I would add the desktop version (not the online version) of ThinkFree Office to that list, which in my mind, is a shining example of a truly excellent desktop Java application. It’s responsive, fast, and looks great.
http://product.thinkfree.com/desktop/ if you want to check it out. It’s not open source or free. But they do have a free evaluation version that is fully functional.
Anyway, I probably won’t be following this thread anymore. I have a lot of other stuff to do… Like writing desktop software… In Java
Edited 2007-03-08 03:19
Java apps we have:
-JEdit
-JDiskReport
-Netbeans
-Eclipse
-Limewire
-Azureus
-Maple
What does mono have… Ah… beagle? banshee? fspot? tomboy? each of these apps could be written by a competent Java programmer in a weekend.
So… Why they haven’t?
Java is too much talk, to little action.
How many years it’s been there? Where are the “killer” apps? Mono is new, and there it is, a lot of cool and useful apps and for LINUX. Isn’t that kind of software that linux needs to convince the average Joe to switch ( or at least try it) ?
So… Why they haven’t?
JAlbum: Java photo album app(looks a lot better than FSpot)
http://jalbum.net/skins/
Has been downloaded over 2 million times!
As for the others, I’ve never used Tomboy or beagle and I’ve never heard of banshee.
You missed a bunch =)
Here are a few that come to mind off the top of my head:
Visual Thesaurus
http://www.visualthesaurus.com/
Very cool application. Looks good too.
DbVisualizer
http://www.dbvis.com/
My favorite SQL editor hands down.
Oxygen XML Editor
http://www.oxygenxml.com/
IMHO the best XML editor out there.
Lots of reasons, and not to start a fire, but… Java on slower platforms is a mistake. Not everybody has a game machine. …and Java is not the language the hype suggests. It gets pluses for GC and string overrun protection, but a lot of minuses in the arcane department. It is too heavyweight. The world is ready to move past C/C++/Java for desktop app development. Sorry if I offend, but that’s how I see it. (No, I’m not MS. I’m a Python bigot. 😉
I totally agree! The biggest changes in computing and in Linux usage are smartphones and, especially, the OLPC 100€ computer. MILLIONS of users are going to be using hardware which is very low on resources, running Linux and GTK+.
OLPC users will use the platform to get reading and writing skills, as well as to learn programming. Java, and especially Swing, suck badly on this platform!
As for smartphones, the numbers might be higher, but the ratio of programmers will be a lot lower. In any case, a horrendous platform too for Java/Swing (and don’t mention Java ME, because it is a joke that is useless for anything but the simplest games).
Opera Mini.
People seem to believe Java and C# are worlds apart, they’re NOT. Look at IKVM and Jacil, they can recompile Java bytecode into .NET CIL, and vice versa, you don’t even need the source code.
There probably won’t be a clear winner, and we may even see them working together in the future.
that the same people who wouldn’t support KDE because of QT are perfectly willing to ignore the patent issues with .NET. I’m not a KDE troll either, I’ve been using gnome 40hrs a week since the first release.
Java might not be a great desktop language but it has lot’s of other areas where it really shines. At the company I work we use Java a lot on main frame computers, AS400 computers, web stuff.
and no .. I’m not a Java person. SQL Server developer.
Wow, being a hard core eclipse developer for so long, I finally decided to try netbeans, to see just how easy it is to build a swing app.
I am very impressed! Netbeans is very zippy (better the Eclipse), and there Design view puts me in mind of visual basic, in that it’s really simple to put a form together, and get it lined up nicely.
For my next intRAnet application, I’ll definitely be using NetBeans with Swing!
Even now, the tools and languages we have available for creating desktop applications are extremely poor. Adobe and Microsoft are on the right track with Flex and WPF respectively, but where are the equivalents in open source? I’ve been waiting for an open and scriptable SVG browser for years now, and Firefox still hasn’t delivered.
While these tools are great for telling a computer what to do when all the variables are known, they still for the most part fail to address HOW a user interacts with a computer. For Linux to win on the desktop in any way at all it needs to be more like the Wii, and less like the Playstation 3.
And to take the desktop now, Linux also needs to be able to handle interaction beyond the mouse, such as ink, touch, and voice, which are becoming increasingly important and patent encumbered. Yet without a unified API in some form (say part of the Java standard), Linux will not be able to compete with commercial solutions (or at least not as an open source product).
I want to use Java. To be honest, I regret that I chose C# as the language for our internal business application one year ago. However, I made the decision based on the following then valid points:
* Visual Studio. It may have bugs (I’ve found more of them lately), but it’s absolutely lovely to work in. Especially UI development is extremely straightforward and easy.
* Swing. Although NetBeans have made it much easier to create UI quickly, there were many quirks the last time I evaluated it. For example, the AbsoluteLayout that I wanted to use in order to overlap some controls was making the application crash occasionally.
* Previous experiences with Visual Basic. Having developed software in VB6 for several years, the transition to C# was not hard.
* Uncertainty. I simply didn’t have time to make the necessary research to verify that OPC communication, database communication (including existing Access 2003 .mdb-files), and XML serialization were going to be as simple and straightforward as it is in .NET.
The last point still holds true. I simply know too little about the available classes in Java to estimate whether or not using Java would mean more implementation work. But one thing is true: I really appreciate all that Sun is doing right now and I will take a closer look at Java again.
>>
Java is where the action is in Computer Science.
<<
Great claim! Now, let’s see how you back that up…
>>
Microsoft is dead last in implementation.
Examples:
– CheckedExceptions? — Dot Net still waiting for that Spec sharp.
<<
Checked exceptions are, in my experience, of questionable value. Not only do they result in more typing overhead, but programmers are more likely to want to distill them down to something common denominator, like Exception. All too often I see that Java programmers, wanting to avoid a throws clause, will try and seek ways to get around it altogether, defeating its supposed purpose.
>>
– Unix File permissions — Windows has none, the Windows trolls TALK about ACL’s but NEVER Impliment them, Even with the ORACLE install the Oracle Windows team let EVERYBODY Walk All Over the Oracle Data area.
In OS X, Linux and Solaris you create an Oracle User and Group and NOBODY can touch the Oracle data areas.
– OS X ( su ) temp root user privilege — Windows? We can Turn It OFF, and Windows Geeks are RECOMMENDING turning it off.
<<
We seem to have jumped the rails. What does the file system have to do with either Mono or Java? You lost me here. If you are using Mono under any of these systems, it is not like it is going to allow you to magically work around the file system’s conventions and priviledges.
>>
– Visual Studio 2005, STILL can’t mix C# and VB in the same project!!!
<<
Haven’t tried it. I know that with Mono though, I can certainly mix code from all sorts of different languages. Want your C# class to inherit from a Java class? No worries. Want Nemerle and Boo and IronPython objects all working in concert? To the best of my knowledge, there is no problem, provided you have the assemblies for these languages. I do not use Windows so I cannot speak for VS5.
>>
Here’s the real “Innovation” in C#
Java throws an InvalidIOException
C# throws an IOException.
C# was designed for and by THE GUYS WHO WON’T LEARN TO TYPE.
<<
So you feel that InvalidIOException conveys more inherent meaning than IOException? Well chalk one up for you. Personally, I think we’d all do a bit better if we could have a ReallyUnfortunateInputOutputPerturbanceException, but that’s just me being snarky.
>>
I think it’s a hiring requirement, if you know how to type you can’t get a job in the Microsoft Language Department.
<<
No, that’s a general statement about programmers. Most people who program are under tight deadlines and take as many shortcuts as humanly possible. Why spell something out when you could abrv ur msg dwn?
I in no way support this practice, it is something I abhor, just like the use (abuse) of hungarian notation. Whoever the Hungarian was that came up with that ought to be taken to the woodshed.
In working with both Java and .Net APIs, I have never once said to myself ‘gee, those Microsoft/Mono guys were obviously desperate for a shortcut with that one’.
That said, my overall feeling with Java and especially the J2EE stack is that there is a philosophy of ‘why do in 5 classes what you could do in 30’. Whereas the .Net APIs seem compelling because they are so straight forward, Java seems to love the baroque. I can handle this in my classical music selection, not so much so when I have to program a solution to something.
>>
Java has getter and setter methods, C# has properties, again, quicker to type, but getter and setter methods SORT TOGETHER yielding day to day Better Productivity!
<<
Better Productivity?
Is this some sort of hideous joke?
Over the years I have had to live with this Better Productivity of which you speak when writing Java. For some reason, it has turned into one of the aspects of the language that I hate the most. But it would be unfair to proclaim it either great (your view) or as sucking chunks from a sewage pipe (my view) without comparing and contrasting code:
setSomeValue(getSomeObject().someMethod(getParameter()))
vs
someValue = someObject.someMethod(parameter)
The key difference is not merely one of saving some typing. If I have to confront both of these expressions, it is much harder to parse what the first is trying to do than the second. Since nothing is gained by the first over the second *except* more typing (and therefore greater chance of syntax error) how you figure that getter/setter style accessors are more productive is beyond me.
As far as ‘sorting together’, what are you going on about? Accessors (getter and setter) are two sides of a single property in a language like C#. In Java, they are two distinct functions. Please explain yourself.
>>
Java was designed by professionals ( who can type ).
<<
As illustrated in the comparison above, there is nothing inherently professional about adding all sorts of typing overhead. It just obscures what you are trying to say. The impact on development, maintenance, refactoring, etc. would lead me to believe that the approaches you are so eager to champion are the antithesis of professional language design.
>>
But, the real fun is running Solaris 64bit and Java on a Mac with VMware Fusion. Actually WinXP-64bit
<<
Stunning conclusion or worthless factoid? I’m afraid I can’t tell.
Here are some things for you to ponder when it comes to Java -vs- Mono/.Net:
– Opening Java will prove a wonderful thing for Mono. The IKVM project, which allows Java byte code to be run by Mono has always been hindered by Java not being fully open. Now that this barrier is gone, I can have the best of *both* worlds while working in any (or many) of the broad range of languages supported by Mono/.Net. This is a win-win situation all around.
– Java as a language is playing catch up with .Net. This is no idle boast. Before .Net came onto the scene Java was slow to add anything. Now they are in a reactionary state trying to add the language extensions that are already making .Net users much more productive. That should tell you a thing or two about the alleged ‘design professionals’ behind the Java language.
– XML support and web services are so much easier in Mono/.Net than in Java that it is not even funny.
– Assemblies have no real analog in Java. Jar files are nice, but where is the versioning? Developers have to resort to things like osgi in order to be able to develop reasonable plug-in systems for instance.
There are many other features that you should look into about Mono/.Net before proclaiming how Java is so much better. The fact of the matter is that I can be much more productive today in Mono than I was ever able to using Java.
>>
For Linux to win on the desktop in any way at all it needs to be more like the Wii, and less like the Playstation 3.
<<
So if I read your analogy right, Linux on the desktop doesn’t need to be at all cutting edge, it just needs to be cute and offer nunchucks?
Maybe you should think about giving Zelda a break for a while.
I’m pretty sure what he meant by the Wii analogy is that the Wii has been successful because of its simplicity and intuitiveness. It managed to take gaming to a place where no other gaming console has gone before:
1. Most Women
2. Seniors
3. Basically all non-gamers
After watching my Mother in Law and my 70 yr old father play Bowling (when neither has ever played a game console before), I have witnessed this first hand.
So Linux has to be dumbed down for mass consumer acceptance.
I’ve always thought that Java and Linux should go together like cookies and milk. The only barrier, up until recently, was Java licensing, and OSS devs being reluctant to accept the old Java licensing. Now that Java is going GPL, there are no problems.
And I think that both Java/Swing (with Netbeans, Matisse and NetBeans platform) and Eclipse/SWT/Eclipse RCP present truly awesome alternatives for desktop development. Then there is also the forthcoming QT Jambi, which looks very very promising (QT is an awesome toolkit, and combining it with Java should be great). And, of course, Java-Gnome is being re-written from scratch, hopefully to greatly improve Java/GTK bindings.
And it seems that both Swing and SWT are gaining traction very rapidly, particularly in the corporate apps, but also in commercial apps and open source apps.
Developers, and ISVs, and corporations, are wanting to move more and more to cross platform solutions, to avoid vendor lock-in, and to be able to leverage more of their IT investments together.
And as both Swing (with Matisse and NetBeans platform) and SWT (and Eclipse RCP) continue to improve, their offerings just keep becoming more and more attractive.
As for NetBeans vs Eclipse, I think they’re both great. However, for ease of development and overall bundled features, I think NetBeans has leap-frogged ahead of Eclipse.
As for Mono – it’s very nice. I like the GTK# bindings, and it’s being used for some good Gnome apps. Mono is also serving a purpose of .Net to J2EE migration, in the form of Grasshopper from Mainsoft. It’s also serving a purpose of some MS only shops taking a serious look at Linux because they can now port their apps.
In short, I think the MS/.Net/C#/Win32 stranglehold on desktop development is gradually dying, being replaced by great Java alternatives. And I also think Linux desktop devs will increasingly use Java, due it’s constant improvements, and GPL licensing.
Almost every application we use at work is written in Java, either Swing or SWT. And these are third party applications not just things we write here… in fact I don’t think we use a single application written in .NET… and this is a huge government contract with multiple venders… so what is this about Java having lost the battle for the Windows desktop???
I think the assumptions is based on the fact that .NET will be available on all Windows platforms, and .NET framework will eventually be the framework of choice for Windows applications.
The assumption is rather optimistic given how long it took for the original win16 to win32 migration – add to that, what are the benefits; if they want multi-platform, there is Java – so how can Microsoft justify re-writes of applications (or atleast partial) given the next to no tangiable improvement.
I think the assumptions is based on the fact that .NET will be available on all Windows platforms, and .NET framework will eventually be the framework of choice for Windows applications.
Yeah, that’s why .NET is/will be the platform for the vast majority of windows programming.
The assumption is rather optimistic given how long it took for the original win16 to win32 migration
It wasn’t that long. Everybody wanted to get away from win16 as soon as possible.
add to that, what are the benefits; if they want multi-platform, there is Java
Most windows developers don’t care about multiplatform.
so how can Microsoft justify re-writes of applications (or atleast partial) given the next to no tangiable improvement
They don’t re-write unless there is a good enough benefit. Visual Studio is a perfect example. Gradually, parts of it are rewritten in managed code.
Sun has always had two big problems with regards to their promotion of Java. One is that they never seemed to grasp that to some people the JVM and libraries are more important than Java (the language). The second thing is that they’ve always continued to pimp Swing as the ultimate answer to the GUI.
Sun employees contribute to Gnome, but have they ever even sponsored anyone to work on Java-Gnome bindings? Not that I recall, but correct me if I’m wrong. But Sun never seemed to grok that nobody wants Swing next to the native GUI. I suspect some at Sun have realized it, but political forces within the company have always supressed it in order to pimp Swing. Hell, for years Sun didn’t even care about the desktop. They found their niche on the server, and was happy with that.
Sun also never realized that people (especially in the open source desktop world) are interested in other languages on top of the JVM. It’s always been about Java (the language), instead of Java (the platform). .NET/Mono has always been better in that regard.
So years ago Sun could have open sourced Java and Mono would have had no traction. Years ago, Sun could have realized that people don’t want Swing on their desktops. Years ago Sun could have sponsored alternative languages for the JVM.
It’s too late at this point. Open sourcing Java isn’t enough to gain traction at this point.
As far as I’m concerned, Java does not exist on the desktop now. Of the hundreds of applications I’ve used over the years on the “Linux desktop”, there has only been 1 Java app: dimsum (a chinese language tool). Oh and there was ArgoUML which I’ve played with a bit in the past. And my impression of ALL java programs (desktop and otherwise) are not good, they always use up at least 150-300MB of RAM and have long startup times even for the simplest apps. Even Perl/Python/Ruby apps are much better in those two aspects.
It is a debate as to whether the memory requirements and cpu utilization is worth it. I can understand these objections to a degree, though I feel that Java is viable on the desktop. But I do object to your characterization of Java’s memory usage. Java memory usage is higher than a C application, but not THAT high.
Let’s take some examples of fairly heavy apps:
1) Eclipse with the following plugins WTP, TPTP, MYLAR, LDAP, Quantum DB, Subversive SVN, SpringIDE, CDT, and AspectJ. I do not know the exact size of the projects but I have the entirety of JXTA in my current workspace and I assure you that is a significant amount of code. Memory usage: 126MB. (With a lot of editors and extended use it sometimes grows to about 200-250 MB, but 126 MB is my usage right now as I am winding down my day.)
2) JBoss 4.05 running 4 moderate sized applications: 148MB
3) Netbeans: only the SVN plugin and 3 smallish projects (~15K lines of code): 178 MB
And a lighter app:
4) jxplorer: A fairly simple LDAP GUI: 33 MB
With the exception of jxplorer none of these apps are what could be termed “light weight” but only one exceeded what you termed the least amount of RAM that a Java app uses. That is blind dismissal of the platform for reasons that just plain are not valid.
The machines I use are fairly powerful (1.6 GHz CoreDuo Laptop, a 1.4 GHz Pentium D, and an E6400 Core2Duo desktop) but I do not have much problems with startup time. The only application that I note taking a long time to load is Amarok. (likely due to my use of XFCE4 instead of KDE.)
I grant that I do not use Java too much on the “Desktop” except for Eclipse. This is simply because the Java applications have not been the ones that filled my needs. On a low memory machine (under 256 MB) I would probably hesitate to use a java GUI application, but not a cli one.
On a low memory machine (under 256 MB) I would probably hesitate to use a java GUI application, but not a cli one.
I’d be curious if that’s limited to Swing or if it includes SWT as well? It appears to me that SWT applications eat about 20MB minimally (rought estimate, probably varies quite a bit on different platforms) which is actually fairly competitive with C# application sizes.
I would tend to limit use of a java based GUI in 256 MB of RAM regardless of whether it used SWT, Swing, or AWT. While SWT might be a little better on memory consumption I do not find the difference between the three that significant. I would put c# (except CF) in the same boat.
I like Java and use it quite a bit, but memory constrained environments are not the forte of desktop Java.
My guess is that this open sourcing of Java is a part of a Troll Tech/QT style double licensing program with the GPL for F/OSS Java development and a separate payment based license for closed source Java development.
GTK with its LESSER or LIBRARY GPL licensing allows for free closed source development under certain conditions
and would therefore be incompatible with such a licensing program. I think this is why Sun is not considering GTK for the Java/Linux GUI platform but is sticking with Swing which is theres and can be put under the double licensing program with the rest of Java.