I Still ‘Lisp’ (and You Should Too)

This page summarizes the projects mentioned and recommended in the original post on news.ycombinator.com

Our great sponsors
  • InfluxDB - Access the most powerful time series database as a service
  • SonarLint - Clean code begins in your IDE with SonarLint
  • SaaSHub - Software Alternatives and Reviews
  • FrameworkBenchmarks

    Source for the TechEmpower Framework Benchmarks project

    Clojure is about 2.75x slower than Java, while Python is 5.59x slower.

    The fastest composite Python "framework" is uvicorn at 17.9% of the fastest run in Java (officefloor). The fastest Clojure run is Aleph at 36.4%.


    About SBCL, I get conflicting results. The Benchmarks Game shows it roughly as fast as Java for many problems:


    But here it's significantly worse than the Clojure runs, likely due to the slow DB bindings (the other test types show it roughly in line with Clojure; though it uses a "Stripped"/unrealistic HTTP implementation):


    I am not sure which Lisp implementation is used; is it SBCL? Does this file speak to you?


  • coalton

    Coalton is an efficient, statically typed functional programming language that supercharges Common Lisp.

    I vehemently disagree with dynamically typed being a winning point of Lisp. SBCL's strong support for type checking is the main reason I was drawn from Scheme to CL, and Coalton (https://github.com/coalton-lang/coalton) is one of the most interesting Lisp projects I have encountered.

    Type checking can remove an entire class of bugs from even being a consideration. Yes, it could be argued that type mismatches are a trivial class of bug, and yes, proper testing should catch any issues... but catching problems before you go to testing can save you precious seconds, especially when coding in the typical interactive style of Lisp. Lisp lets you code at amazingly high velocity, good support for type checking helps increase that velocity even further.

  • InfluxDB

    Access the most powerful time series database as a service. Ingest, store, & analyze all types of time series data in a fully-managed, purpose-built database. Keep data forever with low-cost storage and superior data compression.

  • symreg

    A Symbolic Regression engine

    Well, I wrote a genetic programming library, and it was fun to parse a Lisp-like representation from Python. You still have recursion and everything (albeit no tail call optimization).

    Here, `_from_source` goes from a plain array of tokens to a nested one (tree), depending on their arity:


    Lisp is almost valid Python. The exception is the single-element tuple which needs a comma: (x,)

    But I still preferred to use Python as a programming language, and Lisp as a sort of AST. It's just easier. I am curious what roadblocks you faced in your ASCII delimited parsing.

    Do you by any chance still have the two parsers? I'd love to see them. If you are worried about your anonymity, you can find my website on my HN profile, and my e-mail on my website. I promise not to disclose your identity publicly.

NOTE: The number of mentions on this list indicates mentions on common posts plus user suggested alternatives. Hence, a higher number means a more popular project.

Suggest a related project

Related posts