6 ms·
You seem to be complaining that... Lisp doesn't exist? You seem to be saying his complaints are of the from "A hypothetical language I have in my head can do th
by jerf 17y ago
You seem to be complaining that... Lisp doesn't exist? You seem to be saying his complaints are of the from "A hypothetical language I have in my head can do that better", but the complaint is of the form "This existing language does that all and better."
Given that the only other "problem" in the post is a Hello World post, surely you aren't complaining that the author failed to include a "Hello World" lisp program? Well, here you go:
(print "Hello World")
I do not understand what you're saying at all.
(Also, I'm not a lisper. In fact I'm increasingly of the opinion that it represents a wrong direction for the future of programming languages. So this is not a "pro-Lisp bias" thing.)
- miloshh 17y agoWell, Lisp sure does exist, and has been used to solve real world problems. But those were predominatly in applications where performance, parallelism, graphics, large matrix computations and GUIs do not matter. If you want to pick on the imperative languages (i.e. Pascal/Fortran/C/C++), you better show you can do what they can do.
- mahmud 17y agoUnsubstantiated claims. Common Lisp has been embedded inside Quake II: http://ecls.sourceforge.net/ecl-in-quake2.jpg http://ecls.sourceforge.net/ecl-in-quake2.jpg That takes care of the graphics, networking, matrix manipulation and low-latency. What other FUD do you need answered?
- miloshh 17y agoNah. Using Lisp to script an engine written in C++ is not the same as writing the engine itself in Lisp. I'm not saying this is not possible, it's just that nobody tries. You might be able to do a serious graphics or high-performance computing project in Lisp. You will be the first one, and I'll be very interested in how it goes.
- lispm 17y agoMany have been done. ICAD has been written in Lisp and many turbines of several commercial aircrafts have been designed with it. CDRS was the conceptual design and rendering system, written by Evans & Sutherland in Lisp. Many cars from Ford and Jaguar have been designed with it. It was then taken over by PTC and sold as Pro/Engineer Designer. Mirai is a 3d graphics tool used for example to create the animations of Gollums's face in Lord of the Rings. Earlier versions of this software have been used for animation films and many computer games, for example by Nintendo to design the 3d worlds. There were other uses of this software, for example the Orca in 'Free Willy' was animated with it. Here is a screenshot of Mirai: http://lispm.dyndns.org/lisp/pics/Mirai-P5-Paint-Front.jpg http://lispm.dyndns.org/lisp/pics/Mirai-P5-Paint-Front.jpg Let us know when there is a similar Haskell app that supports 2d+3d painting, 3d modelling, 3d animation, 3d rendering, 3d motion editing, etc. in a nice application for, say, SGIs or Windows machines - then show how to script it in Haskell at runtime.
- miloshh 17y agoOh, Haskell is also not used very often for those things. It's just my (outsider) perception that Lisp programmers frequently pick on C/C++ as inferior. Haskell programmers instead ask "what can we do to make Haskell performance closer to C/C++?" However, I am doing graphics for a living, and much of it in C++. I am sincerely interested if I can use another language to give me a higher degree of productivity and not sacrifice too much performance. Common Lisp might be able to pull this off, but it certainly is not often used in this way. I think you'd agree it's more common for a Lisp person to ask "why do people still use these inferior languages?" rather than "how can we match the performance/scalability/parallelism of these other languages?".
- lispm 17y agoC/C++ are inferior. C and C++ are very bad as a dynamic and interactive languages. C makes it hard to write secure programs and C++ is just horrible in many ways. But C/C++ are superior as static low-level languages compared to Lisp. The Haskell programmers should really ask themselves how to get closer to C/C++ in speed - especially since the Haskell language implementations (GHC!) are mostly static and code is usually statically compiled - just like C and C++. If Haskell compilers generate slower code or user code is slow, Haskell users have little excuse, only poorer tools and/or poorer code. Lisp programmers do have an excuse, since the tools are optimized for safe execution of untyped dynamic (changeable at runtime) code. That's a completely different angle of programming. From there the Lisp compilers try to recover some speed by selectively removing dynamics and safety - where possible or needed. Lisp programmers ask themselves how to improve the compilers, but since both the application domains and the architectures tend to be different, things are hard to compare. C/C++ wins in the static performance contest. Lisp wins in the runtime flexibility contest. But those are really very different domains. You think that Common Lisp programmers think that C is inferior. The reality is that these are completely different languages developed for different tasks with very different implementation and design decisions. If you are a Lisp programmer, you can write graphics intensive applications in Lisp - you can also get near to C performance - but it's hard and it often is not full C performance (unless you are using specialized compilers). But still you would be very lonely (unless the company around you uses Lisp), since much of the industry uses C/C++ for graphics (from Low-level drivers to Maya). Still many Lisp programmers, despite knowing that Lisp and C are different, try to use Lisp either alone or together with C in performance oriented domains: sound processing and image processing were and still are such domains.
- mmphosis 17y agoI tried: (print "Hello World") The result I expected was: Hello World The result I got was: "Hello World" In the language we are using, the "Hello World" program is simply: Hello World but, this is my anti-Lisp bias thing.
- mahmud 17y agoLisp "printing" is used for two different purposes: 1) to display results for a human reader/viewer. and 2) to serialize Lisp forms for later READing. Instead of print, try princ. [1]> (princ "hello world") hello world "hello world" The first unquoted string is the rendered display of the PRINT function, a side-effect. The second quoted string is the result, print returns the string it printed as a result. Try nesting them and see what happens: (princ (princ "hello world")) You admit to having an anti-lisp bias without knowing anything about lisp. This whole "I hate it because I don't know it" thing is silly and unbecoming of good programmers.
- jstraszheim 17y agoJust curious, what do you think is the right direction?
- kunley 17y agoIf Go people succeeded with taking over some C area, that would be the direction right enough, don't you think? Simply because Go seems a bit better than C. I'd love to see some modern SML or Haskell taking over the area of code compiled to binary, plus a constant growth of dynamic languages as well, because they are also cool. But that big revolution may not happen.
- stefano 17y agoProbably Microsoft's F# is the modern SML with more chances to become mainstream and start that big revolution.
- pavelludiq 17y agoI'm curious, i rarely see any REAL[1] criticism of lisp, just the old "ughh, my eyes, all those parenthesis, aaa" type of nonsense. Why do you think its a wrong direction? [1] Im not talking about implementations, obviously, Common lisp, scheme and clojure have their problems, im talking about the general idea of lisp.
- ekiru 17y agoI also feel that Lisp is a wrong direction. Its main problem is the lack of static typing. It is understandable that a language which has existed for so long with relatively little change would lack a static type system, but with as much progress as has been made in research on type systems since then, there is no good reason for a modern language to lack a powerful type system.
- mike_organon 17y agoThere is value in static checking for some things, but it is also limiting. It requires that code be written such that those things are declarative, can be understood without running the program. There is also value in having those things to be programmable, dynamic. This is a "good reason" even if you prefer the alternative. In Clojure, the lack of static type checking was not done out of laziness. > there is no good reason for a modern language to lack a powerful type system. Lisps can and do have powerful type systems - you're confusing dynamic with none at all.
- ekiru 17y ago> There is value in static checking for some things, but it is also limiting. Other than type-safe heterogenous lists(which is only true if you hold static type systems to a much higher standard of type-safety than dynamic type systems), what sorts of things do a type system with type classes, algebraic data types, and higher order functions prevent doing? > Lisps can and do have powerful type systems - you're confusing dynamic with none at all. Common Lisp has a powerful object system and dispatch scheme, but it isn't as powerful as Haskell's type system. Type classes provide compile-time multi-methods which can be every bit as dynamic as CLOS's when needed, but which are statically checked as much as is possible. In addition, type classes make it possible to dispatch not just on argument type but also on return type. How do you write a Common Lisp function which polymorphicly converts an integer to whatever type you need? This is admittedly a bit of a weak example, but polymorphic conversions like this can probably be useful(for example, you could use it to implement a somewhat inefficient heterogenous list). In Haskell(I'm not very familiar with Haskell, but my testing indicates that this would work): class FromInt t where fromInt :: Integer -> t Haskell also has parameterized types, which aren't as needed in dynamic type systems, but that relative lack of need is only because a dynamic type systems considers a program that calls a method which doesn't work on an object's type at runtime to be type-safe. In a statically typed language with type classes and sufficiently powerful syntactic macros, it would be possible to conveniently defer to dynamic type checking in way that would type-check statically. The macros are only necessary for the convenience part. Otherwise, you'd have to create a lot of type classes for every type you wanted to use dynamically. With macros, you could just include the creation of the appropriate classes in the form that defines a new type. In fact, it could be built into the language making even macros unnecessary.