newLISP has an approach to cons that I haven't seen before.
(cons 1 '(2)) => '(1 2)
(cons 1 2) => '(1 2)
If the second argument isn't a proper list, then cons behaves like the function list! https://www.newlisp.org/newlisp_manual.html#nil_and_true
(I have a soft spot for lisps that avoid improper lists.)
miniblog.
What happens if you do a survey on Mechanical Turk asking programmers what semantics they expect of their languages?
https://blog.brownplt.org/2017/07/06/crowd-pl-design.html has the answer! Direct link to PDF: https://cs.brown.edu/~sk/Publications/Papers/Published/tpk-crowdsource-lang-design/paper.pdf
Thread.
How Tumblr has developed over time, the importance of continued attention by the developers, and the community consequences of seemingly minor features: https://kotaku.com/in-2018-tumblr-is-a-joyless-black-hole-1827294865
Interesting talk on using PEGs to parse Clojure in Cursive to give good syntax error messages: https://www.youtube.com/watch?v=kt4haSH2xcs (the messages are largely machine-generated!)
Wow, there's an entire Clojure interpreter implemented in Go! https://github.com/candid82/joker
The primary use case seems to be linting, but it implements an impressive subset of the language.
"Static type systems can help working on large code bases. Immutable datatypes can help too."
I've seen this regularly asserted, and I generally agree, but how do we measure this? What other things help?
Ghostwheel: https://github.com/gnl/ghostwheel is a remarkable Clojure library.
It has compile-time effect detection (so it can verify you use foo! names) and even generative testing!
(The readme is a fun read too.)
Excellent Emacs thread -- choose FOSS tools that empower you! https://twitter.com/iLemming/status/1013846872274829314
Just added an exciting new code analysis feature to Helpful: view callees.
This analyses the source code, understands macros and special forms, and gives a handy link to every function used!
Neat elisp feature I learnt today: because closures are just lists, you can manually construct them and call them as functions:
(mapcar '(closure (t) (x) (1+ x)) '(1 2 3)) ;; => '(2 3 4)
Total Download Size: 3292.10 MiB
Total Installed Size: 13327.24 MiB
Net Upgrade Size: 995.34 MiB
Upgrading a (several months old) Arch Linux box, and you can definitely see that binaries tend to get bigger over time!
Neat debugging feature in Visual Studio for C++: you can use the debugger to only step through code you've written, saving you stepping through layers of the standard library! https://blogs.msdn.microsoft.com/vcblog/2018/06/29/announcing-jmc-stepping-in-visual-studio/
TIL OCaml has .mli files which are much like .h files in C: they define (and enforce) a public interface.
This seems to be less popular in newer languages: we tend to prefer public/private annotations in a single file. I'm not sure why this changed.
Fun article discussing the early development of autocorrect, blacklisting unwanted words and working out what to correct: https://www.wired.com/2014/07/history-of-autocorrect/
(Also contains this remarkable comment: "As someone who typed the entire first draft of his book on a phone...")
Adding dragon emoji as semicolons in node.js or the typescript compiler: https://blog.angularindepth.com/instead-of-semicolons-what-if-you-could-code-with-dragons-df5d0a4ef4ee
Nice post showing that working with programming language implementations need not be scary!
Syntactic Closures by Bawden amd Rees: https://www.dtic.mil/cgi-bin/GetTRDoc?Location=U2&doc=GetTRDoc.pdf&AD=ADA195921
This 1988 paper explores an alternative Scheme macro system before hygienic macros were standardised.
Visual augmentation of source code editors: A systematic review https://arxiv.org/abs/1804.02074
A useful paper categorising all the different ways IDEs can show additional metadata alongside the code.
For example, they show this cute plugin (Clepsydra) that shows worst case runtime.
GitHub has made a considerable effort to let users hide their email addresses: https://help.github.com/articles/about-commit-email-addresses/
I totally understand that users find this desirable, but it's awkward to implement on top of git. GH provide a hook to prevent mistakes: https://help.github.com/articles/blocking-command-line-pushes-that-expose-your-personal-email-address/
A fun quiz on eval() in JS, and corner cases of its behaviour: https://blog.brownplt.org/2012/10/21/js-eval.html
I've seen some of the gotchas before, but I still don't envy JS implementors.
How do you bootstrap a trusted computing base? I suspect you'd want a C compiler that was small enough that you could read the entire disassembly and verify that it worked as expected. That seems intractable.
Showing 321-340 of 657 posts