Corbin @ Corbin @programming.dev

Posts

2

Comments

90

Joined

2 yr. ago

Also, the author has a standalone blog post on the topic from 2011, Expression Parsing Made Easy.

It's not even an analogy; pointers and reference mechanics are the same concept in programming and linguistics. See the page on referents for an example blend of viewpoints.

The author would do well to look up SGML; Markdown is fundamentally about sugaring the syntax for tag-oriented markup and is defined as a superset of HTML, so mistaking it for something like TeX or Word really demonstrates a failure to engage with Markdown per se. I suppose that the author can be forgiven somewhat, considering that they are talking to writers, but it's yet another example of how writers really only do research up to the point where they can emit a plausible article and get paid.

It’s worth noting that Microsoft bought PowerPoint, GitHub, LinkedIn, and many other things—but it did in fact create Word and Excel. Microsoft is, in essence, a sales company. It’s not too great at designing software.

So close to a real insight! The correct lesson is that Microsoft, like Blizzard, is skilled at imitating what's popular in the market; like magpies, they don't need to have a culture of software design as long as they have a culture of software sales. In particular, Microsoft didn't create Word or Excel, but ripped off WordPerfect and Lotus 1-2-3.

Forget about your job for a moment. In general, why are you willing to set a threshold on how accessible your work is? I urge you to forget about how callous your employer wants you to be.

across the Internet ... doesn't require storing data twice

A flavor of the CAP theorem applies here; if you want your data to be available even during network partitions (and those are going to happen on the Internet!) then it has to be duplicated somehow. For example, I still have a soft spot for Tahoe-LAFS, which allows users to control how much duplication will be used and typically is configured to have some redundancy. Typical cloud providers build redundancy into their storage products; for example, it's known that Google's Colossus storage system uses Reed-Solomon to trade space for durability.

Nah, just use direnv instead, comrade.

For what it's worth, most of your comments aren't eligible for copyright; they aren't sufficiently original or information-packed. Just like @onlinepersona@programming.dev and their licensing efforts, it's mostly a vanity to attach a license to unoriginal one-line throwaway jokes. I wouldn't say that it's arrogant so much as lacking in self-awareness; a one-liner must be deeply insightful, contain a pun or paraprosdokian, address the current zeitgeist, or otherwise be memorable above and beyond the time and place that contextualized it.

Like @devtoi@feddit.nu I use plain-text accounting (PTA) to manage a few bank accounts, including small businesses. In my case, I'm using hledger. Every time I get a receipt, invoice, or statement, I type it into a text file. My bank gives me CSVs which are easy to import. Reports are done with a few commands; repeatable reports are done by saving commands to a shell script. hledger comes with builtin tools for monthly reports, BSE, currencies, pending invoices, closing/opening new years, and those are merely what I recall using recently.

A claim which is mostly true is false. Programmers should pay attention to details, since that is all computers know.

Open your mind a little; collective action has an impact but individual action may not. Paraphrasing Cloud Atlas, certainly an ocean is nothing more than a vast collection of raindrops, but each individual raindrop collectively acts as a body of water. This dissolves your false dilemma.

There are a lot of programming languages. Also, features can often be hacked onto or off of a language. It's therefore important to be able to quickly reject a language based on undesirable features. It's also important to recall the big picture: to maintain a large amount of instructions or transformations which have been proven correct. Anything which gets in the way of that big picture should be quickly rejected.

Self's descendants are not well-understood in our popular culture. The two most popular (Turing-complete) languages, ECMAScript and Python, are both Self grandchildren, and Java is also a child of Self; yet, the article's author incorrectly believes them to be ALGOL descendants because of surface syntax as well as the Java/ECMAScript focus on performance. Note also that the author doesn't mention E (WP, esolangs), which is akin to Erlang in making message-passing explicit but descends from Self, unlike Erlang which descends from Prolog. (I will give them partial credit for noting that Smalltalk is an ancestor of Java.)

So, the exemplar should be a message-passing everything-is-an-object language designed for JIT with no Prolog influence. The earliest such language in the family tree is Self!

INTERCAL is an ALGOL descendant. A holistic timeline of esoteric languages shows that esoteric languages don't form a family; however, there are several families not mentioned in the article, notably cellular automata and string/wire diagrams.

Yeah, writing your own squeeblerizer sucks, but there's no better option. GNU Scrimble can be used off-the-shelf as a passthrough, so the only real tasks are implementing Squeeb's algorithm and a sprongler; then, your entire pipeline is merely something like:

        $ gscrimble --passthrough --args -- ./your_squeeb | ./your_sprongler


  

