I've just released v0.3 of deadgrep: https://github.com/Wilfred/deadgrep
This new version allows you to collapse file results, and is much smarter about regexp, case and file type settings!
miniblog.
https://github.com/crdoconnor/strictyaml is a neat project deliberately subsetting YAML to remove the unsafe or complex features.
It also has types and even allows you to make round-trip edits with comments preserved!
Whilst JSON does not support comments, today I learnt that npm reserves the key "//" for you to add comments to the top level object in package.json: https://stackoverflow.com/a/14221781/509706
What type would you expect for a function that takes a string of the form "123" and returns an integer?
I've seen str -> int (with an exception message), str -> option<int> (no info on what was wrong) and str -> result<int,int_error> (exposes all the error types to callers).
Stylish was an awesome browser extension that enabled you to override CSS on websites. Turns out that it logs every single URL you visit! https://robertheaton.com/2018/07/02/stylish-browser-extension-steals-your-internet-history/
For Google searches, it also records the search term and search results. Yikes.
Docker Hub has this lovely feature where *they* provide builds of Dockerfiles. For example: https://hub.docker.com/r/etsy/hound/
This is great for making software more trustworthy. I can review the code on GitHub and be confident that I'm running the same code. More platforms should do this.
Inspired the helpful Using Emacs series: https://cestlaz.github.io/posts/using-emacs-6-swiper/ I've been experimenting with C-s bound to swiper rather than isearch.
I'm a big fan of Anzu: https://github.com/syohex/emacs-anzu for enhancing isearch, but I'm finding that I use swiper more with this new keybinding.
https://www.msreverseengineering.com/blog/2018/2/26/concrete-and-abstract-interpretation-explained-through-chess uses chess to describe concrete and abstract interpretation: considering state spaces, approximating, and dealing with intractably large sets of possibilities!
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.)
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/
Showing 2,641-2,660 of 7,508 posts