Ask HN: Weekend Social: Top two programming languages and what they can borrow?

Answering my own questions:

1. Common Lisp, Python.

2. This is not exactly a language feature but more of an attribute of the ecosystems, but I wish Common Lisp had a more comprehensive 'batteries included' standard library. It does have a pretty good standard library [1] for its time, but in the modern day, it fades in comparison to that of mainstream languages like Python or Go. Yes, the availability of Quicklisp compensates for the relatively smaller standard library, but it does not fully replace the value of having a large and cohesive standard library.

For Python, I wish (and this might be controversial) that it used s-expressions instead of whitespace-based delimiter for blocks. I find cutting, pasting, moving around, and in general, manipulating whole s-expressions as individual units very convenient with appropriate editor support (e.g. Paredit). I know there are languages like Racket, Clojure, etc. which fulfil the requirement of extensive batteries included library + s-expressions, but they are much less popular than Python. In my ideal world, one of the top three popular languages would be a Lisp or Lisp-like language with an extensive standard library comparable to Python's.

3. Common Lisp for personal projects. Python for collaborative projects.

[1] https://www.lispworks.com/documentation/HyperSpec/Front/X_Sy...

1. PHP and C. 2. I wish C had PHP's native "associative array as junk drawer" data structure. Conversely, I wish PHP had more support for a "long lifetime" task that wasn't expected to vanish at the end of a page load. 3. Am I trying to target the web? Then PHP.

1. Typescript, Ruby

2. Elegant typings, native to language syntax. Syntax flexibility.

3. Usually this choice is made for me or before me. And unfortunately it is often neither.

1. J, Lisp.

2. There are no such features. But I want all languages to have J in the same manner as they have regexp. I mean a tool like NumPy but with sweeter syntax and more possibilities.

3. J is for number munching, Lisp is for everything else.

1. JS, Python

2. [i know u said 1, but there's so many] JS->Py: Looser type handling, nicer syntax for dicts. Py->JS: Less punctuation, comprehensions

3. I created a hybrid called Pith (https://news.ycombinator.com/item?id=46637033). JS with some nice Python features.

Appendix (Nov 2021)

A version of Python (call it "Pith" [0]) that fixes the annoying things, eg:

no colons

  if bool:
  # should be
  if bool
  
  for thing in things:
  # should be
  for thing in things

  a_dict['prop']
  # should be
  a_dict.prop

  a_dict = {'name': 'value'}
  # should be
  a_dict = {name: 'value'} # like in js
  # even
  a_dict = {content-type: 'json'} # ooh, ahh !

  if __blah_blah_blah__ == '__main__' # dunder-struck ?
      main()
  # should be
  # nothing -- it just calls main() if it's there

  # instead of
  a_dict.get('prop')
  # it should be like JS that returns undefined or None or something nullish or falsey
  a_dict.prop

  v = a if this else b # barf
  # should be
  v = this ? a : b
  # or (to steal from VB)
  v = iif(this, a, b)
  
  # maybe fix list/dict-compros, too, while i'm at it

  elif x:
  # should be
  else if x # like any decent language

  f'{huh}'
  # should be
  `{huh}` # like JS

  len(a_string)
  # sb
  a_string.length

  # Regular Python              | # Pith uses less punctuation
                                |
  def main():                   | def main
      a_dict = {                |     a_dict =
          'name': 'value'       |         name: 'value' # maybe use = instead of :
      }                         |
      if True:                  |     if true
          print(a_dict['name']) |         print a_dict.name
      elif 1 > 2:               |     else if 1 > 2
          print('ooh')          |         print 'ooh'
                                |  
  main()                        | # no need to call main()

maybe add a do/while loop, multi-line comments ###, JS-style regex /reg/ instead of r"regex" blah blah blah

etc, etc, etc

it could be a preprocessor (like the C Preprocessor) that takes Pith and converts it to Python

for JS, take out parens, curly braces, semicolons, etc (make it "look" more like Pith)

i know these changes are fraught with peril, but i don't care (do i?). there's no reason (is there?) that i should be stuck with Guido's or Brendan's design choices [1] (i can make my own :) )

i even had an idea that you could write a program in Pith and it could output either Python or JS (or anything else). that might need a little more thought

[0] "Pith" is prolly already in use by something else, just humour me

[1] that's the bigger idea here -- take a language you like, fix all the things you don't like about it. maybe lisp with fewer parens

1. Python, C++.

2. Significant indents, Compiles.

3. Ease of coding, Performance.