Hacker News Reader

Comment by eklavya | Hacker News Reader

I have always been curious about Lisps but the lack of static typing turns me off. Sure you can have a type system (typed racket) but it doesn't feel organic, also then why not use any other statically typed language (haskell, scala, ..). With all the hype (very likely well founded) surrounding Lisps, I feel like I am missing out.

View on HN

LISP is so powerful you can embed an ML in it while still getting its benefits for your use case. Incremental, per-function compilation, easy macros, and live updates were my favorite features. There's also been a ton of work running LISP's fast. Subsets even compiled to hardware in the past, including SHard (still around) and DDD.

Example from sklogic that embeds ML in LISP https://github.com/combinatorylogic/mbase

House, an experimental Haskell operating system is exactly that. If I had a lot of time on my hands I would love to revive that project. https://en.m.wikipedia.org/wiki/House_(operating_system)

(Shameless plug follows)

Take a look at my own Haskell operating system project Hos (https://github.com/tathougies/hos). Written in Haskell 98 using the JHC compiler (a bit outdated, but makes it easy to generate ANSI C from Haskell sources). Currently supports multi-tasking, interrupts, paging, garbage collection. Has the beginnings of a simple user-space ATA driver.

Patches welcome. E-mail me at travis@athougies.net if you want help setting up a development environment!

Would be nice if you could get Hos listed on https://wiki.haskell.org/Applications_and_libraries/Operatin... ...

The way I see it is that the "killer feature" of Lisps is the macro system and macros fit more naturally in an untyped setting. In a way, macros are kind of a "compile-time eval" and eval is one of those functions that is very hard to statically type.

You can have static typing with lisp if you want. There are many implementations of it actually. You can even detach the specifications of types from the code they refer to and specify the whole thing in lisp, no need to add any new syntax.

An example implementation from CHICKEN Scheme: http://wiki.call-cc.org/man/4/Types

http://clhs.lisp.se/Body/d_type.htm

http://3lproject.org/features

Some of that is vastly simpler to do with a dynamic language.

"You can boot into a REPL (Read Evaluate Print Loop) and can inspect or rewrite any part of the OS as you are using it."

As far as I know, nobody has figured out a way to have your cake and eat it too with static typing. Some of the simple things that lisps have been doing for decades are very difficult if not impossible to do with statically compiled languages.

There's nothing in a REPL incompatible with static typing. Haskell, Swift, and Hack by FP all have interpreters with type provers.

But it's quite a lot of work to get acceptable OS performance if your entire system is interpreted or has to be JIT compiled all the time. People who do that tend to coincidentally decide they're so hardcore they don't even need JPEG support, video, or web browsing…

Reply on news.ycombinator.com