Edit: Whoops! Forgot to mention, GNU Scrimble also has Snorble support out-of-the-box, and Scrimble clients have content auto-negotiation, so your_squeeb can just take JSON on stdin. GNU Scrimble is really nice for this sort of thing, just...big.

And if you want to sprongle directly into a database or etc. then you can write your_sprongler to taste. Full disclosure: I have a fairly fast implementation of Squeeb's algorithm in rpypkgs. However, I'd really recommend writing your own; it's like twenty lines of code you can copy from Wikipedia and it'll give you a good basis for extending it with your own desired changes later.

You can read snorblite's code if you need to figure out a specific sprongling technique, but it's way easier to just go look up the original SprongCode from SprongReg. Use a search engine to get around the university's paywall. This gets you the SprongCode UUID and you don't have to read code written by a batshit fascist.

It's because the Booleans sometimes are flipped in display-server technology from the 1980s, particularly anything with X11 lineage, and C didn't have Boolean values back then. More generally, sometimes it's useful to have truthhood be encoded low or 0, as in common Forths or many lower-level electrical-engineering protocols. The practice died off as popular languages started to have native Boolean values; today, about three quarters of new developers learn Python or ECMAScript as their first language, and FFI bindings are designed to paper over such low-level details. You'll also sometimes see newer C/C++ libraries depending on newer standards which add native Booleans.

As a fellow vim user with small hands, here are some tricks. The verb gU will uppercase letters but not underscores or hyphens, so sentences like gUiw can be used to uppercase an entire constant. The immediate action ~ which switches cases can be turned into a verb by :set tildeop, after which it can be used in a similar way to gU. If constants are all namespaced with a prefix followed by something unique like an underscore, then the prefix can be left out of new sections of code and added back in with a macro or a :%s replacement.

I was going to bring this one up. The least realistic part of Antitrust is how the antagonist is defeated, but the parts where somebody is impatiently waiting for javac to finish so that they can pack their .class files into a JAR, or typing in a list of IPv4 addresses one-by-one to see which one works, were painfully plausible.

In short: If you'd like to learn more, come visit #pypy on Libera IRC. It's an interesting discussion topic, particularly if we want standard-library imports like math, sys, or json to work.

RPython is not capable of translating to bare metal today; it depends on libc and libffi for many features even when not producing JIT compilers. It's also intended to operate on a layer of syscalls: rather than directly instructing hardware, it wants to make fairly plain calls, perhaps via FFI, passing ordinary low-level values. So, any OS developer would first have to figure out how to get RPython to emit code that doesn't require runtime support, and also write out the low-level architecture-specific hardware-access routines.

That said, RPython is designed to translate interpreters, and fundamentally it thinks an interpreter is any function with a while-loop, so a typical OS would be a fairly good fit in terms of architecture. RPython knows the difference between high-level garbage-collected objects and low-level machine-compatible values; GC would be available and most code would be written in a statically-typable dialect of Python 2.7 that tastes like Java or OCaml.

The OS would be the hard part. RPython admits the same compositional flexibility as standard Python, so it should be possible to hack PyPy into something that can be composed with other RPython codebases. This wouldn't be trivial, though; PyPy in particular is tightly glued to RPython since they are developed together in a single repository, and it wasn't intended for reuse from the RPython side.

If all of that sounds daunting, and what you would like to do instead is take an existing kernel or shell with C linkage and ELF support, and extend it arbitrarily using Python code, then PyPy can help you in that direction too. Compile a libpypy and embed PyPy against your kernel, and you can then run arbitrary Python code in a fairly nice environment which supports Python-first development. Warning: while the high-level parts of this might be nice, like Python's built-in REPL tools, the low-level parts could be very nasty since this embedding interface is old and rotting, to say nothing of actually getting bare-metal code that doesn't make syscalls.

A list can store zero or more elements. A NonEmpty can store one or more element. That's all.

This overall strategy -- representing the top of a list as a dedicated value -- shows up elsewhere, notably in Forths, where it is called "top of stack" and often stored in a dedicated CPU register.

Incorrect. The hidden gold is Factor. You were close!

Extension modules are implemented in C because the interpreter is written in C. If it were written in another language, folks would write extension modules for that language instead. Also, it would be less relevant if people used portable C bindings like cffi, which are portable to PyPy and other interpreters… but they don't.