Split from thread ‘Oracle sues Google over use of Java in Android’
JEE could be much better, it is holding back invention. All those stacks of libraries around and on top of each other, its a mess. Restart ~ 2 minutes, patching ~ 1 hour… Its as messy as Windows apps were with OLE and ODBC.
And Oracle’s own software isn’t that pretty either.
Not a fan of it, but Node.js could go a long way.
The problem is js is that it’s very hard to keep it maintainable, even for small projects.
while I can’t comment if javascript is hard to maintain, it does look good with support for it in technologies like Unity3d.
IME it’s actually not that bad. With the help of JSLint everyone can reach a pretty decent level of code quality. There are good editors and excellent resources (books & videos), you can generate documentation, and there are many patterns to chose from.
If you are a fan of mixins and traits you can tack that on with libraries/frameworks like Joose.
Personally, I’m still surprised that JavaScript is actually a pretty decent language. Well, it surely got its quirks, but below all that mess and all that awful code out there, there is actually a very expressive and compact language.
Right now it’s my favorite language. I’m having lots of fun with it for some reason. My past self would be surely disgusted. 
Well doh JS is an excellent language, with nearly infinite freedom to the programmer – that’s where the maintainability issue comes in! How many javascripters know about the crucial ‘===’ operator? Oh well, let’s not get in a language discussion, because I think we both love it, yet wouldn’t want to work with somebody elses JS.
No, JS is not a good language for anything over and above trivial scripts. For applications, its appalling. Strict static typing was developed for a reason, and it doesn’t take long dealing with any large JS codebase before you find out why - it saves you from doing stupid shit that a compiler can trap for you.
JS doesn’t have any include / import function. It doesn’t have modules / namespaces. It doesn’t have file-scoped variables (It’s all global baby!!). The foreach iterator is borked for arrays (it returns strings, not index numbers and if you have extended the array prototype, it returns prototype functions as well as indicies!). It was explicitly designed for small tasks and on top of that it runs very slowly compared to Java/C/C++.
Javascript makes sense for in-page HTML scripting. For large apps it’s a PITA. An JSLint is a piece of shit. Half the things it reports as errors aren’t (e.g.: preferring === to == can be wrong depending on input but JSLint will always recommend the former)
How many javascripters know about the crucial ‘===’ operator?
JSLint. 
It doesn’t have file-scoped variables (It’s all global baby!!).
There should be at most one global variable. Also, Java isn’t file-scoped - it’s block-scoped. JavaScript on the other hand uses function scope. Unfortunately it defaults to the global object, but JSLint will point this out if necessary.
The foreach iterator is borked for arrays […]
Why would you use foreach? It’s too much to type (requires a guarding hasOwnProperty check). Also, do you mean for-in or the new forEach?
[foreach] returns strings, not index numbers […]
For-in gives you the keys. You are supposed to use it to iterate over the properties of some object. Either way yourArray[‘0’] will give you the first item.
if you have extended the array prototype
Don’t modify objects you don’t own.
it returns prototype functions as well as indicies
Hence the hasOwnProperty guarding condition. Again, JSLint points this out.
It was explicitly designed for small tasks and on top of that it runs very slowly compared to Java/C/C++.
Well, it’s faster than Python, Ruby, Lua, etc. So, it’s really not that slow.
An JSLint is a piece of shit. Half the things it reports as errors aren’t
(e.g.: preferring === to == can be wrong depending on input but JSLint
will always recommend the former)
Well, if you write something like if (foo == null) and you aren’t actually looking for null here, but for undefined, then replacing the == with === will break the program. It only worked initially, because those two errors canceled each other out.
If you want to check if some variable is truthy or falsy you should use if (foo) or if (!foo) and similar constructs.
You shouldn’t use == or != ever (and there really is no need to use them), since it won’t be clear what your real intention was.
JSLint looks quite handy. That will help me when I need to do some small Javascript work.
accompanied by the sounds of a camel’s back breaking
Komodo Edit + the kjslint addon (+on before save macro trigger if you don’t like pressing another button or using a separate shortcut).
For pain/hassle free but still pretty good minificiation use the YUI Compressor. While the Closure compiler saves a few percent more, it does require lots of attention and hand-holding. Personally, I can’t be arsed with that.
[other opinions about which bits of the language to use snipped]
Sure. And you’re back into the C++ trap. It’s a fine language if everyone uses it the way you do. Fucking awful if their list of language features to use or avoid differs from yours. And it always differs from yours. Each programmer lives in a different cul-de-sac of the full language.
Languages that make it easy to blow your foot off (like C++, JS) are annoying.
And the lack of static typing is annoying beyond belief. I read on slashdot recently someone saying why they gave up ruby programming - so much time writing tests where 90% of that was just checking that the parameters and types were correct. That’s what machines are for, for christ’s sake.
And even when you have tests (as we do) the lack of typing still manages to bite you in the arse. I lost a whole fucking day debugging an issue where something was broken but continued on silently due to a type change that a statically typed language would have told me about immediately.
You don’t find these things in small hacks but when you start dealing with complex code bases in JS, it just creaks - it’s not designed for it. I mean, come on - you can’t even include library code into another JS file FFS. That’s as basic as it gets.
In somewhat related news, I gave Rhino a try a couple days ago. Wow it is bad, at least for my needs. The type system doesn’t mesh well with Java at all. After a day of trying to convert between the types in my Java and JavaScript code, I finally trashed the whole idea. I’m now doing it in straight Java and I’ll be able to tack on some scripting later. It certainly won’t be Rhino though!
What are some JVM scripting languages that use the same type system as Java? Pnuts is one, but I wanted to try out something else. I really want something close to Java, but less verbose, as Java developers will be writing this script. I’ve looked at Beanshell, but I don’t feel it is written particularly well. Nice looks interesting.
And it always differs from yours.
All of our code must pass JSLint and modifying other objects is forbidden. Also, we don’t use libraries which modify build-in objects (e.g. Prototype). We also got code and documentation conventions. Reading JavaScript: The Good Parts is also mandatory.
To be fair, I came up with those rules. I’m in charge of that stuff here.
Edit: Splitting the thread and adding that kind of headline is sorta silly. No one feared that Oracle might sue anyone over JavaScript.
…
Well doh. It was meant as a silly reference to the old thread, so that people would immediately know what happened. Feel free to suggest a new thread headline, if it’s important to you.
Rhino can certainly be a PITA, but exactly what problems did you run into? I built a set of wrapper classes that (at least for me) solve all annoyances. If I know the problem, and my code fixes it, I can put some code in the public domain.
What? Oracle is now going to sue over Javascript?! those b… :
Go for janino, it rocks. www.janino.net
It’s compiled to byte code so it’s fast and uses exactly the same syntax as java so it’s cut-and-paste from java to janino. Beanshell is a poor man’s janino.
The only problem with janino is that it’s based on java 1.4 syntax, so it hasn’t got generics and auto-boxing so it can’t understand that code. It can run on java 1.5 and 6, it just can’t use those new language features.
[quote]And the lack of static typing is annoying beyond belief.
[/quote]
Agree 100%
I can never understand why people would want to use a language with no static typing in a project larger than 10 lines of code.
No static typing to me just means that an important part of the code (typing) becomes invisible, obfuscating bugs, making the code less readable, and delaying compile time errors to runtime errors.
For scripting I’ve also done a lot with Groovy. I started out being quite enthousiastic about it, but the more I’ve used it, the more I detest it.
Too much ‘magic’ going on there under hood, too much focused on making things more readable for non-programmers but ending up less readable for developers (because for example a lot of code you write implies functionality and code Groovy hides from you). And it’s soooo bloated a language it’s not funny anymore. And oh yeah, it’s slow too.
Well, at least it supports static typing and interoperates naturally with Java, but other than that I dislike it a lot.
Hmm, Janino’s site seems down… I’ll try again later.
I had a utility function written in Java that got uglier and uglier. It went something like this…
public Stuff getStuff (Object object) {
if (object instanceof String)
stuff
else if (object instanceof NativeArray) {
NativeArray array = ((NativeArray)object);
for (int i = 0, n = (int)array.getLength(); i < n; i++)
stuff
} else if (object instanceof NativeJavaObject) {
object = ((NativeJavaObject)object).unwrap();
if (object instanceof ArrayList) {
for (String dirPattern : (ArrayList<String>)object)
stuff
} else
throw new RuntimeException("Unknown object type: " + object.getClass());
} else
throw new RuntimeException("Unknown object type: " + object.getClass());
return stuff;
}
It wasn’t clear why String was not wrapped – if I wanted access to the JavaScript native string, I guess I can’t. Anyway, writing that left a bad taste in my mouth. I imagine there would be a similar circus on the JavaScript side of things. A small library to handle conversions would help, but I imagine converting back and forth would become very tedious and error prone. I think it should be seamless to work well.
Groovy is really terrible. Crazy how much hype that steamy pile has gotten.
I don’t have time right now, and I don’t even know whether this answers your question – my Rhino is a bit rusty. Will look into it tomorrow.
public <T> T getVariable(String name, Class< T > type)
{
try
{
this.enterContext();
return (T)Context.jsToJava(this.getJs(name), type);
}
finally
{
this.exitContext();
}
}
public Object getJs(String name)
{
try
{
this.enterContext();
return ScriptableObject.getProperty(this.rhinoScope, name);
}
finally
{
this.exitContext();
}
}