davidkellis

Didn't l0phtcrack do this like 25 years ago?

Some amateur radio folks do something along similar lines: https://en.wikipedia.org/wiki/Earth%E2%80%93Moon%E2%80%93Ear...

Does this affect the linux version of homebrew? I'm hoping this has no effect.

Vibe coding a programming language: https://github.com/davidkellis/able

How many other user interactions are generally considered objectively bad practice? Sure, there may be a time and place, but what is frequently overused?

Toasts:

- https://maxschmitt.me/posts/toasts-bad-ux

- https://youtu.be/LeCKu0HqGFQ?si=xKApVFSqdzLGF0SD

Modals (being a special case of modes):

- https://modalzmodalzmodalz.com/

Modes:

- https://www.nngroup.com/articles/modes/

- https://ilyabirman.net/meanwhile/all/timed-modes/

What else?

It sounds like this is trying to coin a new term. I hadn't heard the word forge used to mean an all-in-one git+issue tracker+project mgmt+etc. suite before.

You to today (I do too). May not tomorrow: https://www.tomshardware.com/software/windows/microsoft-acco...

At first I couldn't figure out why Quill was being posted again, but now I see that a long awaited version 2.0 was released 3 days ago (see https://slab.com/blog/announcing-quill-2-0/ ). Thank you for the heads-up!

These are not new, but my takeaways from https://tratt.net/laurie/blog/2020/which_parsing_approach.ht... and https://rust-analyzer.github.io/blog/2020/09/16/challeging-L... are to embrace various forms of LR parsing. https://github.com/igordejanovic/parglare is a very capable GLR parser, and I've been keeping a close eye on it for use in my projects.

It's definitely a good reference, but I'll never read them cover to cover. Not unless I'm having trouble sleeping. :-)

ELI5 please?

My tin-hat alter ego says the three letter agencies are creating these companies for the sole purpose of then purchasing the data and skirting the law. But that guy is crazy. ha ha.

Sounds like inertial navigation to me.

I was looking for the same thing. This is what I hacked together to scratch the itch: https://github.com/davidkellis/mackeys

I run PopOS

I'm self hosting Ghost for blogging, Home Assistant for smart home controller, and in the middle of setting up Vaultwarden for passwords. I also run a lot of stuff off my Synology - Synology Drive instead of Dropbox or Google Drive, Synology Photos instead of Google Photos. I don't have a great solution for email or phone - emails is paid hosting through Zoho and use Android for phone. I'd like to get off those. It's all a long drawn out process.

I'm in the same boat. Trying my best to de-FAANG my life. Self hosting as much as possible, with as little management overhead as possible, but I'm still stuck on Android and I don't know how to break free.

What are the best alternatives to iOS and Android? Is it reasonable to consider the hardware itself "safe", given that the software tracks and calls home about every single thing it does? What are the alternatives?

Everyone hates paywalls

I'd like to see something like this for practitioners. I kind of have a feel for what's out there, but I don't know of anything that is: 1. pleasant to use 2. simple 3. scannerless 4. supports left recursion that produces a left-associative parse

My wife and I homeschool our children. We are part of a local homeschool co-op, and the kids love it.

I've been working fully remote for a year and a half, and homeschooling doesn't hinder my remote work in any way. I periodically have a "break-in", where one of the kids barges into the office during a meeting, but it's no more interruption than any other common interruption (e.g. someone comes in late, someone pardons themself to the restroom, etc.).

At some point it makes more sense to switch to Crystal.

I saw vlang.io a few months ago. Every time I come back to the site, my jaw hits the ground again. I am utterly impressed by Alexander's productivity - it blows me away every time I consider it.

I think V is an impressive language, but it isn't quite geared toward my vision of what a language ought to be.

I am more a Rubyist than a C, Rust, or Go developer, and so my preference is for a higher level language that's a little more pleasant to use and doesn't make me think about some details that I consider "irrelevant". I'm firmly in the "sufficiently smart compiler" camp, and think that I shouldn't have to think about those low level details that only matter for the sake of performance - the compiler ought to handle that for me.

