HackerLangs
TopNewTrendsCommentsPastAskShowJobs

Jtsummers

28,583 karmajoined há 17 anos
[ my public key: https://keybase.io/jtsummers; my proof: https://keybase.io/jtsummers/sigs/2v_NBwmgy9lrspxf8k7DN4UwIi-73h22Wxr_7kF01RM ]

Submissions

What If It's Not the Phones?

theatlantic.com
8 points·by Jtsummers·ontem·0 comments

Iran, Not Trump, Is in Control of This War

theatlantic.com
38 points·by Jtsummers·anteontem·12 comments

The Military and the Republic

foreignaffairs.com
7 points·by Jtsummers·há 7 dias·0 comments

Wisk, Boeing's air taxi firm, rushed software testing, ex-employee claims

seattletimes.com
7 points·by Jtsummers·há 9 dias·0 comments

A bold satellite rescue mission came together in record time, but will it work?

arstechnica.com
7 points·by Jtsummers·há 22 dias·0 comments

America Is Headed Toward the Infinite Workweek

theatlantic.com
46 points·by Jtsummers·há 22 dias·22 comments

The Biggest Tell That Something Was Written by AI

theatlantic.com
5 points·by Jtsummers·mês passado·0 comments

Backyard Star Wars (2010)

spectrum.ieee.org
9 points·by Jtsummers·mês passado·1 comments

America Is Missing Out on the Ultimate Mosquito Weapon

theatlantic.com
2 points·by Jtsummers·mês passado·0 comments

I Am Begging You to Read Terry Pratchett

theatlantic.com
4 points·by Jtsummers·há 2 meses·3 comments

The Single Dumbest Conspiracy Theory of 2026

theatlantic.com
2 points·by Jtsummers·há 3 meses·0 comments

The Story of the Cartel Olympics

theatlantic.com
6 points·by Jtsummers·há 4 meses·3 comments

Everyone but Trump Understands What He's Done

theatlantic.com
19 points·by Jtsummers·há 4 meses·3 comments

The Obvious Is Taking Its Revenge on Trump

theatlantic.com
10 points·by Jtsummers·há 4 meses·1 comments

Communicating Sequential Processes (2022) [pdf]

web.archive.org
5 points·by Jtsummers·há 4 meses·0 comments

Warren's Abstract Machine: A Tutorial Reconstruction (1999)

web.archive.org
4 points·by Jtsummers·há 4 meses·0 comments

U.S. Capabilities Are Showing Signs of Rot

theatlantic.com
16 points·by Jtsummers·há 4 meses·1 comments

The Glaring Oversight in the U.S. War Plan

theatlantic.com
11 points·by Jtsummers·há 4 meses·4 comments

Deceit, Desire, and the Literature Professor: Why Girardians Exist (2012)

shc.stanford.edu
3 points·by Jtsummers·há 4 meses·2 comments

Trump Has a Bridge He Wants to Sell You

theatlantic.com
5 points·by Jtsummers·há 5 meses·1 comments

comments

Jtsummers
·há 11 horas·discuss
[dead]
Jtsummers
·há 13 horas·discuss
I wrote that quickly and should have edited it for clarity. What I meant was a new collection type that could be treated as a sequence.

https://www.lispworks.com/documentation/HyperSpec/Body/17_a....

None of the functions operating on sequences are generic, so you cannot create your own type and do a `defmethod` and have them automatically adapt to it. And unlike `print-object` which gets used by format and print and others, there's also no "protocol" (or whatever term you like) generic function you can implement which will make your collection acceptable as a sequence.

You could build something like this, and maybe shadow the standard functions so that it's not a new set of functions from a user perspective, but it's a notable absence in a language with a rich OO system through CLOS. It makes sense that it wasn't in the original spec, but I still think it would have been something that would have been added if the development of CL (as a standard) had continued.
Jtsummers
·há 13 horas·discuss
> maintaining a fork is roughly the same as maintaining a feature flag.

He didn't say that in the interview. Or, he didn't make nearly as broad a claim as you have made. He said:

>> If you want me to maintain a flag to remove it, I can ask you to maintain a fork removing it. Telling people to “fork it” often upsets them.

The context of his statement was people wanting a feature (search as one example) removed (or removable, via feature flag). In that case, the fork is about as hard to maintain as the feature flag, assuming the software is reasonably well organized.

But in general, your claim is not true, and it's not what he wrote.

> You should address the point Mitchell made

No, I have no obligation to respond to something that he didn't say.
Jtsummers
·ontem·discuss
> I was astounded when I saw that you run programs using the live REPL.

That's one way, you stopped too early in your investigation though.

You can produce binaries, though the precise mechanism will vary by your implementation. And there's no reason to use the REPL for it. You can create an executable file with something like this:

  (defun main () ...) ; do whatever you need in here for program launch

  (sb-ext:save-lisp-and-die "my-program" :executable t :toplevel #'main)
And then `sbcl --load program.lisp` (or whatever you name it) and it'll produce a binary for you. Other implementations will have other methods of achieving the same thing.

Or, if you don't need a binary, you can have something like this:

  (defun main () ...)

  (main)
And then run `sbcl --load program.lisp`. That will compile and execute it without ever invoking the REPL.

(NB: Using a function named main isn't strictly necessary, I named it that for the example. Name it whatever you want.)
Jtsummers
·ontem·discuss
> I’ve always believed there should be way more forks, both personal and maintained ones.

There aren't more forks because once you fork something you take on the burden of synchronization, or you forfeit the benefit of future upstream work. To focus on Ghostty, Mitchell has taken on the effort of maintaining cross-platform support. If I want one specific feature (or even a bunch of features) and create a custom fork, but then GTK changes, now I have to support that change myself (assuming it is relevant to me or my community of users), or figure out a way to integrate Mitchell's changes into my fork, or I risk losing my customizations by having to rollback to baseline if the differences between my fork and baseline are too great.

If the system is well-engineered (the work on libghostty helps here) then you can keep that common core without forking, and fork just things on the periphery of the system. But well-engineered is not common.
Jtsummers
·ontem·discuss
And it remains in a state of almost getting to the point of generic collections (like C++, Clojure, many others) using the standard functions, but not quite getting there. There are functions (not generic functions) which operate on sequences, but no standard way to extend what types are considered sequences (as one example). It makes sense that the 1995 version of the spec would be incremental, but without a further development (or consensus amongst the implementations if no official standard) it's difficult to continue moving forward to make better use of the language's generic function capabilities.

That's where Clojure, Julia, and many others have advanced beyond what CL (by the standard) provides. The language needed at least one or two more standards to drive those features forward, but never got them.
Jtsummers
·ontem·discuss
> There is real, palpable, practical, functional difference between working a Lisp REPL and a REPL in a non-homoiconic languages

Smalltalk is not homoiconic, and it's REPL experience is equivalent (I'd argue somewhat better, but that's mostly a tooling thing, see the commercial CL implementations as examples of improvements over SBCL + Emacs + Slime). Homoiconicity is not the trait that makes the CL REPL experience better than others, it's that it includes a very good debugger, the compiler, hot code reloading, the ability to redefine classes and update current instances, and so on.

That's the tooling, not the language, that provides the experience. Nothing about being non-homoiconic prevents other languages from having a comparable (or even better) experience.
Jtsummers
·ontem·discuss
Or as my dad, a CSAR pilot, used to say, "I'd be happy to be out of a job."
Jtsummers
·ontem·discuss
If you haven't read it, I'd suggest taking a look at Paul Graham's book On Lisp [0]. He says better, and with more examples than I'd provide in a comment block, what I'd write on the subject. Jump to chapter 8 for his discussion on the topic, referring back to chapter 7 if you find the macro definitions difficult to read.

[0] https://www.paulgraham.com/onlisptext.html
Jtsummers
·anteontem·discuss
> As you can imagine that incentivized only fixing important bugs, and even those we had to consider whether it was worth it or not.

Or you're batching your releases into larger builds because you know it'll take 6 weeks to test regardless. This increases the duration of each development iteration because you have 100 things you want to do and you could do that in, say, 4x13 week efforts, but with the added 6 weeks between iterations (and possibly more after it leaves your shop) that takes a one year effort and turns it into about 1.5. So the program office decides you should do one big release each year, which also ups the risk because a lot of testing that would catch bugs isn't done until the end in that big 6-week test effort. Oops, now your 1 year + 6 week effort just got turned into 1 year + 6 week + (unknown rework time) + 6 weeks. Probably 2 years.
Jtsummers
·anteontem·discuss
It's a British English vs American English thing.

https://en.wikipedia.org/wiki/American_and_British_English_g...
Jtsummers
·anteontem·discuss
> Not on Hacker News though.

You're not the boss of Hacker News, don't try and tell people what they can and cannot do. You pose a question about arrogance and then display a grand example of it here.
Jtsummers
·anteontem·discuss
> Do people not understand that the US can level Iran tomorrow? Really?

Short of using nuclear weapons, no, the US cannot "level Iran tomorrow". And the threat of nuclear weapons has become much weaker over the decades, it would be political, and potentially national, suicide to use them at this point.
Jtsummers
·anteontem·discuss
https://archive.is/q6SQa
Jtsummers
·anteontem·discuss
> Either I allow myself to be interrupted or I come back to missed messages and calls.

Given those two options, the reasonable one is the latter. Just miss a few messages and calls, control your own time.
Jtsummers
·anteontem·discuss
> Also who describes "A Clockwork Orange" as old english?

Presumably the confused student who sought out a translation.
Jtsummers
·anteontem·discuss
> he continues to conflate books with reading - and not just that but reading specifically physical books (referring to his stats around book ownership). [emphasis added]

She and her, the author is a woman.
Jtsummers
·anteontem·discuss
> I can only imagine them being awkward and non-idiomatic in JS

You don't have to imagine, you can look at the code used in the JS version and it goes through some fun contortions to get around the fact that JS is not expression oriented (like Scheme). This is from page 35 (PDF: https://sicp.sourceacademy.org/sicpjs.pdf):

  function count_change(amount) {
    return cc(amount, 5);
  }
  function cc(amount, kinds_of_coins) {
    return amount === 0
           ? 1
           : amount < 0 || kinds_of_coins === 0
           ? 0
           : cc(amount, kinds_of_coins - 1)
             +
             cc(amount - first_denomination(kinds_of_coins),
                kinds_of_coins);
  }
  function first_denomination(kinds_of_coins) {
    return kinds_of_coins === 1 ? 1
           : kinds_of_coins === 2 ? 5
           : kinds_of_coins === 3 ? 10
           : kinds_of_coins === 4 ? 25
           : kinds_of_coins === 5 ? 50
           : 0;
}

That certainly works, but it's awkward. Here's the Scheme code from the 2nd edition of SICP:

  (define (count-change amount) (cc amount 5))
  (define (cc amount kinds-of-coins)
    (cond ((= amount 0) 1)
          ((or (< amount 0) (= kinds-of-coins 0)) 0)
          (else (+ (cc amount
                       (- kinds-of-coins 1))
                   (cc (- amount
                          (first-denomination
                           kinds-of-coins))
                       kinds-of-coins)))))
  (define (first-denomination kinds-of-coins)
    (cond ((= kinds-of-coins 1) 1)
          ((= kinds-of-coins 2) 5)
          ((= kinds-of-coins 3) 10)
          ((= kinds-of-coins 4) 25)
          ((= kinds-of-coins 5) 50)))
The JS code has to use the ternary ?: to get around the fact that it does not have a good equivalent to `cond`. You can see that they've gone through a literal translation of Scheme to JS that results in very unidiomatic JS code.
Jtsummers
·há 3 dias·discuss
> Why not just use Scheme directly, what's the benefit of porting to Hoot?

Scheme is not a thing you use directly, you have to select an implementation. Hoot is one such implementation (targeting execution on WASM).
Jtsummers
·há 3 dias·discuss
> What exactly makes the GAO not "part of the executive branch" ?

https://www.law.cornell.edu/uscode/text/31/702

>> (a)The Government Accountability Office is an instrumentality of the United States Government independent of the executive departments.

The law establishing it also establishes it as independent.