oliverkwebb

You should be posting a link to https://flaviocopes.com/books/ or https://flaviocopes.pages.dev/books/css-handbook.pdf

The mailing list thing just sends you a public url. There's really no need to subscribe to it

Related, I have written about the formatting of the TZ database and other representations before: https://gitlab.com/libtime/documentation/-/wikis/Timezones

If the editor focused on becoming an IDE instead of being idiot-proof and cleanly designed, what would distinguish it from the 1,000 other editor projects?

It's nice to see an editor that explicitly isn't an IDE and is more something like notepad. often when editing config files and the such, it's more convenient to use something like notepad than it is to use something like VSCode.

This editor doesn't have delusions of grandeur, it focuses on usability more than features. and it is better for it.

JPL provides a data generation API that you can telnet into: https://ssd.jpl.nasa.gov/horizons/ to get the positions and whatnot of asteroids, planets, spacecraft, etc.

Thank you! I accepted it

This is also interesting for speed, The algorithms ran by all the impls are identical, but sacrificing speed for cleanliness and adherence to spirit is done regularly.

Without having actually measured, the rust impl probably runs faster than the C impl, but that's not because rust is "faster" than C. That's because I used a closure with one call to floor() for modulus in rust, whilst in C I did 2 fmod()'s to get it because the alternative would've been to make the code unreadable or add a second function/macro (although thinking about it now, undef does exist...)

This discrepancy with time is explained in the book the algorithm is based on (Practical Astronomy with Your Calculator, which also does a good job explaining a ton of other ideas and models in astronomical calculation).

January 0th makes sense because a year starts on January 1st. You count days of the year from 1 instead of from 0. So if we are going by the day of the year, day 1 of the year should be Jan1, the consequence of this being that Jan0 exists and is Dec31 of the prev year.

I originally got into this because of my status bar on i3, hacking together C code from moontool into https://github.com/oliverkwebb/moontool about a year back.

He was the publisher of the Halloween documents (from my understanding leaked by a whistleblower to him) and has always been a firm opponent to Windows in all his works. Are you thinking of Poettering?

Javascript is a famously cruft free language, as we all know.

My real question is how you created an account, found this article, presumably read through it, and wrote out multiple comments insulting me all within two minutes.

For a definition of "nobody" that includes Eric S Raymond, one of the most prominent figures in the linux world who's article (https://www.catb.org/esr/time-programming/index.html) I reference multiple times.

[plonk](https://www.catb.org/jargon/html/P/plonk.html)

> Which language can do anything without some asm and support as many platforms as C?

I wouldn't be surprised if someone figured out how to do the interrupts and register control necessary to invoke syscalls with pure LISP/Scheme/CL :P

P.S. anything that compiles with LLVM and has an ingrained way to do print() that doesn't invoke libc, although there's a blurry line here between "pure asm"/"compiles to asm" that involves trusting-trust-style bootstrapping of features into the compiler

The core of C is pointer arithmetic; This creates a fundamentally unsafe environment.

You can't even do anything in C without some asm (syscall wrappers) because C was meant to boil down and streamline PDP-11 assembly (Your computer is not a fast PDP-11) to a set of consistent principles. The consequence of this is that the core of the language is pointers and pointer arithmetic, and raw unabstracted pointers are fundamentally unsafe to work with.

Using the rust type system I can essentially confirm code is bug and edge-case free with exhaustive matching and unit testing (C's lack of tooling blessed the world with autoconf and cmake btw). Not to mention rusts ability to abstract away necessary boilerplate gives me more time to think about my code instead of pointer arithmetic and allocation heuristics.

The "cure" for C is a language that abstracts away raw pointers and memory allocation.

Thanks, the link esr provides in his website (https://www.catb.org/~esr/faqs/time-programming/index.html) leads to a 404

It's general presentation style and the way it's supposed to spread remind me of https://www.anybrowser.org/campaign/

Cool stuff, Although the fact it's under non-commercial licensing tempt me to just slap together a quick SVG file and offer it under public domain.

I see it more as a piece of history than any actual measurement of someones "hackerness". It's a fun way of peering into the realm of 80s hacker culture and seeing what was popular or cutting-edge at the time ("Have you ever programmed in the X windowing system?")

> As a result, you don't have to write articles on your website first and have them be read by an RSS reader.

I don't see how this is a problem, for proper preview, the markdown will have to get compiled into HTML/text anyway.

Most SSG's do this, but this can also be done with a good enough markdown compiler (cough lowdown) and a for loop. Without restricting your markdown formatting to a subset of the features of 2 markdown compilers

> The only reasons there are any issues with kind of issue merging code between different projects is 1) if you want to abuse users

"Abuse" them how? There's nothing wrong with the GPLv2, and no one should be obligated to switch to a different version.

> Linus screwed everything up by modifying the GPLv2 to remove the automatic upgrade clause (maybe so his users could abuse their users).

So, in your world. The FSF should be free to hold the entire open source community hostage? What if the evil "user abusing" people take over and make the GPLv4 with a version of CC0 and forcing everyone to switch (here's hoping, at least :P )

Having the ability to attack open source software is power, and that power can be used for coercion. The GPL is designed to prevent this, not propagate it with a backdoor.

> The latter is then part of why Rob made the even more awkward decision to do it to busybox, and why any of this is relevant to toybox... a project which shouldn't really exist for any reason other than because Rob really really wanted people to be free to abuse users going forward

No, toybox was created because the code of busybox was starting to look like GNU code (there's a reason they didn't codeshare even when they had the same license). It was originally a GPLv2 project in it's infancy.

> When you work on pretty much anything else, you really aren't going to run into this license compatibility problem: these are the only two projects I have ever come across that are using this fork of GPLv2

Linux Kernel and Samba still can't codeshare. ISABUG SHOULDBEFIXXED :P

> the only real problems now are Linux and busybox. Regardless, blaming GNU for Linus and Rob screwing us all over makes no sense

In your mind, the GNU project should have the ability to do whatever it wants up to _and including_ changing the terms which all open source software can be used at whim. And it's everyone else's fault when they don't trust the FSF with that ability.

> not with the GPL itself, as it isn't at fault.

You are correct, The GPLv2 is actually to some capacity a fine license. Which is why I'm mad at the FSF for trying to take the open source world hostage which lead to companies getting rid of GPL code in their codebases alltogether.

A issue with this is favicons. Which take up loads of space since they are tiny (usually losslessly compressed raster) images. You can simplify them or make them smaller or in ycombinaters case turn them into SVG. But without _changing_ the image itself it's still around a dozen kilobytes in some cases

Nice tool, I've been using html2md[1] and such. It's written in python and in beta so it's probably not the best for processing static sites and such. But still useful

[1]: https://github.com/suntong/html2md

Is there any chance this relates to the recent anti-trust case against google?

I.e. making a attempt to appeal to user wants more since the majority of the money they make is at risk