R – How to debug server side code in Aptana Jaxer

I didn't use Jaxer for very long, but here's some things I found:

Pros

• Write the frontend and backend in the same code. Especially nice for writing validation logic.
• "Seamless" AJAX communication back to the server - it's just like calling a JS function.
• The ability to use JavaScript frameworks like jQuery to manipulate the DOM.
• The ability to generate or manipulate images using the Canvas API.
• You get to write your server JavaScript using whizzy new JavaScript 1.8 features like Array extras and getters/setters.

Cons

• I found their API to be unstable (they were transitioning to 1.0 when I was trying it so that kinda made sense) and the documentation was confusing, missing, or didn't match with changed functionality. I also found that it was very hard to debug my Jaxer server-side code, and when I got in trouble the error messages weren't very helpful.
• You don't get real MVC or even MVP (ASP.NET-style) separation between your presentation and your logic.
• I personally couldn't get E4X (xml in JavaScript) working, which was supposed to be a big draw.
• There's not a lot of framework built around it for building a whole application. You're starting from some pretty basic building blocks.
• It's not really providing any help in your view, so forget all the templating or reusable components you might use elsewhere. Not that you can't replicate that, but it's more difficult than having it out of the box.

Overall, I think Jaxer has the most promise as a postprocessor in front of another web framewok. It would be great to use Jaxer to layer all the spiffy AJAX stuff on top of an existing site. It would make it a lot easier to make a dynamic site with validation / page manipulation logic shared between server and client. I don't think I would want to write an application using only Jaxer. Also, it's young (and immature) - I'll be interested to see where it ends up.

I am the developer for Myna (www.mynajs.org), an Open Source server-side JS platform based on Rhino and Java. I'll address the issues as they relate to Myna, but many of these points apply to server-side JS in general:

By using server side JS, can we implement the whole web application without using any server side languages (like C#,java etc). Or server side JS sits in between the web server and other langauge stack.

In Myna it is possible to write your entire app in JS. Myna already includes API's for Database access, Object Relational Mapping, crytogrophy, OpenID, etc.

Is it really a better approach than c#/Java?

With a Rhino based server it is trivial to drop down to Java whenever needed. You can easily install open-source/commercial/hand-coded Java libraries and then script them from JS. This means you get the rapid development of JS but maintain the advantages of the Java platform

what are the advantages and disadvantages?

pros:

• Rapid development: In Myna you just create files in the webroot with an .sjs extension. This means you can create an edit-save-refresh browser cycle with is very fast for debugging/tweaking code.

• Easy JSON: Having JS support server-side means moving complex structures is very easy

• Shared code: If you need to perform the the same function on both the server and the browser, you can use the same code

• Dynamic ORM: Statically typed compiled languages make it hard to alter objects at runtime. This usually means that ORM has to be defined in advance. In Myna building ORM is as simple as

  var manager =new Myna.DataManager("DataSource name").getManager("table name");
  

  You get an object that can do all basic CRUD operations without ever explicitly defining the DB tables. As another example you can insert a row with all the matching values from a form post:

  manager.create($req.data);
  

• Functional Programing: If you have started playing with advanced JavaScript features then you will appreciate how helpful they are server-side. Because of the consistent server-side environment it is safe to use advanced features such as Array Extras, generators and iterators, destructuring assignments, and E4X

cons:

• Tools: Statically typed languages like C# and Java have excellent IDE and developer tools. Dynamic languages like JS just don't have the tool support yet. Personally I find that the large reduction in boilerplate code and fussy type casting makes up for this, but this is still a big disadvantage if you have been doing a lot of development in IDEs. If you are currently using an IDE, consider using jedit for dynamic languages

• Maturity/Standardization: Serverside JS is still a new paradigm, and there are many players and no clear winners. ECMA does not have any standards for serverside JS. As mentioned in Brandon's answer, the CommonJS group is attempting to form a serverside JS standard and Myna has experimental CommonJS support via Narwhal

how this works well in terms of performance?

In raw computational speed, few dynamic languages can match statically typed compiled languages like C# and Java. Having said that, it really doesn't matter. Any part of your application that is computationally intensive should probably be written in Java, or use an existing Java library. I wouldn't suggest that anyone write a Database in JS for instance. For real world web applications/SOA services, the primary cause of slowdowns isn't raw computational speed, it is inefficient code, especially database access. Myna helps with this by doing things like:

• internally caching compiled JS scripts
• Internally using cached prepared statements for database transactions
• Query and output fragment caching
• Database connection pooling
• Automatic ETag hash support
• Profiling tools
• Lazy loading of metadata

how well we can implement & maintain db transactions? can we do that in serverside JS..?

If you mean transaction as in "a set of SQL statements that can be reversed or committed", then Myna does not yet support transactions. I am open to implementing this if there is enough interest.

If you mean "what kind of database support does server-side JS have?" then the answer is platform dependent. The Myna platform provides the following database features:

• A web-based administration application where you can define "datasources", i.e database connection information. You can then query these datasources by name. Myna includes JDBC drivers for H2, MySQL, Microsoft SQL Server, and Postgresql, but any JDBC or ODBC datasource can be used
• Myna.Database and Myna.Table provide database-neutral metdata access as well as table creation and modification.
• Myna's Query object supports maxRows, paging, SQL parameters,custom row handlers, query-of-query, caching and more
• Myna's DataManager object supports runtime ORM object creation

is it possible to develop RESTFul and SOAP services in serverside JS..??

REST and SOAP support are platform specific features. Myna's WebService object supports the following protocols:

• SOAP
• XML-RPC
• JSON-RPC
• Ext Direct
• JSON-MYNA (a simple protocol that uses normal form posts and returns JSON. Easy to use from the browser)

Myna also understands the PUT and DELETE request methods and presents access to request body content in both text and binary form, so that it is possible to handle these RESTful methods in an application specific way.

Debugging

Traditional breakpoint debugging is a real challenge serverside. Although Rhino supports debugger hooks, using these from a stateless web app would be pretty involved. Personally I don't even use breakpoint debuggers even when they are available (e.g. firebug). Instead I prefer logging.

In Myna,

 Myna.log(type,label,detail)

will spawn a low priority thread to write an HTML log message to Myna's logging database. These logs can then be searched through the Myna Administrator. Logs also record timestamps and elapsed milliseconds for profiling purposes. Myna.dump(obj) can also be used to present an HTML table representation of any object. Myna also logs all un-handled exceptions with stack traces, source code context, and request details. Between dump(), log(), and the default error handler I haven't much difficulty debugging Myna code