 |
Wrong
Posted by invalidname on August 14, 2007 at 08:42 AM | Comments (8)
How to describe the pro- and anti- language change camps?
I think you are doing a disservice to the cause of no language changes by labeling us as "conservative" in general and defining language changes as "innovation".
I wasn't sure if the term "conservative" would be too politically loaded to use to describe those who are generally against the proposed Java 7 language changes, but this comment on yesterday's editor's blog makes me think that the political baggage got dragged in where it wasn't wanted. Another said "I do not consider myself as being conservative. Not politically and not in daily life," while jwenting clarified "We aren't so much conservative as in "resisting change" [...] but conservative as in "cautious"."
My dictionary's definition of "conservative" (this is from the Oxford American Dictionary that comes with the US version of Mac OS X, for what it's worth) didn't help matters by offering what is arguably a biased definition, saying that to be conservative is "cautious about change or innovation". Political conservatives probably don't consider the ideas they oppose to be "innovative" any more than this vocal part of the Java community feels that pining for closures ("just because Ruby has them", they say) is innovative.
In fact, my sense of the term goes way back to high school, when I did a presentation on the Greek comic poet Aristophanes. One of the sources I read made the claim that topical comedy is inherently conservative, in that it mocks the new, thereby implying the old ways were better. With this way of thinking, regardless of whether Arisophanes' favorite target, the Athenian Strategos Cleon, was "conservative" or "liberal" by any modern reckoning (if such reckoning even makes sense), there's a certain "conservative" sensibility in saying "the new leaders are asses and their stupid new ideas will lead us to ruin."
Then, compare that thought to this comment from the current poll feedback:
Give the generics, XML and closure fanboyz the boot. No, wait. Before you kick them out force them to clean up the mess they created during the last decade. And don't forget the hundreds of thousands of open bug reports in the dreaded bugparade.
But what do we call the relative camps proposing and resisting closures and the other language changes that have been suggested? And is it as simple as pro- and anti-change? Sure, some people write Java 1.4 code because they just like it better, but are there camps that just want to see Java's development take a different course, say, preferring to expose new functionality through new libraries rather than messing around with the language syntax?
Turning back to the Forums, which spurred yesterday's editor's blog, there's further discussion in the thread Re: Please stop promoting new frameworks and concentrate on Java stack, where the conservative cautious jwenting, quoted above, goes on to write: "As said, there's a point in which it gets to be too much of a good thing Though it's slowing down a bit and there's some consolidation there was a time not too long ago when a new web framework for Java was released somewhere just about every day. The differences were often minimal, the bugs plenty. Had those people joined forces with an existing project rather than go their own way they could have had the same thing they coded themselves in the context of that project instead, making it better for everyone. Of course some concepts are irreconcilable with any existing "framework" and do warrant their own project. Things like Struts and Spring are too different at heart, shouldn't be one product."
krippa asks,
Is it possible to use Glassfish as COSNaming service:
"I am trying to bind a Remote RMI-IIOP stub in a naming service. Doing so by creating the default InitialContext doesn't seem to work. I read something in a thread saying that it is "because you are supposed to use the COSNaming service with IIOP". Isn't the default configuration in glassfish a cosnaming service (the one in jndi.properties)? Can I configure glassfish to provide one? How? Or do I have to bind my stubs with the naming service provided by orbd (<JDK_HOME>/bin/orbd.exe)?"
Finally, jsl123 needs some guidance on
Calling WebService over Http.
"Hi, i have an application that needs to talk to a web service that is implemented as a straight http get request and it is unlikely to change. If it was a "proper" web service, then i could use the java webservice client code to call it, however as it isn't i wondered if anyone could advise on the best cause of action. Firstly is it ok to make an external http call within a managed function (I was probably going to use a message queue around the calls as well to allow for timeouts, etc)? Are there any issues i should be aware of? Ideally the call would run in its own thread which is why i was thinking of wrapping it in a message queue. Secondly if the above isn't possible/advised, what would people suggest instead."
Danny Coward's thoughts about the Java 7 language proposals are a highlight of the Java Today section.
"In light of some of the recent discussions about potential enhancements to the Java language, there has been general concern that the Java language will get too complicated and will be filled with esoteric features that only a few people want and will use." Danny looks at current proposals and the ideas behind them in Java Programming Language: Design Principles and Proposals. "As stewards of the Java Programming Language, we welcome such discussions and highlight some proposals here. " The article highlights the work being done in the Kitchen Sink Language project, and also links to some alternative views.
The JSR-291 (Dynamic Component Support for Java SE) expert group has posted their final release of the OSGi-based JSR. The spec defines a dynamic component framework for Java SE. "The dynamic component model supports assembly of applications from components and supports implementation detail hiding between components as well as lifecycle management of those components." An OSGI JSR-291 page hosts the spec, a reference implementation, and a TCK.
InfoQ's Niclas Nilsson takes note of the new multi-core era and asks Is Erlang the Java for the concurrent future, springing off of Ralph Johnson's blog Erlang, the Next Java. Niclas writes, "the Erlang take on concurrency differs from the mainstream languages by not having any shared state. The processes are very lightweight, and if a process wants to communicate with another process, it communicates by sending messages. This architecture makes it possible to scale and distribute systems in quite a different way than systems that uses shared memory for communication between processes or threads."
In today's Weblogs,
Kohsuke Kawaguchi presents
Yet more plugins from the community.
"The list of plugins for Hudson just keeps expanding. The last week added a plugin to interface with PMD/FindBugs/checkstyle/CPD as well as a plugin to scan through all FIXME/TODO kind of comments."
Arun Gupta describes "the exact steps to deploy your first JRuby application in GlassFish V3 Technology Preview builds" in
First JRuby on Rails App in GlassFish V3
Finally, Max Poon continues a deep dive in
Extending the NetBeans Tutorial JSF-JPA-Hibernate Application, Part 4.
"Switching from Hibernate JPA to Glassfish JPA/TopLink Essentials
SimpleJpaHibernateApp is developed based on JSR 220 Java Persistence API with optional Hibernate-specific options, e.g. in persistence.xml or @Cache Annotations for caching applied. Hence, due to the pluggability of the Java Persistence API architecture, JPA-compliant applications such as SimpleJpaHibernateApp can easily be switched to make use of other Java Persistence providers such as Glassfish JPA. This article describes how this can be done."
Current and upcoming Java
Events :
Registered users can submit event listings for the java.net Events Page using our events submission form.
All submissions go through an editorial review before being posted to the
site.
Archives and Subscriptions: This blog is delivered weekdays as
the Java
Today RSS feed. Also, once this page is no longer featured as the
front page of java.net it will be
archived along with other past issues in the java.net Archive.
Bookmark blog post:  del.icio.us  Digg  DZone  Furl  Reddit
Comments
Comments are listed in date ascending order (oldest first) | Post Comment
-
I think we should be labeled as "pro API/VM changes" ;-)
IMO one of the greatest innovations introduced by Java was throwing out all of the old baggage that you "had" to have in a language and limiting the functionality of other features. No pointers, no enums, no operator overloading... You are more innovative when throwing out things (a minimalist) then when you try to please everybody by adding things. It is not innovation when you go down the path treaded by practically every other language!
Posted by: vprise on August 14, 2007 at 05:03 PM
-
...just want to see Java's development take a different course, say, preferring to expose new functionality through new libraries rather than messing around with the language syntax?
Thats me Sir :-)
I want to see a Java with a stable core language and constantly improving APIs.
With the new module system it should be able to refactor old APIs to improve them. They should be as consistent as possible (take a look at Cocoa for inspiration).
What is most important: Fix as many bugs as possible. This would be the best promotion for Java that could be done. Instead of discussing the pet feature of every developer that should be included in the core language we should discuss what bugs need to be fixed for the next release and what things need to be improved.
Then, deployment of the VM is a major playing field for future improvements. Take a look how Apple has done this. There is much to do and discuss for Java 7, 8, 9 ...
You see, I am not conservative in whatever definition. I simply think that people that want to include the suggested features and more in the core language simple think in the totally wrong direction.
Posted by: aehrenr on August 14, 2007 at 06:04 PM
-
The problem is if you ask 100 people you will get 100 different answers. For me Generics have allowed me to write code that doesn't get abused by others as often. Thats a plus because it makes my life easer. I'm not interested in XML and feel adding language support for it is short sighted. If it's a language level change then it should be to support any "embedded language". I really want a reflection system that isn't based on strings for identifiers. I think properties will give me this. The BeansBinding solution to use EL instead, and it's ugly and not type safe and not java. I wish I could weigh in on closuers but it all seems way to confusing to really understand what people are and are not proposing.
In the end THIS is what happens when you have a community. People rant and rave and express their dissatisfaction about what they think is wrong.
Posted by: aberrant on August 14, 2007 at 07:51 PM
-
Java is not a small experimentally software platform. It is the biggest software platform around: Banks, all kinds of business and operations, research institutions from all branches of studies and whoever write their software in Java. What all those undertakings have in common is that they need a stable software platform. They do not have the wish to experiment in computer science but to tackle the problems of their operation. Often they are not even computer scientists but have studied other fields.
So the Java language should stay as stable as possible. If language changes are envisaged they should be discussed very well and then included in an experimental compiler that is included in the JDK of the next version, so everyone can try an make an opinion. Language changes should be the exception not the rule.
Posted by: aehrenr on August 14, 2007 at 09:05 PM
-
Reading Danny Coward's article I have to conclude he just doesn't get it. Reading is more important than writing he says.the "same" Java you knew in JDK 1.2 he says about Java 5. Sound's great. And then why oh why was the dreaded C++ template syntax used for generics? Difficult to read and butt ugly it changed the feel of the language.
Simplicity mattershe says. Ladies and gentleman, may I introduce you to Angelika Langer's famous generics FAQ http://angelikalanger.com/GenericsFAQ/JavaGenericsFAQ.html .The PFD version for printing is 427 pages. FOUR HUNDRED TWENTY SEVEN pages to deal with all the idiosyncrasies of "simplicity matters" generics. 427 pages of information Sun didn't care to cough up.
Why is operator overloading on the plate now? Do we really need to have to learn the Java equivalent of the C++ orthodox canonical class form to avoid having to accidentally mess up code because we forgot to defined the Java 7 equivalent of an assignment operator?
Someone apparently also can't wait to write
System.out << "Hurray, finally Java works like C++" << System.endl;
And instead of toString() we finally have to provide
friend ostream& operator<<(ostream &os, T);
just so we can print our objects?
If we choose [our design principles] wisely, these will keep us classic and yet hip for a long time to come. he says. Being "hip"? That is marketing junk. I give a f*ck*ng f*rt about being hip. And where in the whole article did he actually present the design principles? It seems there aren't any, except trying to be "hip".
Posted by: ewin on August 14, 2007 at 11:25 PM
-
"but are there camps that just want to see Java's development take a different course, say, preferring to expose new functionality through new libraries rather than messing around with the language syntax? " bingo. And most if not all of those shouldn't be part of the standard API but rather optional addons.
Language changes should be the exception not the rule. And that's the crux. Java's grown (thanks to Sun's initial vision, now sadly diluted severely) into a platform that's rivalled in importance in the industry only by the likes of Cobol and PL/1. Those didn't get to the top by being "hip" and being changed to reflect every hype that came around. They got to be big (and especially stayed big) because they were reliable and stable. Unless Java remains to be seen by its major users (who are multinational corporations rather than research students) as stable and reliable it will quickly be replaced by something else, something that's been proven to be reliable and stable for the last 20+ years, Cobol.
Posted by: jwenting on August 15, 2007 at 07:15 AM
-
A thing that didn't get mentioned as much as I would like is the fact that there are already language changes done by external compilers that compile to bytecode and are Java 1.4 compatible. There are several such languages whose features are copied and pasted into the Java 7 suggestions.
Language change fans don't want new language features since these exist and are 100% compatible with the current VM (back all the way to 1.4)... They want to force all of us into these features in a rushed manner, thats bad.
We are for diversity, there is nothing wrong with having multiple languages on top of the VM and we are very much for that. I think Groovy is an excellent idea (although I don't use it myself) and so is JRuby. This allows people who want more adventurous languages to get what they want without putting the entire Java eco system at risk.
Posted by: vprise on August 15, 2007 at 09:01 AM
-
Ladies and gentleman, may I introduce you to Angelika Langer's famous generics FAQ http://angelikalanger.com/GenericsFAQ/JavaGenericsFAQ.html. The PFD version for printing is 427 pages. FOUR HUNDRED TWENTY SEVEN pages to deal with all the idiosyncrasies of "simplicity matters" generics.
and we will have another such document when Mr Gafter gets his closure specification, not to mention all the other "features". They are proposed at such a pace that it is even impossible to find some concrete proposals and argue about them.
I think the committee that defines C++ will go green with envy.
Posted by: aehrenr on August 15, 2007 at 09:19 AM
|
java.net RSS Feeds
