The same app 4 times: PHP vs Python vs Ruby vs Clojure

Ruby is clean (but I dislike the stack), and Python looks good, but ye gads is Closure ugly... Uglier than PHP, even.

My favorite part about PHP is how easy it is to get a simple Nurble-like app up and running... but that's just me.

Something rubbed me wrong with this statement. If you are going to make a remark like '[Clojure's] performance should be the highest of the above,' shouldn't you at least try them first?

I'd like to refactor the Ruby example, but I'd like to know what the proper implementation should be!

    NOUNS = {l.strip().lower() for l in f}

    fs = require 'fs'
    express = require 'express'
    app = express()

    app.use express.bodyParser()
    app.use app.router
    app.use express.static(__dirname + '/public')
    app.set 'views', __dirname + '/views'
    app.set 'view engine', 'jade'

    nouns = fs.readFileSync('nouns.txt', 'utf8').split('\n')

    nurble = (text) ->
      text = text.toUpperCase()
      words = text.toLowerCase().replace(/[^a-z ]/g, '').split(' ')

      for word in words
        if word not in nouns
          re = new RegExp "(\\b)#{word}(\\b)","i"
          replacement = '$1<span class="nurble">nurble</span>$2'
          text = text.replace re, replacement

      text.replace  /\n/g, '<br>'

    app.get '/', (req, res) ->
      res.render 'index'

    app.post '/nurble', (req, res) ->
      res.render 'nurble', {nurble: nurble req.body.text}

    app.listen 3005

I thought you were just going for line-for-line parity until I came across the Clojure example. I think you could've written that same `for` loop in Clojure and either yield the original word or yield "nurble" if it intersected a noun. But this is put up or shut up territory and I'll take another look.

Also, could you clarify why you make multiple assertions that Clojure is "too much" for this task?

I'm a fulltime Ruby developer learning Clojure on the side and Clojure's Ring+Compojure feels like Rack+Sinatra to me. In fact, the choice between Ruby and Clojure to me is as trivial as using Python or PHP. Here's ClojureDoc's tutorial on making a DB-backed webapp in Clojure: http://clojure-doc.org/articles/tutorials/basic_web_developm.... It's just Sinatra/Flask in another flavor all over again.

The only downside of Clojure so far for me is that I might already be drunk with that special Lisp koolaid already.

Also, I think the regex usage makes the code a little harder to digest and comes at the cost of further unnecessary cycles.

I think this code gets even easier if you don't have to preserve the whitespace and filter non-alpha characters. (see danneu's suggestions)

Finally, what are your thoughts on passing along the wordlist (nouns) as an arg to nurble? This would offer referential transparency and also make the test easier.

Btw, I think your update broke your gist (where you changed (some (partial = w) nouns) to (not (some (partial = w) nouns)). Check that out again.

Cool post, thanks for sharing.

  <%@ page import="java.nio.charset.Charset" %>
  <%@ page import="java.nio.file.*" %>
  <%@ page import="java.util.List" %>
  <%@ page contentType="text/html;charset=UTF-8" language="java" %>
  <%!
    public String nurble(String text) throws Exception {
      text = text.toUpperCase();
      String[] words = text.toLowerCase().replaceAll("/[^a-z ]/", "").split(" ");
      List<String> nouns = Files.readAllLines(Paths.get("nouns.txt"), Charset.defaultCharset());

      for (String word : words) {
        if (!nouns.contains(word)) {
          String pattern = "(?i)(\\b)" + word + "(\\b)";
          String replacement = "$1<span class='nurble'>nurble</span>$2";
          text = text.replaceAll(pattern, replacement);
        }
      }

      return text.replace("\n", "<br>");
    }
  %>

  <html>
  <body>
  <h1>Your Nurbled Text</h1>
  <div><%=nurble(request.getParameter("text"))%></div>
  <p>
    <a href="/">&lt;&lt; Back</a>
  </p>
  </body>
  </html>

As for your comment on you have to load up the nouns file each file, assuming you have PHP 5.2 or later, the file will stay in memory when using APC and is reused. You can opt to extract the content and store that in memory also.

Lastly, for performance, the code could be improved as I mentioned above, but Apache is definitely not the way to go for performance. NGINX is the way to go, both are very similar, but when it comes to performance NGINX is super lightweight, fast and handles a heck of a lot more connections.

overall I think I prefer the python example.

- You're comparing raw PHP with frameworks from other languages. Try not using frameworks in other languages.

- You're saying that PHP has no dependencies manager - http://www.getcomposer.org

- Using anything more than PHP for such task is an overkill.

To be clear, I'm not saying that PHP is the best language of them all. Like all languages it has its ups and downs and there's a lot of subjectivity on what you like and dislike. I'm just saying that such comparison isn't really fair.

Source is available here: https://github.com/NickPresta/nurblizer

There are some minor differences (due to Go lacking backreferences with it's Regexp package, as far as I can tell) that I don't care to fix. Still, in ~74 lines of code, you get something pretty decent (and no external web server required, either).

[1] https://github.com/brucespang/Frank.php

Note you are very nice with the PHP implementation by using a function instead doing the foreach inside the HTML ;)

May I suggest improve the article by including: 1- an HTML template of each framework (since each seems to have a their own syntax) 2- the JS and GO example (since it's the trend on YC) 3- Use the Framework name instead of the language name

Most modern PHP projects (PHP 5.3+) are using namespaces, autoloaders, and Composer to handle dependencies.

http://getcomposer.org/

http://codepad.viper-7.com/1MFTAW

You can also improve the php function by using nl2br and isset instead of in_array

Here is a revised code : http://codepad.viper-7.com/4OtoTD