No. I was pretty naive in my initial attempts. I tried for many months to make Laurence Tratt's Algorithm 2 (see https://tratt.net/laurie/research/pubs/html/tratt__direct_le... ) work, but ultimately I failed. I recall running into some problem with my implementation of Tratt's idea that led me to conclude that his Algorithm 2 doesn't work as stated. My reasoning is buried in a git commit message from many months ago - I'd have to go look it up.

My takeaway from Tratt's explanation was that the general technique of growing the seed bottom-up style when in left-recursion - I think I've also seen that idea termed "recursive ascent" somewhere else but I can't place it offhand - seemed reasonable, so that's what I kept working on until I figured out something that seemed to work.

Later on, I ran across https://github.com/PhilippeSigaud/Pegged/wiki/Left-Recursion, which describes Sergio Medeiros' technique at a high level. One of the nice things I used from the Pegged project was the unit test suite. I re-implemented some of the unit tests from Pegged in my own PEG implementation and discovered that it failed at those unit tests.

It took me another number of months to figure out why my implementation failed the unit tests. I re-jiggered my implementation to make it handle the scenarios captured by those unit tests, and then naively thought "hey, it works!"...

All was well until I ran across another set of unit tests in the Autumn PEG parser (see https://github.com/norswap/autumn). My implementation failed some of those as well. After another number of months, I had a fix for those too.

Long long long story short, this process continued until I couldn't find any more unit tests that my implementation would fail, so once again I'm at the point where I think "well, I think it works".

There have been a number of occasions where I've thought "if this doesn't work, I'm just going to re-implement Pegged in Crystal!". Perhaps that's what I should've done. Ha ha! In a few months, when I find another test case that breaks my implementation, I may just do that. We'll see. I hope it doesn't come to that. Fingers crossed. :-)

I'm trying to build a programming language that might best be characterized as rust - ownership + GC + goroutines (coroutines with an automatic yield semantic).

My rationale for starting this project was that I like specific features or facilities of many individual languages, but I dislike those languages for a host of other reasons. Furthermore, I dislike those languages enough that I don't want to use them to build the projects I want to build.

I'm still at a relatively early point in the project, but it has been challenging so far. I'm implementing the compiler in Crystal, and I needed a PEG parser combinator library or a parser generator that targeted Crystal, but there wasn't a PEG parser in Crystal that supported left recursive grammar rules in a satisfactory way, so that was sub-project number 1. It took two years, I'm ashamed to say, but now I have a functioning PEG parser (with seemingly good support for left recursive grammar rules) in Crystal that I can use to implement the grammar for my language.

There is still a ton more to be done - see http://www.semanticdesigns.com/Products/DMS/LifeAfterParsing... for a list of remaining ToDos - but I'm optimistic I can make it work.

Rails codebases I've looked at are usually in pretty good shape. I attribute it to the conventions that are fairly strongly enforced.

I agree with the sentiment, but I noticed recently that TaxJar (I considered applying there at one point) mandates a trial period along these lines. From https://life.taxjar.com/distributed-team-hiring-process/, "... We hope a candidate is able to spend somewhere between 80 and 160 hours working with TaxJar during their trial. ..."

Presumably there are some people who are willing to do a trial, either concurrent with their existing employment, or on the chance that they will be hired after the trial.

Politics is religion nowadays as well.

chevrotain's playground tool - https://sap.github.io/chevrotain/playground/?example=JSON%20... - is sure nice!

What parsing algorithm does chevrotain use under the hood? Does it allow left-recursive and right-recursive productions/rules?

Absolutely! Furthermore, https://github.com/harc/ohm is the successor to OMeta.

I'm in the same boat. I've found https://github.com/harc/ohm to be a pretty pleasant grammar and parser to use.

Ohm also has a nice interactive editor: https://ohmlang.github.io/editor/