Lisp is sin

Post by [deleted] » Tue, Sep 01, 2009, 5:43 PM UTC

itgoon wrote: post #14

KirinDave wrote: post #11

Earlier quoted context omitted.

Shouldn't we ask ourselves if this goal is reasonable? Making arbitrary software is at the limits of our capacity right now, even if people devote their lives to it as a profession, passion, and an art. It's one thing to take an approach like Apple Automator (a much beloved automation environment), but it's another entirely to say, "General Purpose Software should be within the grasp of the 'average person.'" It's no…

Horse hockey. While I know that there are a lot of horror stories (and I can tell a few), some of the most productive "programmers" I've ever met used MS Access or Excel. If you don't consider advanced usage of these applications as a form of programming, then you are illustrating the point: It is not only possible to "dumb down" programming, it is inevitable. So much so that you haven't even noticed it happening.

Post by yummyfajitas » Tue, Sep 01, 2009, 5:47 PM UTC

arakyd wrote: post #7

semmons wrote: post #4

> But I'm willing to bet that a lot more developers will be able to understand this since this is in a programming language they understand well. This is one argument I don't buy. He talks about the Mort programmers never being able to understand Lisp. I am willing to bet, any Mort programmer who looked at this C# would not be able to understand it. I'm sure they could take advantage of it, but write it themselves, I…

Yeah, he says that Lisp is too hard for the common man, and then sort of implies that this is because it doesn't use ALGOL derived syntax. I don't think that's the issue. It's not Mort who's fallen in love with ALGOL syntax, it's the CS graduate Elvis's who cling to their expensively acquired "skills" (priesthood memberships) with religious fervor (he says, as a CS student). I program in C#, and lambdas and delegates…

    [a, b, c] -> '(a b c)

    f(x) -> (f x)

    {
        f(x)
        g(x)
    } ->
    (progn
        (f x)
        (g x)
    )

Post by andreyf » Tue, Sep 01, 2009, 5:59 PM UTC

semmons wrote: post #4

> But I'm willing to bet that a lot more developers will be able to understand this since this is in a programming language they understand well. This is one argument I don't buy. He talks about the Mort programmers never being able to understand Lisp. I am willing to bet, any Mort programmer who looked at this C# would not be able to understand it. I'm sure they could take advantage of it, but write it themselves, I…

    function memoize(f) {
        var memory = {};
        return function memoized(arg) {
            return arg in memory ? memory[arg] : (memory[arg] = f(arg));
        }
    }

Post by tnovelli » Tue, Sep 01, 2009, 6:09 PM UTC

yummyfajitas wrote: post #24

arakyd wrote: post #7

Earlier quoted context omitted.

Yeah, he says that Lisp is too hard for the common man, and then sort of implies that this is because it doesn't use ALGOL derived syntax. I don't think that's the issue. It's not Mort who's fallen in love with ALGOL syntax, it's the CS graduate Elvis's who cling to their expensively acquired "skills" (priesthood memberships) with religious fervor (he says, as a CS student). I program in C#, and lambdas and delegates…

Something I've never gotten around to is building an algolish-lisp -> lisp translator. [a, b, c] -> '(a b c) f(x) -> (f x) These two translations are strictly syntatic modifications to lisp. Some syntactic sugar: { f(x) g(x) } -> (progn (f x) (g x) ) With these three tweaks, we are probably 90% of the way to recruiting the common man (if syntax is really what puts them off).

Post by snprbob86 » Tue, Sep 01, 2009, 6:31 PM UTC

justinhj wrote: post #27

Compare the C# version of memoize to this one (from On Lisp). The C# one looks very long and ugly in comparison, so I hope it isn't the new Common Lisp. (defun memoize (fn) (let ((cache (make-hash-table :test #'equal))) #'(lambda (&rest args) (multiple-value-bind (val win) (gethash args cache) (if win val (setf (gethash args cache) (apply fn args)))))))

  (defun memoize (fn)
      (let ((cache (make-hash-table :test #'equal)))
      #'(lambda (&rest args)
          (multiple-value-bind (val win) (gethash args cache)
          (if win val
              (setf (gethash args cache) (apply fn args)))))))

  static Func Memoize(Func func)
  {
      var memoDict = new Dictionary();
      return arg =>
      {                
          TReturn result;
          if (!memoDict.TryGetValue(arg, out result))
          {
              result = func(arg);
              memoDict[arg] = result;
          }
          return result;
      };
  }