Hacker Newsnew | past | comments | ask | show | jobs | submit | onetom's commentslogin

no. as others have stated too, the following should be mentioned

- what's the 2 meaning in BMP

- it's designed as a monospaced (or proportional?) bitmap font

- designed in a single 16x16 size only (or also 8x16? it's a bit unclear)

- provided as an OTF/TTF font format, which can be scaled by most font rendering engines to other sizes, but u need antialiasing to make it look smooth (this is mentioned, but under the download section only)

- use as a "last resort" default font, according to wikipedia at least


In earlier versions of Apple OSes, you could edit the menus yourself, with the officially supplied resource file editor app and there was nothing really special about it.

There are `ibtool` and `plutil` CLI commands built-in to macOS these days too, but to get some graphical editor, u would need to download 3GB of Xcode and u would invalidate the code signatures, etc...

Plus there is a huge churn in the application versions, so any customizations would need to be applied repeatedly to newer app versions.

Sad, really...


> I feel like my Forth-like compiler and VM capture enough of the spirit of Forth!

Being interactive is core to the spirit of Forth, so I think your feeling is off.

The fact that editing, compilation and execution is folded into single, comprehensive workflow, makes it possible for a Forth system to be situated in very resource constrained environments and evolve while it's running, potentially without any dependence on some other, beefier computer somewhere else.

There are tons of problems avoided with bundling all these capabilities together. There is no question of "which version of the compiler to use?", since it's part of your program, because it's so small (few hundred bytes probably), it can be part of it.

It also has the D-lang, Rust or Zig style `comptime` feature via the immediate mode words.

And the list goes on an on...

Here is a starting point for understanding more of these principles: https://www.ultratechnology.com/lowfat.htm

Chuck Moore's ColorForth (https://colorforth.github.io/cf.htm) takes these ideals to some extremes, allowing an ATA IDE disk driver to be a few words of code only: https://colorforth.github.io/ide.html


Having written a Forth-like native-code compiler (https://github.com/kragen/stoneknifeforth) and also a game in Gforth, I can't claim to be a Forth expert, but I agree. A lot of the weaknesses of the language (such as no compile-time checking of even the number of arguments to a subroutine, much less their types, and its terseness) are shored up by the interactivity of the environment. Some of the short words in Forth like ? only make sense in that context. And some things that might otherwise be weaknesses, like variables being static, become strengths in that context. (If you store into x in a word you're testing, you can see what got stored there with x ?.)

More generally, Forth, considered as a programming language, is not very good compared to other languages of a similar level, such as C or assembly. Its strength is as an interactive environment. (And none of what I've said here implies that you have to use a block editor.)

This is all fairly abstract, but it's not the first time I've talked about it, so I did an ASCIIcast last year demonstrating me writing a square root subroutine: https://asciinema.org/a/621404 I screwed it up in the middle and had to debug it, which is where Forth's interactivity shines. You may want to watch it on double speed, though. You can also get the pleasure of watching me learn that Gforth has readline-like command-line history!

That said, I think you're exaggerating a bit. I haven't seen a Forth compiler that's only a few hundred bytes, and I don't think the blocking PIO in Chuck's IDE driver is a good way to access an IDE disk, although it's adequate for initial bootstrapping.


I think it's ok to edit forth code in a modern text editor. Following your definition, many modern forth engines wouldn't qualify as a forth. You don't need an antique screen-based editor to get immediate words.


Another thing of the Forth spirit is that the system is supposed to be fully bootstraped (like most Lisps as well), having a very small of words written in Assembly, and then everything else fully bootstraped in Forth and available for customisation.


I wonder, how rigidly has the JSON format been baked into the protocol.

It feels like a shortsighted choice, just because it's prevalent in recent decades.

It took years to implement performant parsers for it and it has a lot of quirks, missing features and the tons of double quotes and mandatory commas significantly harm its human readability...

Not sure what would I recommend instead, but personally I would prefer using EDN instead, as a Clojure programmer

https://github.com/edn-format/edn


You can write lexicon (the schema) in whatever language you want and then transform them to JSON for sharing.

The record format should be something widely used and implemented for sending over the wire. There are lots of languages and ecosystems participating.


  > The record format should be something widely used and implemented for sending over the wire.
That's just one of the parameters. It should also be something efficient if it's going to be sent over the wire at scale.


We're all sending JSON around all the time, it's not really that big a performance hit, especially in context of the formats transiting networks today (it's the same, lots and lots of JSON)


Note that it's CBOR being sent over WebSockets (afaik).


The firehose is CBOR, jetstream is JSON (which more people use)

I was mainly speaking more generally than atproto. Most APIs talk JSON these days


Great.

It's finally as snappy as recompiling the "Borland Pascal version of Turbo Vision for DOS" was on an Intel 486 in 1995, when I graduated from high school...

They C version of Turbo Vision was 5-10x slower to compile at that time too.

Turbo Vision is a TUI windowing framework, which was used for developing the Borland Pascal and C++ IDEs. Kinda like a character mode JetBrains IDE in 10 MB instead of 1000 MB...

https://en.m.wikipedia.org/wiki/Turbo_Vision


Can you give some pointers to some popular implementations or algorithms in any language, please?

Is there some "industry standard" or "best practice" for such a metric?

I guess Bitwarden might have something publicly available...


While I agree with what we don't need, something is still off with the UI. I can't really put my finger on any specific problem, though. It's just a gut feeling.

The names are bold faced, so my attention is drawn to them, but since i don't recognize any of them, i don't even know where to start reading.


i'm not from the US, but i did work on forms related to government workflows.

it bugged me for a long time why a person can't store facts about themselves and let some software figure out which of those facts are needed for filling out any form, which needs the usual personal facts.

then one can review the required facts and decide which ones are they willing to share.

in fact governments could even standardize the kind of info they are dealing with usually and when a citizen wants the government to do something, instead of filling out forms, they could provide their own, self-hosted fact db, run the govt's query and provide the results (after review)


I think the post office could have been this, but the political will wasn't there. Separation of banking from taxation and the postal system from both of those for separation of concerns for compartmentalization was probably at the forefront of the minds of the founders, since Washington himself had run a spy network and been personally hunted by soldiers and mercenaries on their own turf during the revolution, so I can't say these aren't legitimate concerns, but they haven't exactly aged well. At the time of the revolution and directly after the union, there was no federal income tax anyway.


> I think the post office could have been this

Explain. Id like to.know


I was responding to this aspect:

> it bugged me for a long time why a person can't store facts about themselves

https://en.wikipedia.org/wiki/Postal_savings_system

https://en.wikipedia.org/wiki/United_States_Postal_Savings_S...

Hypothetically, you could have sent 0.01 to a friend and use the memo field as a poor man's postcard with free postage, provided in-system transactions were free, which they arguably ought to be, but likely never were or would be in actuality.


Sounds similar to what Tim Berners-Lee was working on with Solid (https://solidproject.org/about).


Taxes work on "self assessment" basis meaning you, the taxpayer have the burden to declare all facts relevant to assessment of your tax and you pay the tax.

Then, sometimes your case is picked for audit and then they check if what you declared is correct as per applicable laws or not.

See, here is a small mom and pop shop... who owns that? Is the premises on rent? How much ? Is the rent deed valid and proper? Maybe you are paying less rent than declaring? Are you actually employing people you say you are? Are you paying them exactly you say you are paying?

How would you ensure that fact db is not having funny data ?

Say i am saying i am paying 100 bucks a week for fuel but fact is, my shop is next door to my home and i am just pocketing this cash daily. If i keep putting this 100 bucks weekly expense in this factdb, how will govt know.that i am not lying?


That's how they work now in america. They don't have to.

As for fraud, the same way they check for lies now, cross reference reports and then audit.


It’s my understanding that they have expected ranges certain things should be within that’s considered normal and anything outside of that puts a higher risk of an audit or simple manual review/adjustment.


You're moving the goalposts; the purpose would be reducing toil (and possibly other costs) for the people who are currently tasked with filling out these types of forms.

There's nothing in the comment you're responding to that suggests that it's instead meant to be a solution to the problem of the government (or any other org) being unable to trust the inputs to its systems or ameliorate the costs of bad actors at all.

A person entering lies in their personal fact database tomorrow can submit the same lies on their personal income tax return today.


the https://docs.openfile.tax/en/latest/direct-file.html link in the readme results in 404


sorry I changed the name, here's the correct URL - https://docs.openfile.tax/en/latest/reference.html


i would have explicitly mentioned shell & eshell too.

ansi-term however doesn't work thru TRAMP, out of the box, though there are workarounds, like https://github.com/cuspymd/tramp-term.el (hasn't tried it yet)


Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact

Search: