kagevf

You can think of code reviews as an opportunity for knowledge transfer.

... and it has the added benefit that the person it's directed to will actually read your feedback since it would be directly related to work they're doing.

I agree, which is better - for or map - depends on context. map typically is functional and allocates memory, for does not. But for is more likely to have side-effects. Which trade-offs matter depends on the larger context of the surrounding code.

Public transit isn’t free on the strip except during New Years Eve and possibly some other special occasions.

The monorail from Mandalay Bay to Bellagio is free, but it isn’t public transit.

The code looks pretty readable, if you're familiar with CL and the Windows API - nice!

You might want to consider not :USEing your dependencies, and use the package name prefix when you invoke exported symbols instead, though, like you did with re.

Speaking of which, is re this: https://github.com/massung/re?

I wonder if MS long term plans to have both GH and Azure DevOps (the source code management part) ...

In Common Lisp, '(' is a macro character that triggers a reader macro to read/parse the list it surrounds with a pair ')'.

More info: https://gist.github.com/chaitanyagupta/9324402

This one demonstrates how what's read in can be parsed - sort of a "Lisp in Lisp" version of eval: https://stevelosh.com/blog/2016/06/symbolic-computation/#s11...

> think of tests more like assertions or checksums.

That's a good way to summarize how tests can catch regressions. And, I think I'm stealing that!

Everything is still an expression in CL, but you have to account for different namespaces.

Also, the above can be further shortened to:

  (funcall (if (< 1 0) #'+ #'*) 42 100)

GitHub has had diff for images for years, and there's a web automation testing (think: Selenium) vendor called Aplitools that takes snapshots of web pages and diffs those too.

I don't know of any non-proprietary tools, but at least the tech is out there.

I use papercut too.

I expect that with AI, we'll be less able to rely on the heuristic of bad grammar to easily detect phishing. That one flaw gave the phishers away so often, and made it so obvious ...

> Would you write your own JSON parser, is it that easy in LISP?

Well, there are a lot of them. Here's a link to a guide someone wrote to compare a bunch of them: https://sabracrolleton.github.io/json-review.html

> Looking at Quicklisp's package manager, it looks like the packages are updated on at least a year's interval?

I think it used to be closer to monthly. It has slowed down a lot recently. I've seen talk on IRC about ideas on how to improve the bus factor for that situation.

Also, there are some alternatives to Quicklisp that exist, such as ocicl, which seems to be gaining in mindshare. I haven't used it personally (yet), but so far I've only seen positive feedback from people that have tried it.

Too bad there isn't one for quicklisp...

This blog has some useful Linqpad tips: https://www.danclarke.com/linqpad-tips-and-tricks

In particular, keyboard shortcuts to toggle visibility on the different sub-windows, and using the Util class to prompt for a password I find to be useful.

It looks like with this, you get macros and a repl, though.

xappings show up in an example in CLTL2's readtable chapter: https://www.cs.cmu.edu/Groups/AI/html/cltl/clm/node192.html#...

I’ve been really liking emacs across the 3 major OSs - pretty much works the same everywhere. The joke is that emacs itself is an OS, but it makes a decent shell. Setting save-desktop to 1 and it survives Windows reboots. Change some keybindings, get meta and control in the same location even when using MacOS.

I think you made a worthwhile point.

I recall seeing either on IRC or reddit someone asking about why their code wasn't working as expected, and it lead back to needing to understand that the string literal in their code was getting updated - so likely similar to the UB in C that you mentioned. Until seeing that post, I wasn't really aware of that potential issue with literals, so I think it's good to point these things out. Recently, I saw it was mentioned in "Successful Lisp"; it might be mentioned in other books I've read, but maybe I just didn't pick up on it.

Yes, updating literals is asking for trouble, or at least can lead to some confusion.

If I replace ‘(a b c) in my example with (list ‘a ‘b ‘c) I got the same results.

Correct.

  (let* ((x '(a b c))
         (y (cdr x))
         (z (copy-list (cdr x))))
    (format t "y=~A, z=~A~%" y z)
    (setf (nth 1 x) 'w)
    (format t "y=~A, z=~A~%" y z))

=>

y=(B C), z=(B C)

y=(W C), z=(B C)

Japanese e would only ever be [ɛ]. The constructs to produce an [e] sound would be transliterated as "ei" (the quoted are just letters, not meant to be IPA).

So, while I disagree that they sound "exactly the same", I do agree that in most cases the differences between [e] and [ɛ] wouldn't be enough to cause confusion between speakers of either language.

I don't know IPA, but Japanese e and Spanish e are also different. Spanish e is like English A in "ace", Japanese e is closer to English "eh".

It's written in arc, a lisp language Paul Graham created. I think you're right about vi, though.

Same here; getting a handle on string interpolation was particularly challenging.

This is a dumb one, but I told it to refer to PowerShell as "StupidShell" and told it not to write it as "StupidShell (Powershell)" but just as "StupidShell". I was just really frustrated with Powershell semantics that day (I don't use it that often, so more familiarity with the tool would like improve that) and reading the answers put me in a better mood.

Someone did: https://portacle.github.io/

Also, lem (already mentioned elsewhere in this thread)

I wish ielm had presentations like SLIME ...

Right, but they hedge their way out of it with "This makes the left and right parenthesis unchangable from within the language (not conceptually, but under some implementations it is not possible)" so it's not even clear which "Lisp" they're talking about. If I'm not mistaken, ( itself is a reader macro in CL.

When I saw the headline, my first thought was "what about Lisp macros?" so at least for me it starts out by addressing exactly that question ...