Sorry for the bad formatting, try this one:
Maybe a missing the point, but why do languages like LISP and Python have rather weak IDE's? No disrespect to emacs, but it seems to have stood still in the face of huge leaps in the quality of IDE's for other environments.
I believe Java combined with a next-generation Java IDE (Eclipse or especially IntelliJ) can recapture much of the productivity that's supposedly lost to Python's terse syntax. Intelligent code completion gets around Java's rather wordy way of doing things, and refactoring support makes supporting that verbose code a breeze. IntelliJ is smart enough to figure out if you have a variable, what type it is once you declare it and can offer constructors to instantiate it without you having to do all the typing. IntelliJ can even find redundant bits of code and refactor them into a method for you.
One of Python/LISP's main attractions is the interactive environment. Java's hot swappable classes combined with IntelliJ's debugger allow you to experiment and play around with your classes while your program is running, all the while inspecting your data structures, having conditional breakpoints, evaluating arbitrary expressions on the fly, etc. Really quite amazing how far java debuggers have come in the past few years. Plus java's remote debugger makes attaching to an already running process as easy as debugging locally which is great for debugging complex server side stuff.
Checked exceptions is a big problem for Python0philes. You can get around that in Java by throwing RuntimeExceptions, but some find that sloppy. The right way to avoid having to declare a boatload of exceptions from a method, is to catch low level exceptions and throw a higher level exception (e.g. your library catches IOException, SQLException, throws LibraryException). I've got IntelliJ set up with a template to generate a new Exception with one click and just fill out the name of the exception, and, viola, you've got your higher level LibraryException and you've forever liberated your users from having to worry about an IOException when calling your method and allow them to do more sensible generic error handling.
IntelliJ/Eclipse has tight integration with a number of standard tools like Ant (for builds), JUnit (for unit testing), XDoclet (for code generation), as well as plugins for tons of open source projects (by untalented non-hackers, according to the esteemed Mr. Graham) that make the task of getting work done a little easier by keeping you from inventing the wheel.
So what you're left with is an IDE that can compensate for Java's supposed weaknesses and lets you enjoy Java's strengths, which have been enumerated by numerous prior posts (Robust Libraries, Strong typing, standardized Unit testing, standardized build tools, platform independence, strong documentation, very few nasty surprises).
Which leaves me to wonder why, with all the great productivity and mind expanding power of Python and especially LISP (which had every f*cking feature back in '57 with McCarthy), do we struggle with vi or emacs, several slightly incompatible versions of LISP, shitty IO/concurrency libraries (for LISP), poorly documented libraries that you're not sure will work until runtime and even then may die on you unexpectedly in production when you blindly pass in some unexpected type, with decentralized pockets of apis scattered across the web in various states of disrepair? Java libraries seem to be a more organized affair, certainly from a documentation standpoint (the power of strong typing, checked exceptions and Javadoc are underestimated in my opinion and is one of the unsung features of the Java language) than most Python and certainly LISP libs out there. Why can't there be an IntelliPython, or IntelliLISP.
My point here is not to bash Python or LISP or any language. I have done a bit of work with scripting testing with Python (Jython actually) and am making an effort to learn CLISP (from Paul Graham's ANSI Common
Maybe I'm missing the point, but why do languages like LISP and Python have rather weak IDE's? No disrespect to emacs, but it seems to have stood still in the face of huge leaps in the quality of IDE's for other environments.
I believe Java combined with a next-generation Java IDE (Eclipse or especially IntelliJ) can recapture much of the productivity that's supposedly lost to Python's terse syntax. Intelligent code completion gets around Java's rather wordy way of doing things, and refactoring support makes supporting that verbose code a breeze. IntelliJ is smart enough to figure out if you have a variable, what type it is once you declare it and can offer constructors to instantiate it without you having to do all the typing. IntelliJ can even find redundant bits of code and refactor them into a method for you.
One of Python/LISP's main attractions is the interactive environment. Java's hot swappable classes combined with IntelliJ's debugger allow you to experiment and play around with your classes while your program is running, all the while inspecting your data structures, having conditional breakpoints, evaluating arbitrary expressions on the fly, etc. Really quite amazing how far java debuggers have come in the past few years. Plus java's remote debugger makes attaching to an already running process as easy as debugging locally which is great for debugging complex server side stuff.
Checked exceptions is a big problem for Python0philes. You can get around that in Java by throwing RuntimeExceptions, but some find that sloppy. The right way to avoid having to declare a boatload of exceptions from a method, is to catch low level exceptions and throw a higher level exception (e.g. your library catches IOException, SQLException, throws LibraryException). I've got IntelliJ set up with a template to generate a new Exception with one click and just fill out the name of the exception, and, viola, you've got your higher level LibraryException and you've forever liberated your users from having to worry about an IOException when calling your method and allow them to do more sensible generic error handling.
IntelliJ/Eclipse has tight integration with a number of standard tools like Ant (for builds), JUnit (for unit testing), XDoclet (for code generation), as well as plugins for tons of open source projects (by untalented non-hackers, according to the esteemed Mr. Graham) that make the task of getting work done a little easier by keeping you from inventing the wheel.
So what you're left with is an IDE that can compensate for Java's supposed weaknesses and lets you enjoy Java's strengths, which have been enumerated by numerous prior posts (Robust Libraries, Strong typing, standardized Unit testing, standardized build tools, platform independence, strong documentation, very few nasty surprises).
Which leaves me to wonder why, with all the great productivity and mind expanding power of Python and especially LISP (which had every f*cking feature back in '57 with McCarthy), do we struggle with vi or emacs, several slightly incompatible versions of LISP, shitty IO/concurrency libraries (for LISP), poorly documented libraries that you're not sure will work until runtime and even then may die on you unexpectedly in production when you blindly pass in some unexpected type, with decentralized pockets of apis scattered across the web in various states of disrepair? Java libraries seem to be a more organized affair, certainly from a documentation standpoint (the power of strong typing, checked exceptions and Javadoc are underestimated in my opinion and is one of the unsung features of the Java language) than most Python and certainly LISP libs out there. Why can't there be an IntelliPython, or IntelliLISP.
My point here is not to bash Python or LISP or any language. I have done a bit of work with scripting testing with Python (Jython actually) and am making an effort to learn CLISP (from Paul Graham's ANSI Common LISP), if only to deepen my programming knowledge, through "bottom up programming" , macros, functional programming, etc. But, if I'm going to make the effort to learn a new language, I don't want to go back to the dark ages of friggin VI or emacs just coz Paul Graham says I can have better living through macros. It's the tools, stupid!
Sure why not? You're well within your rights to change how Linux works on your machine(s). It's when you release it as your own in a non-free manner that you run into problems. But that's a bad analogy due to the differences in licensing (GPL vs FairPlay).
Accessing a DB is by far the biggest bottleneck for most applications that I've worked on. It is usually at least an order of magnitude slower than any other operation. I think DB's are probably one of the most inappropriately used technologies in the "enterprise" space. You can't wipe your ass without an ACID db for all your persistence, when in practice, the only thing you really need a db for is for querying for reporting and crap like that. For OLTP stuff you'd probably be better off with something like this, or Berkley DB which forgo the SQL Engine and just offer more direct access to the underlying datastructures for much greater performance. Then you can have some other process parse up the persisted data and populate your reporting database.
That's the appeal of TiVo. It's supposed to give you control over the stuff you see, filtering out the crap you don't want to see (commercials, etc.). Which is why Big Media is so against it. No argument about the crappy content on tv, though. I've been without one for a year and I'm not looking back.
>>Can't support TiVo. I can see paying for convenient TV listings, but the ability to record/timeshift should come straight out of the box.
Which is EXACTLY what it does
I haven't used it myself, but this debugger for Java allows you to record the execution of your program and play it back again and again to see what's happening, who's setting what variables, etc
http://www.lambdacs.com/debugger/debugger.html It appears to be free (as in beer), so there's a bonus for your right there!
I just picked up this <A HREF='http://www.archos.com/us/products/product_50 0201.html'>puppy</A> that has 6 Gigs of storage and can rip directly from any audio source. And it's $350. Seems to me to be the best of the IPod and this thing, for 50 bucks less. You can take that cash and buy 2 Rocco DVD's
Servlets offer the advantage over traditional CGI of being persistent, that is the servlet engine runs inside your webserver continuously waiting to handle requests. So you don't run into startup costs per request as you do with traditional CGI. This was the key advantage that servlets had originally over Perl/C/C++ but I think there are other alternatives now that do similar things in these other languages.
However, once you buy into servlets and Java, many other things that you might want to do from your web application are wrapped up in a nice little package (DB API, threading, RMI/CORBA, etc). The servlet engine provides a framework for getting input parameters, cookies, etc. and allows chaining servlets to process different parts of the request. And a nice thing about servlets is that (ideally) you should be able to write your servlet application and run it on JRun or Tomcat or whatever engine works best for you with no modification of Java code.
Slashdot Mirror
Sorry for the bad formatting, try this one:
Maybe a missing the point, but why do languages like LISP and Python have rather weak IDE's? No disrespect to emacs, but it seems to have stood still in the face of huge leaps in the quality of IDE's for other environments.
I believe Java combined with a next-generation Java IDE (Eclipse or especially IntelliJ) can recapture much of the productivity that's supposedly lost to Python's terse syntax. Intelligent code completion gets around Java's rather wordy way of doing things, and refactoring support makes supporting that verbose code a breeze. IntelliJ is smart enough to figure out if you have a variable, what type it is once you declare it and can offer constructors to instantiate it without you having to do all the typing. IntelliJ can even find redundant bits of code and refactor them into a method for you.
One of Python/LISP's main attractions is the interactive environment. Java's hot swappable classes combined with IntelliJ's debugger allow you to experiment and play around with your classes while your program is running, all the while inspecting your data structures, having conditional breakpoints, evaluating arbitrary expressions on the fly, etc. Really quite amazing how far java debuggers have come in the past few years. Plus java's remote debugger makes attaching to an already running process as easy as debugging locally which is great for debugging complex server side stuff.
Checked exceptions is a big problem for Python0philes. You can get around that in Java by throwing RuntimeExceptions, but some find that sloppy. The right way to avoid having to declare a boatload of exceptions from a method, is to catch low level exceptions and throw a higher level exception (e.g. your library catches IOException, SQLException, throws LibraryException). I've got IntelliJ set up with a template to generate a new Exception with one click and just fill out the name of the exception, and, viola, you've got your higher level LibraryException and you've forever liberated your users from having to worry about an IOException when calling your method and allow them to do more sensible generic error handling.
IntelliJ/Eclipse has tight integration with a number of standard tools like Ant (for builds), JUnit (for unit testing), XDoclet (for code generation), as well as plugins for tons of open source projects (by untalented non-hackers, according to the esteemed Mr. Graham) that make the task of getting work done a little easier by keeping you from inventing the wheel.
So what you're left with is an IDE that can compensate for Java's supposed weaknesses and lets you enjoy Java's strengths, which have been enumerated by numerous prior posts (Robust Libraries, Strong typing, standardized Unit testing, standardized build tools, platform independence, strong documentation, very few nasty surprises).
Which leaves me to wonder why, with all the great productivity and mind expanding power of Python and especially LISP (which had every f*cking feature back in '57 with McCarthy), do we struggle with vi or emacs, several slightly incompatible versions of LISP, shitty IO/concurrency libraries (for LISP), poorly documented libraries that you're not sure will work until runtime and even then may die on you unexpectedly in production when you blindly pass in some unexpected type, with decentralized pockets of apis scattered across the web in various states of disrepair? Java libraries seem to be a more organized affair, certainly from a documentation standpoint (the power of strong typing, checked exceptions and Javadoc are underestimated in my opinion and is one of the unsung features of the Java language) than most Python and certainly LISP libs out there. Why can't there be an IntelliPython, or IntelliLISP.
My point here is not to bash Python or LISP or any language. I have done a bit of work with scripting testing with Python (Jython actually) and am making an effort to learn CLISP (from Paul Graham's ANSI Common
Maybe I'm missing the point, but why do languages like LISP and Python have rather weak IDE's? No disrespect to emacs, but it seems to have stood still in the face of huge leaps in the quality of IDE's for other environments. I believe Java combined with a next-generation Java IDE (Eclipse or especially IntelliJ) can recapture much of the productivity that's supposedly lost to Python's terse syntax. Intelligent code completion gets around Java's rather wordy way of doing things, and refactoring support makes supporting that verbose code a breeze. IntelliJ is smart enough to figure out if you have a variable, what type it is once you declare it and can offer constructors to instantiate it without you having to do all the typing. IntelliJ can even find redundant bits of code and refactor them into a method for you. One of Python/LISP's main attractions is the interactive environment. Java's hot swappable classes combined with IntelliJ's debugger allow you to experiment and play around with your classes while your program is running, all the while inspecting your data structures, having conditional breakpoints, evaluating arbitrary expressions on the fly, etc. Really quite amazing how far java debuggers have come in the past few years. Plus java's remote debugger makes attaching to an already running process as easy as debugging locally which is great for debugging complex server side stuff. Checked exceptions is a big problem for Python0philes. You can get around that in Java by throwing RuntimeExceptions, but some find that sloppy. The right way to avoid having to declare a boatload of exceptions from a method, is to catch low level exceptions and throw a higher level exception (e.g. your library catches IOException, SQLException, throws LibraryException). I've got IntelliJ set up with a template to generate a new Exception with one click and just fill out the name of the exception, and, viola, you've got your higher level LibraryException and you've forever liberated your users from having to worry about an IOException when calling your method and allow them to do more sensible generic error handling. IntelliJ/Eclipse has tight integration with a number of standard tools like Ant (for builds), JUnit (for unit testing), XDoclet (for code generation), as well as plugins for tons of open source projects (by untalented non-hackers, according to the esteemed Mr. Graham) that make the task of getting work done a little easier by keeping you from inventing the wheel. So what you're left with is an IDE that can compensate for Java's supposed weaknesses and lets you enjoy Java's strengths, which have been enumerated by numerous prior posts (Robust Libraries, Strong typing, standardized Unit testing, standardized build tools, platform independence, strong documentation, very few nasty surprises). Which leaves me to wonder why, with all the great productivity and mind expanding power of Python and especially LISP (which had every f*cking feature back in '57 with McCarthy), do we struggle with vi or emacs, several slightly incompatible versions of LISP, shitty IO/concurrency libraries (for LISP), poorly documented libraries that you're not sure will work until runtime and even then may die on you unexpectedly in production when you blindly pass in some unexpected type, with decentralized pockets of apis scattered across the web in various states of disrepair? Java libraries seem to be a more organized affair, certainly from a documentation standpoint (the power of strong typing, checked exceptions and Javadoc are underestimated in my opinion and is one of the unsung features of the Java language) than most Python and certainly LISP libs out there. Why can't there be an IntelliPython, or IntelliLISP. My point here is not to bash Python or LISP or any language. I have done a bit of work with scripting testing with Python (Jython actually) and am making an effort to learn CLISP (from Paul Graham's ANSI Common LISP), if only to deepen my programming knowledge, through "bottom up programming" , macros, functional programming, etc. But, if I'm going to make the effort to learn a new language, I don't want to go back to the dark ages of friggin VI or emacs just coz Paul Graham says I can have better living through macros. It's the tools, stupid!
Sure why not? You're well within your rights to change how Linux works on your machine(s). It's when you release it as your own in a non-free manner that you run into problems. But that's a bad analogy due to the differences in licensing (GPL vs FairPlay).
Accessing a DB is by far the biggest bottleneck for most applications that I've worked on. It is usually at least an order of magnitude slower than any other operation. I think DB's are probably one of the most inappropriately used technologies in the "enterprise" space. You can't wipe your ass without an ACID db for all your persistence, when in practice, the only thing you really need a db for is for querying for reporting and crap like that. For OLTP stuff you'd probably be better off with something like this, or Berkley DB which forgo the SQL Engine and just offer more direct access to the underlying datastructures for much greater performance. Then you can have some other process parse up the persisted data and populate your reporting database.
Don't Touch It! It's Evil!
That's the appeal of TiVo. It's supposed to give you control over the stuff you see, filtering out the crap you don't want to see (commercials, etc.). Which is why Big Media is so against it. No argument about the crappy content on tv, though. I've been without one for a year and I'm not looking back.
>>Can't support TiVo. I can see paying for convenient TV listings, but the ability to record/timeshift should come straight out of the box. Which is EXACTLY what it does
I haven't used it myself, but this debugger for Java allows you to record the execution of your program and play it back again and again to see what's happening, who's setting what variables, etc http://www.lambdacs.com/debugger/debugger.html It appears to be free (as in beer), so there's a bonus for your right there!
I just picked up this <A HREF='http://www.archos.com/us/products/product_50 0201.html'>puppy</A> that has 6 Gigs of storage and can rip directly from any audio source. And it's $350. Seems to me to be the best of the IPod and this thing, for 50 bucks less. You can take that cash and buy 2 Rocco DVD's
Servlets offer the advantage over traditional CGI of being persistent, that is the servlet engine runs inside your webserver continuously waiting to handle requests. So you don't run into startup costs per request as you do with traditional CGI. This was the key advantage that servlets had originally over Perl/C/C++ but I think there are other alternatives now that do similar things in these other languages.
However, once you buy into servlets and Java, many other things that you might want to do from your web application are wrapped up in a nice little package (DB API, threading, RMI/CORBA, etc). The servlet engine provides a framework for getting input parameters, cookies, etc. and allows chaining servlets to process different parts of the request. And a nice thing about servlets is that (ideally) you should be able to write your servlet application and run it on JRun or Tomcat or whatever engine works best for you with no modification of Java code.