Building a performant IDE that scales is a non-trivial architectural problem: https://news.ycombinator.com/item?id=27428625
miniblog.
Sometimes a typechecker spots a ton of issues. I find that lists of numbers get very little benefit though.
I'm writing some messy logic that groups line numbers, and it's super easy to screw up.
Are there other cases? Strings might be another example.
Which Rust libraries are the most "business-y"? A fun analysis that compares weekday download rates with weekend downloads: https://old.reddit.com/r/rust/comments/nsvyxq/what_are_the_most_professional_crates/
checked_int_cast is used more on weekdays, whereas cpp_syn is used more at weekends. Not sure what to conclude there.
TIL that Python allows you to override subclass logic with __subclasshook__! This lets you define protocols, or cute things like isinstance(Noon(), PalindromicName).
Python goes all-in on metaobject protocols :)
https://www.hillelwayne.com/negatypes/
(1) Stare at code wondering what my new struct should look like.
(2) Make coffee and realise what fields I need.
(3) Type it out.
Which of these count as programming? (3) looks like it, but doesn't feel like it.
I've been playing with Hammerspoon to speed up my workflow on macOS.
Setting up shortcuts to jump to my most used apps is really nice. Alt-Tab forces me to choose from a large list.
GQless takes an elegant approach of deriving GraphQL queries directly from your controllers. You write code in typescript (tab-completed etc), and it generates queries! https://gqless.com/
Reading about Oberon on RISC-V, and I'm surprised to learn that adding a USB stack would probably be a major increase in total lines of code! https://news.ycombinator.com/item?id=25501944
GCC will no longer require copyright assignment to the FSF! https://lwn.net/Articles/857791/
It's definitely a hurdle (I've done the paperwork in several jobs) so this should really help new/casual contributors.
cargo flamegraph is a delightful way to run your Rust binaries as normal, but see a flamegraph of runtime performance! https://github.com/flamegraph-rs/flamegraph
Plotting TODOs over time for different OSS projects is a really interesting way to look at project development: https://schleiss.io/plotting-source-code-todos-for-open-source-projects
There's often a bump before a major release. Most projects increase over time (perhaps it's proportional to LOC?).
scc is a fast, polished tool for counting lines of code: https://github.com/boyter/scc
The author has several great posts discussing LOC tooling, including this one on exploring codebases with it: https://boyter.org/posts/why-count-lines-of-code/
grex is a really impressive tool that generates a small regex for a given set of string inputs: https://github.com/pemistahl/grex#53--examples-top-
There's a live instance you can play with at: https://regex.help/
Fascinated (and slightly surprised) that Google found ~50% of security bugs occur in code written in the last 12 months.
So maintained code that isn't actively developed is often good!
https://security.googleblog.com/2021/04/rust-in-android-platform.html
Super impressed that I received an elisp PR that discusses backwards compatibility to 1997! https://github.com/Wilfred/bison-mode/pull/13
One nice property of autoformatters: they're a really fast way to do a quick syntax check. Especially with a slow build process, it's a good check for dumb mistakes.
It's now possible to compile small Rust programs with libgccjit! This will enable Rust on a bunch more architectures.
https://blog.antoyo.xyz/rustc_codegen_gcc-run-core-tests
Admittedly these programs don't run correctly yet, but getting something basic working often takes 80% of the work in PL.
The Rust documentation host, https://docs.rs/, has a really cute nudge to make sure your code has documentation. It exposes the docs coverage percentage in the UI!
Blog comments work best when the author has a large following, and they actively engage their community.
I don't think many blogs reach this scale. For a typical blog, it's probably better to have comments on link aggregators (Reddit etc) instead.
I'm coming to the view that NP-complete problems are harder to work with than tasks equivalent to the halting problem.
For the halting problem, you know you're never going to solve the general case. For NP-complete problems there's a slew of complex algorithms to explore.
Showing 201-220 of 345 posts