Slashdot Log In
When a CGI Script is the Most Elegant Solution
Posted by
CmdrTaco
on Sun Mar 04, 2007 11:52 AM
from the the-answers-is-always dept.
from the the-answers-is-always dept.
An anonymous reader writes "Writing local Web applications can be quick, easy, and efficient for solving specific Intranet problems. Learn why a Web browser is sometimes a better interface than a GUI application and why experienced Web developers find themselves struggling to learn a GUI toolkit, and descover that a simple CGI script would serve their needs perfectly well, if not better."
This discussion has been archived.
No new comments can be posted.
The Fine Print: The following comments are owned by whoever posted them. We are not responsible for them in any way.
Full
Abbreviated
Hidden
Loading... please wait.
When is a CGI script the most elegant solution? (Score:5, Insightful)
Easier than Networking! (Score:5, Insightful)
Quick web scripts are way easier than developing an application if only for the fact that you don't need to figure out how to use networking in whatever language you'd be working in. Plus, you don't need to "distribute" the application once it's done, and you don't need to provide updates to every user on your network who's using it: update your script, update the application.
Plus, developers think in program logic, not in program design. A web script let's the developer write their output in HTML, then go back in later and add some CSS for presentation once they've got the program actually working. I say, it's a good way to do things.
Not to mention that a lot of web scripting languages are easier to use than full-blown application languages, and there are many packages that let you attach native GUIs to web scripts. There isn't a compelling argument not to go that route if your application a) uses networking, and b) is distributed over an intranet.
Re: (Score:2, Informative)
Then there is the joy of browser compatiblility. You start out saying, oh, we will only support browser X...but it never sticks...and your regression testing grows geometrically with each browser and version of bro
Re:Easier than Networking! (Score:5, Insightful)
Honestly, as a web developer, I've never quite understood this. Whenever I design a website, it'll often look different in multiple browsers (read: it'll be effed up in Internet Explorer), but unless I use a particularly fancy bit of JavaScript, they almost always functionally work the same in multiple browsers. I just don't get it... are the people who are writing the web apps really that bad with their concept of standards? Are they relying on browser bugs to do a job? Or are they just getting way too cutesy with their JavaScript? Should someone give them a dictionary open to the word "testing"? It just seems to me to be silly not to spend five extra minutes per browser to open your app up in IE, Firefox, Safari (if Macs will be using the app), and Opera (which is pretty guaranteed to work if Firefox and/or Safari does).
Other than that, though, I agree with what you're saying, in many cases it looks like a full-blown app would be the best solution. I was thinking along the lines of quick fixes that were easily expandable, though, which in my mind is best for web app.
But hey, in computers there's no wrong way to do anything, right? You just need to gauge which method will make your users swear the least. ;)
Parent
Re:Easier than Networking! (Score:5, Insightful)
But which bits of java script are fancy and which are not? And how often is almost always? It comes back to pushing stuff out on the server and crossing your fingers...and there is plenty of that inherent in development without your two qualifications. I guess I'm kind of anal, but, dammit, when I write a line of code I want it to do the same thing for everybody that runs it. That way I can focus my attention my own boneheaded mistakes.
" I was thinking along the lines of quick fixes that were easily expandable, though, which in my mind is best for web app."
Quick fixes that are easy expanded tend to grow into gigantic morasses of tacked on code with no toplevel design. In 20 years, the poor churl that has to deal with that monster will be damning you to the fiery depths of hell!
Parent
Re:Easier than Networking! (Score:4, Informative)
This is actually quite easy. Stuff that relates to the DOM often differ from browser to browser while the core language does not. This is somewhat similar to the fact that you can compile and link ANSI-compliant C on virtually any platform as long as you don't do anything platform specific.
At work I recently developed a JavaScript framework for calculating text length that had to take variable character widths and hyphenation into account. The idea is that the user can type away in a standard TEXTAREA field and know when some predefined text area in a PDF document is full. I think the code ended up as 500+ lines of JavaScript code, but the ONLY browser specific problem I ran into was a subtle difference in the parsing of arrays; Firefox would treat the statement [1,2,3,4,] as an array with the length of 4, while Internet Explorer would say the length was instead 5 (and the last value was "undefined", if I recall). I gather that the reason why browser independence came so painlessly was that 95% of the code was just text processing and number crunching anyway. I doubt I'd have the same luck if I tried to do a WYSIWYG editor since it would have a great more interaction with the DOM.
Parent
Re: (Score:2)
Perhaps the Javascript they write is, I dunno, particularly fancy? Once you handle events, for example, in your code beyond onClick and onMouseOver, you find they need to be handled differently. And a site that's "effed up" in IE isn't actually acceptable to most web dev
Re: (Score:3, Interesting)
Anyway, whenever I've had problems with script compatibility it's ALWAYS been with event hooks, and with very bas
Re: (Score:3, Informative)
Re:Easier than Networking! (Score:4, Insightful)
With a web app, you also download your code with every single page. Graphics. HTML. Javascript. Every single time.
Yeah, or you could try caching stuff locally on the client machine. This can easily be done with expire-tags or similar. I'd also considering using inline CSS and JavaScript instead of linking them in externally as files. Surely this will reduce the network load. One could also use AJAX where applicable in order to keep pages from refreshing too often. This would also make the app quite snappy.
Otherwise, a high level language running directly against an SQL server is the way to go
Again, this traffic across the network would not exist if you used a web application for the purpose. So, perhaps the HTML transferred through the network is in fact equal to the SQL flowing back and forwards? Hmm.
Then there is the joy of browser compatiblility. You start out saying, oh, we will only support browser X...but it never sticks...and your regression testing grows geometrically with each browser and version of browser you support.
Ok, but what happens to your precious application when your company's Windows users are screaming for a functional version? Mac OS X? The web is a great tool if you need to deliver content and functionality across different setups. I'm sorry, but to me your arguments sound silly. I believe this is a matter of relativity; if I know how to create web based applications (internal or external) and do it good, then it'd probably be the wisest choice instead of me trying to learn "a high level language". Of course, this goes both ways.
Parent
Re: (Score:3, Insightful)
Actually, the opposite should be true. Client browsers will typically[1] cache the contents of an external .css file, downloading it no more frequently than once per visit (the same holds true for .js files). If you're inlining your CSS or Javascript as part of your pages, the client has to download a copy each and every time they load a new page on your site. Granted
Re:Easier than Networking! (Score:4, Informative)
Im working for an (extremely large) company that decided on web apps for the deployement thing alone, without needing (or -wanting-) any of the other advantages. So we have slow, bloated, IE6-only web apps. Hey, its easy to deploy. Has the users cursing non-stop and wanting us dead. But its easy to deploy!
Parent
Re: (Score:2)
Re:Easier than Networking! (Score:4, Insightful)
Parent
Re:Easier than Networking! (Score:4, Interesting)
What's funny though is that the example in the article was neither networked nor multiuser. Why not skip the CGI part even and just have commandline scripts to do certain things? I can't say I've ever really consider writing a simple, single-user one-off GUI application. Nor can I think of a time where I'd want a personal web server listening on a local IP/port.
No, developers think in program design. *Programmers* things in program logic.
But if it doesn't do a or b (as in the article), Perl/Tk is probably simpler than even bothering with a web server. That is assuming that a GUI is even important at all.
-matthew
Parent
How about a step simpler? (Score:3, Insightful)
photo example (Score:2)
Why not just use the command line? I didn't see anything in this article that would exclude its usage.
An example he cites but does not provide, is a photo browser. You could use a combination of image magic and curses to do the same thing, but cli input could be tedious for more than simple viewing and the author's approach could save effort.
I'm doing a lot of cli image manipulation and I'm interested in this technique. I've got an ugly imaging device and a pile of c code to interpret it's output a
Re: (Score:2, Informative)
There's nothing necessarily wrong with that approach. However, as a practical example, I worked for Insurance companies and we developed software initially using nothing but DOS. However, even for simple form processing, it was quite a task (especially when each vendor had their own specific designs for their property and casualty policies). Just to rearange those items even from a given template (or u
Ugh (Score:4, Insightful)
If they meet the following restrictions, they *might* be considered equal:
1) Does not use Java.
2) Works on multiple browser, including future versions of IE which may have more strict security settings.
3) Does not require any client-side settings to work. (For instance, lowering security settings, turning off the pop-up blocker, etc.)
But every web-app I've ever had to maintain in a corporate environment violated every one of these rules. And I'm talking about big companies making these web-apps, like IBM and Siemens. The end affect was:
1) Some only used MS Java, some only used Sun Java, meaning that if a browser had one web-app installed you couldn't install the second one because the Java version would be incompatible.
2) They worked on IE only, which only exaggerated the downfall of the previous point. (You can only have 1 IE per computer, and 1 Java per IE, web developers!!) In addition, it meant that the company I worked for had to freeze IE upgrades to prevent breaking web-app features.
3) We had tons of security problems because of web-apps that required the pop-up blocker to be turned off, or security features to be turned off. (You can only have one set of settings per browser, web developers!! And most of the time, trusted sites doesn't cut it, from my experience.)
Even if all these conditions are met, there's still a good chance that the interface of the web-app might plain suck. The web-based ticketing system "feetimpressions" (not naming names because I still have to work with it, but I think you can figure it out) has a terrible interface. It would be equally terrible as a desktop app, but at least it would run quicker so when you made a mistake you could undo it quicker.
* To be fair, one of the web-apps above was basically a Lotus Notes database converted into a web-app, and Lotus Notes has its own enormous GUI blackhole which seems to suck in any good GUI and mutilate it into something frightening.
Re:Ugh (Score:5, Insightful)
Parent
Re: (Score:3, Insightful)
If you think back, way back when Windows 95 was out people were making th
Re: (Score:3, Insightful)
Oh, it can. Maybe not for "real", but there are toolkits that build entire "windows managers" in javascript. Works amazingly well.
Now that depends where we stop the line of "web app". If we count it as HTML/CSS/Javascript/Whathaveyou, you're right. But there are things coming out to bridge the gap. For example, WPF/XAML, which is fairly amazing, though nothing a slashdotter would be interested in
Re:Ugh (Score:5, Informative)
Parent
Re:Preach it, brutha (Score:4, Interesting)
Remember, if you have a feature that people can't figure out how to use, for all practical purposes that feature does not exist.
If you want to make X popular, first of all give it a decent name. Secondly, write an extension to Firefox so that a specially-tagged HTML page can call an X application over the Internet to run it. Add in all the bells and whistles I described in the grandparent post, and bam, you have a winner... assuming you can make it work without requiring gobs of Linux knowledge like it does now. Now when I visit Gmail, Google can put up a highly interactive email client which lets me drag&drop a file into the email window to add an attachment, and I'm happier and Google's happier and Firefox has a huge selling point.
From what I understand, though, X isn't suited for this for a couple reasons:
1) It's designed to run an entire desktop over the network link, not just one single application. i.e. you define a rectangle as "the desktop" and all windows/etc that X opened would have to be contained in it... that's not ideal.
2) It's bandwidth-heavy. Maybe not when competing with Citrix, but if Google started using it they would see their bandwidth bill skyrocket.
3) X doesn't solve the problem of native widgets. X applications run in OS X look like crap because the widgets are simple greyscale things that look like they were rejected from Windows 95, and not the nice-looking OS X buttons and widgets. Additionally, X applications in OS X still can't accept drag&drop, or use the OS X spell checker, or communicate with other apps, etc etc.
If it's going to happen, I think a new protocol needs to come forth. Perhaps something that transmits VB-like "forms" to the client on demand, and the "forms" can contain scripting in Python to accomplish the task, with a network protocol to stream-in new "forms" as needed and to interface with a remote ODBC connection through this psuedo-app. You could design the "forms" to take up minimal bandwidth and use native widgets by giving instructions like "draw a pushbutton with a label 'hello' at this coords" instead of sending bitmaps (like X does.) You'd also be able to script a form to modify itself to some extent, so you wouldn't need to make a round-trip to the server every time you hit a disclosure triangle.
If anybody builds this, put my name in the credits.
Parent
Re: (Score:3)
Not true. There are drag-and-drop Javascript controls for the usual platforms, though I don't know of any that are platform-independent. I've used them on Windows and Linux and they work.
I'm guessing as to what you mean by "safely" in this context, but it's possible (and I've done it) to open multiple windows, and to then maintain state in such a way that
Re: (Score:3, Insightful)
Yes.
Until you can, web-apps will never be of the same quality as regular applications.
PHP-GTK apps are not "web" apps. They are scripts that can be downloaded. They don't need to be compiled - they are scripts. PHP is usually used for server-sided website processing. But it also works very well as a shell or client script, comparable to Java or Python in many ways.
If I'm writing an email
Re: (Score:2)
Microsoft OLE DB Provider for SQL Server error '80040e14'
/bilddb/content.asp, line 341
Line 1: Incorrect syntax near '('.
Passing chars for numbers in the GET variable nodeID returns an error like "nvchar cannot be converted to an int." Shouldn't the script be handling tho
Re: (Score:3, Informative)
If they meet the following restrictions, they *might* be considered equal:
1) Does not use Java.
2) Works on multiple browser, including future versions of IE which may have more strict security settings.
3) Does not require any client-side settings to work. (For instance, lowering security settings, turning off the pop-up blocker, etc.)
But every web-app I've ever had to maintain in a corporate environment violated every one of these rules.
A few points:
1) These are not rules, these are your own biases.
2) I share bias #2.
3) We're talking specifically about intranet apps here. In an intelligently-managed workplace, having to customize the client shouldn't be particularly onerous (it's not like the IT folks should have to walk to each computer and do everything by hand anymore, if you're managing things correctly). The particular modified settings you list should be no-nos, in my opinion. But, say, requiring JavaScript should not be considered
When the web apps are taking over ... (Score:5, Interesting)
A lot of people are replacing client-server apps with browser based apps, with zero install hassles - which this particular example doesn't really have. But learning to build html apps in CGI mode is easier than re-learning event loops for GTK land (even in perl).
Of course, debugging in-browser apps is getting easier with firebug [getfirebug.com] and other developer oriented firefox bits. Now, whether the app is built using perl-CGI, mod_perl, php, ruby on rails, even servlets doesn't matter - the UI can actually work very well. For instance my sudoku [dotgnu.info], in fact looks better in HTML than if I (let me repeat, if *I*) had done it with GTK or MFC.
And CGI still hasn't lost its edge totally. There are places when you *have* to use CGI to do what you want. I ran into one case when I couldn't use php when I wanted to server pushes [dotgnu.info] on a live connection. Instead of firing multiple requests to the server, I hold the connection and push data when it comes available - sort of stateful connections reinvented for HTTP. Which has definite promise when you're building mashups, which fetch data from elsewhere without cross-user leakage (heh, if he can hijack TCP, I don't know what...) - flockr [dotgnu.info] for instance uses such a script in the backend to feed it data (except I'll be an idiot to post a live CGI script to slashdot).
CGI ain't quite dead yet ...
Another issue (Score:5, Insightful)
One of the issues that concerns me is what essentially amounts to hijacking of my processing resources. One example is animated ads. It takes CPU power to continually flip a large ad's frames; that's *my* CPU power. So I don't let flash or animated GIFs run unless I make an exception. Same thing applies, for instance, to the difference between slashdot and digg. Slashdot provides a static page. I can load it, and the fact that it is loaded costs me nothing in particular. If I flip away from the browser, it doesn't chew CPU time. But if I load a digg page, my CPU is pegged for a while, especially with large pages, because digg is bloated, slow-as-hell pigware that uses *my* CPU to display and organize its content. Guess how much time I spend there. :)
As I generally have other things going in the background, I don't take kindly to profligate use of my resources; animations, pigware, etc. I keep my eyes open, and I tend to spend time on places that more resemble slashdot than digg in this regard. I *will* bite if the site offers something that overcomes my urge to keep my cycles for myself, but that is a conscious value judgement, not an accident.
Generally speaking, there's another advantage for sites that produce HTML and CGI forms, and do not depend upon the user's computing environment, and that is broad compatibility. If you stick to the basics, then the broadest set of browsers will function with your "stuff." No Java, no PDF, no flash... just the basics. You can make beautiful, functional websites (assuming you've the art skills) with the basics. I see no need for more; the value is in the content, and it isn't like you can't make a good presentation. The first thing I think when I run into a morass of Java, etc., is "incompetent."
But that's just me. :)
Well, sort of, Yeah -- maybe (Score:3, Insightful)
First of all, writing a simple GUI application using say Python and TKinter is probably easier than writing a web application. I'm sure the same is true of Ruby, Perl, etc. Or Visual Basic for that matter although VB's database interface (at least in VB3) was so obtuse that I decided to find another language. All of those languages will handle the Event interfaces relatively gracefully.
Second even the localhost (127.0.0.1) interface is likely to be a bit jerky.
Third, No two browsers will render HTML beyond the "hello world" level consistently. Conceptually, that shouldn't matter, but if your input boxes don't appear or line up with inappropriate material in the page display, you can end up tinkering with your application well beyond what you originally envisioned.
Fourth, Browsers cache web pages. They don't always figure out that the page you have requested has changed. It looks to me like NOCACHE statements in HTML pretty much don't work. They may work when used in the HTTP (1.0 or later, right?) header, but getting them there may be non-trivial. This is not a big deal if you are the only user and understand caching since all browsers allow you to force a page reread. But it is not going to work out well with ordinary users.
I'd say that there is a place for simple web applications. But there are a lot of situations where alternative solutions are probably going to be more usable or simpler than a web browser, server, and CGI.
So, CGI is a perfectly OK tool, and maybe it belongs in the toolkit. But it's by no means universally the best solution.
The Screen is The Interface (Score:4, Insightful)
Yes, I often do use a web browser as a script GUI. A web browser changes a few HTML text strings into a pretty display.
Re: (Score:2, Interesting)
GUI = Graphical User Interface
Lynx = Text based web browser
You were saying... ?
Re: (Score:3, Interesting)
If it is only a few lines, it probably isn't 'pretty.' It is probably just a plain, small form centered in an oversized browser window. Personally I find things like PerlTk to be much "prettier" if only because the window is taylored to the app. And also the box model of Tk is MUCH easier to work with than HTML/CSS. I find reliably placing elements on the screen with HTML/CSS to be a huge
I don't understand! Help me? (Score:5, Insightful)
It sounds like the author is recommending a single instance web server application running on a local machine that uses a file store instead of a database and CGI as the programming interface. (In other words, this is NOT an intranet application for multiple users!) Doesn't sound that simple at all. In order to do this, you must:
- Know at least one programming language for CGI.
- Know HTML including forms, postback and session.
- Understand the limitations of web browser UI elements. (There are many.)
- Install and maintain a webserver on your local machine.
- Build a robust file store interface. (Even loading / saving / parsing XML files with backups takes time...)
- Install and maintain permissions for the file store.
- And more...
Sounds like all of the disadvantages of the web with none of the advantages.
Why would you not use PERL and CSV IN/OUT files for simple (or complex) command line processing -- and if you needed a really simple UI, then Excel with Visual Basic. (This isn't easy, but it's a lot less technology to learn and maintain.) Anything more complex: Java, the free version of Microsoft VS or xcode. Anything worth doing is worth doing well.
Those who fail to understand GUI apps.. (Score:5, Insightful)
The premise of the article is that a local application written to target a local server with web browser client is better, but then goes on to say essentially 'ok, here are all the pain in the ass things to overcome when trying to scale it down to a single user compared to typical web server environments'. In his article, he is trading one perceived pain in the ass set of things for another. The unstated stuff is you are requiring the unmentioned user to first have a webserver and CGI environment set up correctly before even beginning to run your app (since the aim is to be standalone on a box, the user's system is the server). He mentions some shortcuts you can take by assuming some network security things and no DB, but in the end the shortcuts are still more work than simple GUI apps for the equivalent task.
As to his fear of GUI toolkits, it's actually mostly silly. He sums it up by saying web browsers don't make you deal with 'resize events, window expose events, or menu events', but the truth is for a GUI application of the complexity he speaks of, GUI toolkits largely don't *make* you, they *let* you. If your application is as simple as what he prescribes, you can ignore that whole functionality of the toolkit. Sure you have to connect events to widgets of interest (i.e. buttons), but you have to do the exact same thing on webapps, but with different wording. If your application has some reason to start messing with the sort of stuff he fears dealing with and is implemented in a browser, a whole lot of pain is in store for you with obscure, platform specific javascript aplenty. Similarly, he mentions file opening/saving, and font management, but again, the toolkit usually has user-wide settings you can ignore the existence of just like a browser for font and style, and evoking the Toolkit standard filebrowser is usually exceedingly simple (along the lines of filename=Chooser() (not a specific language/toolkit)).
I have dealt with quite a few 'webapp-for-everything' people, generally they make web apps with an exceptionally clunky interface that responds poorly (I actually dislike Gmail's interface, but Zimbra was impressive, but still sluggish). If I find myself using it frequently and I can find out what it is frontending (usually a database for general apps, imap for mail, etc), then I write a quick GUI application or use a standard standalone app to do the same thing. I end up with a smoother interface that lets me be more productive, and often things run faster (webapp deployments are frequently the bottleneck, the backend could service far more than the webapp can push through for whatever reason). Whenever I do that and someone glances me interfacing with a system notoriously annoying in interface, they always want my application. Again, good Webapps can be on par with GUI apps, but for all the reasons the guy mentions, webapp developers mostly think implementing everything as simple forms is the way to go and that sucks for a lot of usage. GUI apps of course can be written piss-poor as well, but the typical GUI toolkit primitives are richer than simple HTML forms.
The only potential thing depending on how the app manages data and how it could be useful is the issue of scaling out/up. With a standalone GUI app, the barrier to running it remotely and having all your data in one place is higher than webapps (if running it remotely, must have X/RDP/VNC client installed on your random client which is less likely than a browser, if just having the data remote, still have to get the data accessible via some means and your client must have your software). This is a hard thing to define concretely, but the implementor should be able to make this determination fairly easily.
Re:Those who fail to understand GUI apps.. (Score:4, Insightful)
The original post was solely about CGI, and not at all about client side javascript. This being slashdot, however, almost nobody bothered to notice.
Yes, compared to a "real" gui, html forms don't have the same richness of user interaction possible. Guess what? For 90% of applications, that's a GOOD THING. Forms have evolved the way they have because they're reasonable and reasonably secure for networked UIs. There's always temptation to use some shady "experimental" ui technique, but it turns out that developing good UIs is tricksy, and that these are failures most of the time. Stick to Forms unless you know the reason why not.
There are other advantages as well. Is the best language to solve the problem something wierd and non-deployed, ala Common Lisp? CGI lets you use the language of your choice, without having to do security audits on all the machines envolved.
CGI also enforces a fairly strict seperation between application guts and UI. Even in this day and age, many people still manage to mix these, to their sorrow.
Unlike GUI platform of your choice, CGI has not changed specification since, what, 1994? A script written then will still run today. The same can not be said of GTK or KDE or Mac apps, and I'm not so sure about Windows 3.1 to Windows Vista compatiblity either.
I'm mystified as to why Parent thinks enabling CGI is a "pain in the ass". For me it was a 1-line change in apache.conf for the first script, and then a 0-line change for each additional script. What's so hard about that?
Parent
Here's what happens a month later... (Score:4, Insightful)
"Okay, can we have a basic real-time price chart on that?"
"Can you pick up the settings for my main thick-client work application and use those?"
"This is OK for offline work but now that we're using it seriously it has to respond to clicks right away."
"Ok, when we enter the currency pair, the visual display of the curves should update immediately before we enter the price, just as a sanity check."
Of course you can always reply:
"Well, I decided to do this as a CGI script. That meant a bit of a tradeoff whereby it was easy to develop at the time, but we can't really extend it with rich client-side functionality like that."
To which the correct answer is:
"Looks like YOU have a problem!"
Okay, that doesn't ALWAYS happen. But it certainly happens a lot -- if there's any chance that that the solution will be compared to thick-client apps, it's really not a good idea to start with the web. When everyone's lucky, the result is that work starts on a proper client application. When everyone's NOT lucky, the Java applets and DHTML wizardry come out, and you're left supporting and justifying an increasingly complicated solution that's heavy on scripting and net traffic and that's competing with solid (usually C#) client/server apps. Which is a pain.
Re:Here's what happens a month later... (Score:5, Funny)
if (you == inHouseProgrammer)
"Well you cocksuckers should have told me all this shit up front so I didn't waste my weekend writing a useless web app. If you want it fixed, do it yourself"
else if (you == consultant && you == chargingTimeAndMaterials)
"I'll be happy to add those new requirements for you, but I'm afraid that's going to impact the schedule."
else if (you == consultant && you == chargingFixedFee)
"Thanks for the feedback, bit I'm afraid we will have to address those new requirements in a follow-on contract."
Parent
Have a look at SWILL (Score:3, Informative)
SWILL is great for adding an interface to legacy code, because its impact on the application can be minimal. I wouldn't recommend its use if your GUI requirements are above what can be implemented in a dozen web pages.
Re: (Score:2)
Re: (Score:2)
Re:descover? (Score:5, Funny)
Parent
Re:You web developers... (Score:5, Insightful)
Parent
Re:You web developers... (Score:5, Funny)
Parent
Re:perl? (Score:4, Interesting)
perl CGI, however, is crap as you said
Parent
Re: (Score:2)
Re:What about PHP? (Score:4, Insightful)
Common Gateway Interface [google.co.uk].
PHP is just another language that can be used for a CGI script.
Parent
Re: (Score:3, Informative)
Why would a server NOT have CGI? Unless what you really mean is the developer doesn't have CGI access on the server. I'm not sure you're understanding what CGI is. It is NOT perl. It is NOT PHP. Although both can be used. My cgi-bin is full of custom EXEs.
In simple terms, here is how CGI works; dynamic information from the client is passed to a process launched by the web server through environment variables and command line. An application runs natively on the machine, such as a
Re:What about PHP? (Score:4, Informative)
Need I go on?
Parent