VS Code is exploring a model where you have multiple processes supporting the IDE: a fast syntax checker, and a slower error checking/completion service! https://code.visualstudio.com/updates/v1_36#_use-syntax-only-feature-of-javascript-and-typescript-more-quickly
(Cute model, but I wonder if the lack of threads in node makes it more necessary.)
miniblog.
The base ISA for RISC-V has been ratified, so there's a stability promise! https://riscv.org/2019/07/risc-v-foundation-announces-ratification-of-the-risc-v-base-isa-and-privileged-architecture-specifications/
I've always wondered why npm defaults to the ISC license rather than MIT. MIT seemed more well-known and similarly permissive.
Turns out that ISC is essentially a shorter MIT! https://choosealicense.com/licenses/isc/
Why did Daniel Stenberg create curl, release it for free, and continue maintaining it? https://stackoverflow.com/questions/55884514/what-is-the-incentive-for-curl-to-release-the-library-for-free
(Stack Overflow is big enough that they get answers from the maintainer himself!)
Exploring DWARF objects interactively in Pharo: https://github.com/lukego/blog/issues/20
A really neat idea for LLVM: AST interpreters are slow, so clang's constexpr evaluator is slow. Write a small bytecode interpreter to make constexpr execution scale better!
https://lists.llvm.org/pipermail/cfe-dev/2019-July/062799.html
I have a fondness for visible pixelation: pixel art, bitmap fonts, displays with large LEDs.
It's a medium that's distinctly technological. I can display high resolution photos or realistic graphics on a modern device, but it's less distinct. The medium doesn't affect the msg.
I rather like the fs.readFileSync API in node. It gives you a buffer, unless you specify a text encoding.
This gently encourages users to think about their encoding, without having a heavyweight unicode datatype.
Commonmark.js has a lovely feature that's rare in markdown renderers: it exposes an AST! https://github.com/commonmark/commonmark.js/#usage
This makes it so much easier to extend/modify the syntax in a robust manner.
I'm coming to the view that microblogs (tweets) and normal blogs are too time focused. There's a pressure for novel ideas, ideas must be polished, and they assume you don't want to edit old ideas.
Perhaps a bliki is a better model? https://martinfowler.com/bliki/WhatIsaBliki.html
On the importance of good written communication to maximise your effectiveness as an engineer: https://blog.pragmaticengineer.com/on-writing-well/
Ted Nelson introducing some of the basic principles of Xanadu, his hypertext design: https://www.youtube.com/watch?v=hMKy52Intac
He stresses the importance of visible hyperlinks, an interesting choice when some UI designers argue that today's underlined links are distracting for readers.
HN discussion of interesting technology demos for fifth graders: https://news.ycombinator.com/item?id=20069714
One popular suggestion was browser tools, showing how web sites can be modified.
Another great idea is showing screenshots of bugs in realistic games and how they can go wrong.
Texture is a fun web-centric tool for creating interactive fiction webpages. Rather than accepting arbitrary sentences as inputs, you drag verbs onto nouns in the current paragraph.
Here's an example: https://texturewriter.com/play/jake/predictions-for-a-strip-mall-psychic
Fuchsia, Google's new operating system, has increasingly more information available online, including some design docs!
https://fuchsia.dev/fuchsia-src/the-book
Percy is a neat product for CI of visual changes: https://percy.io/
It reminds me of Wraith: https://github.com/BBC-News/wraith but neatly packaged as a service to run against pull requests.
Systems Software Research is Irrelevant by Rob Pike (2000) https://web.archive.org/web/20060420001914/http://www.eng.uwaterloo.ca/~ejones/writing/systemsresearch.html
Discusses how hard it is to build novel systems today.
Would it be possible to quantify perceived coolness of different programming languages?
My only idea so far is look at how many HN stories mention each language, relative to their usage levels (according to the SO survey).
A transcript from a deeply insightful @strangeloop_stl 2018 talk: comparing software design to programs that generate programs.
Deductive synthesis can give us insights on choosing abstractions, and counter-example guided synthesis is much like TDD!
https://www.pathsensitive.com/2018/12/my-strange-loop-talk-you-are-program.html
Defining extensible macros, and a helpful approach of classifying syntax into distinct categories: https://codewords.recurse.com/issues/two/not-everything-is-an-expression
Showing 301-320 of 736 posts