https://codespeak.dev

And https://news.ycombinator.com/item?id=45613253

Etc

Or JS to call Claude's APIs (from the browser) to see/search/download old conversations. there's more to it than this, but it's a start:

    const search = 'fetch =';
    
    console.clear();
    const org = intercomSettings.lastActiveOrgUuid;
    for (var o = 0; ; o += 30) {
        const r = await fetch(`/api/organizations/${org}/chat_conversations_v2?limit=30&offset=${o}&consistency=eventual`);
        const ccs = await r.json();
        ccs.data.forEach(async cc => {
            const r = await fetch(`/api/organizations/${org}/chat_conversations/${cc.uuid}?tree=True&rendering_mode=messages&render_all_tools=true&consistency=strong`);
            const c = await r.json();
            for (const cm of c.chat_messages) {
                for (const co of cm.content) {
                    if (co.text?.includes(search)) {
                        console.log('https://claude.ai/chat/' + c.uuid, c.name);
                        console.log(co.text);
                    }
                }
            }
        });
        if (!ccs.has_more) break;
    }

> The name invoked the number five, but was completely trademarkable, unlike the number 586.

I see what you did there. See also https://en.wikipedia.org/wiki/Muphry%27s_law

https://en.wikipedia.org/wiki/The_Century_of_the_Self

It's on YT...

https://youtu.be/oiTJ7Pz_59A

https://www.rogerebert.com/reviews/the-shawshank-redemption-...

https://en.wikipedia.org/wiki/Content_Authenticity_Initiativ...

> The combined company is expected to price shares in an IPO that would value it at $1.25 trillion

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