I've seen test runners that report the number of assertions checked, not just the number of tests. Is this useful?
I understand if you have non-fatal assertions (like EXPECT_TRUE in googletest), but I think this is a rare feature in testing libraries.
miniblog.
It's unfortunate that '# foo' can mean "here's a command you need to run as root" or can mean "here's a comment about the next command". It's a recipe for confusion.
When a language has some central design principles, you can spot projects that work really well because they go well with that design.
There's an eslint plugin for extracting JS from HTML, so you can catch issues even when using inline JS! https://github.com/BenoitZugmeyer/eslint-plugin-html
Great talk by Bozhidar on the evolution of Clojure tooling in Emacs: https://youtu.be/4X-1fJm25Ww
(covers an impressive range of features, explores the tooling landscape and has some entertaining Emacs metaphors!)
Now available on MELPA! https://twitter.com/_wilfredh/status/965745451055099904
Great, readable paper by Romain Robbes and Michele Lanza: Improving Code Completion with Program History
It's a quantitative analysis of code completion tools, covering both static and dynamically typed languages!
Lots of IDEs provide a way of viewing the structure of a project: the directory structure, the package organisation, or the methods and fields of classes.
Scaling these visualisations remains a hard problem. Large projects are hard to navigate in any tool.
A big appeal of Emacs, the infinitely customisable editor, is that you can mold it to perfectly fix your workflow.
I have a sneaking suspicion that the Ikea Effect https://en.m.wikipedia.org/wiki/IKEA_effect increases the appeal too though.
Interesting, candid article exploring what happens when you try to build a high performance conservative GC: https://www.excelsiorjet.com/blog/articles/conservative-gc-is-it-really-that-bad/
I really like frameworks that provide a skeleton project generator. It means the initial impression shows a working project, and helps promote best practices!
Exercism has a really good summary of what great code reviews look like: https://tinyletter.com/exercism/letters/exercism-behind-the-scenes-unhelpful-insulting-and-rude-feedback-antipatterns
Cyclic graphs are hard in Rust. A lovely post demonstrating how to use arenas in Rust to build mutable graphs whilst managing lifetimes correctly: https://exyr.org/2018/rust-arenas-vs-dropck/
It is profoundly confusing writing a debugger. You're accustomed to seeing a stacktrace as a sign that you've screwed up, but it means that your debugger is working correctly!
Really neat code completion tool that combines program synthesis with a debugger, so you can set a break point and ask it to generate snippets using the values available! https://youtu.be/SnkskEgcbuQ
Quicktype is a nifty project that generates type definitions from sample JSON examples: https://github.com/quicktype/quicktype
It's often easy to overlook parts of software development that can be automated.
Clojure provides a mechanism for early termination from reduce expressions with 'reduced': https://clojuredocs.org/clojure.core/reduced
It's unusual to see a special early termination function: most PLs only provide general control flow constructs like exceptions.
Where static analysis can't work, the JS community is exploring libraries declaring that they're pure: https://github.com/webpack/webpack/blob/master/examples/side-effects/README.md
Today I learnt that make has a --dry-run option! Tools that want to discover project includes, such as rtags, use this to discover how your project is built: https://github.com/Andersbakken/rtags#setup
elisp-def is now feature complete! You can jump to local definitions, global definitions and distinguish functions from variables, even when you're using macros! https://github.com/Wilfred/elisp-def
Showing 2,881-2,900 of 7,508 posts