I have worked with Python for 10+ years over Apache and rarely other 
platforms too. I have developed software over mod_python and mod_wsgi. I 
will try to shortly touch a few main differences between how we did things 
in Python using it with different platforms and what are the similarities 
and differences between those and the environment Node provides.

First of all, Node is not direct competition of Python. Everything is 
different from head to toe between two platforms.

There are many different implementations of Python interpreter today; but 
they all try to stick with the standard definition of the language. The 
standard interpreter cPython comes with a very rich standard library. In 
this standard library, there are modules to quickly develop a web server; 
but we rarely use those. Instead, we depend on other web servers like 
Apache or nginx to handle http. However, there are also web servers we now 
have access to which are really close to Node. One very famous of them is 
Tornado.

At Node's side, things are pretty different. First of all, JavaScript 
standard does not define a standard library like Python or many other 
languages do. This is not a shortness; but a different way of seeing the 
world.

Node is built on V8, a JavaScript interpreter. This way, Node provides 
something like python interpreter in regards to being an executable 
application to run scripts. The very same way you run python myscript.py, 
you run node myscript.js.

Node also has its own standard library of functions. It is nowhere close to 
having *everything* like Python standard library does. Again, this is not a 
lack of features, this is the way Node is meant to be. Instead of having a 
giant standard library, Node has a *playful* module system that provides 
extremely easy ways to build, pack and publicly share your libraries. Node 
simply prefers playing liberally instead of dictatorship.

As for the key point in your question, as a web development environment, 
what Node provides is almost the same as what Tornado provides. Web server 
is not a separate application. You have all low level http functionality as 
a library provided by Node. Don't get me wrong, I love Python, I still 
heavily use it for many things; but the http server module Node provides is 
a serious one unlike the one in Python standard library. Python's http 
library is meant to be used in development environments while Node's is 
designed and implemented for heavy-duty production servers. Again, if you 
take a look at how Tornado works, you will have a much quicker grasp on the 
mindset of Node's web development environment.


On Sunday, July 8, 2012 1:01:11 PM UTC-4, Tim Johnson wrote:
>
> I've been a CGI programmer for 16 years. I have used python for the 
> last 9. I currently use javascript for client-side programming. I am 
> interested in using node.js for server-side programming. 
>
> I've done a little googling on CGI interfaces for node, but I am 
> finding *too* much information. 
>
> I am including an untested pseudo-code based on python. With that as 
> a reference, I would welcome some javascript code which would work 
> similarly: 
> code follows 
> ################################################################## 
> #!/usr/bin/python 
> import cgilib   ## my cgi module 
> import mvcLoader as load  ## handles importing controller modules 
> ## script loader.py (the executable 'parent' module) 
> ## is the post action for a form which 
> ## accepts an email address and a password as input fields named 
> ## "email" and "password". 
> ## loader.py has a virtual document path that has as path part 0 
> ## a key for the controller that will be `import'ed by the parent module. 
> ## the post action might look like this: 
> ## "http://localhost/cgi-bin/loader.py/auth"; 
> if __name__=="__main__": 
>     ## instantiate the cgi object and in doing so, 
>     ## process the CGI environment 
>     cgi = cgilib.Cgi() 
>     ## print the mime-type header 
>     cgi.header('text') 
>     ## Retrieve the values POSTed for 'email' and 'password' 
>     user = cgi["email"] 
>     pwd = cgi["password"] 
>     ## Retrieve the key for the controller module which will then be 
> imported 
>     ## by the load.controller() method 
>     controller_key = cgi[0] 
>     controller = load.controller(cgi[0]) 
>     ## And the rest of the work happens below 
>     ## in the imported controller module 
>     controller.process(user,pwd) 
> ################################################################## 
> The intent and mechanics of my mvcLoad module should not be relevant 
> to this dicussion. What is relevant is allegories to 
> cgi[keyname] 
> and 
> cgi[virtual_document_path_index] 
>
> I hope that the example makes my question clear. I don't expect 
> anyone to "roll their own" tutorial, but URLs to discussions 
> on similar node interfaces would be most helpful. 
>
> TIA 
> -- 
> Tim 
> tim at tee jay forty nine dot com or akwebsoft dot com 
> http://www.akwebsoft.com 
>

-- 
Job Board: http://jobs.nodejs.org/
Posting guidelines: 
https://github.com/joyent/node/wiki/Mailing-List-Posting-Guidelines
You received this message because you are subscribed to the Google
Groups "nodejs" group.
To post to this group, send email to [email protected]
To unsubscribe from this group, send email to
[email protected]
For more options, visit this group at
http://groups.google.com/group/nodejs?hl=en?hl=en

Reply via email to