Mister_Snuggles

I have a Prime G2 and the RPN mode is just bad. It feels like it was an afterthought, and some things just don't seem to work properly in that mode.

My 48G+ is a much, much better RPN calculator.

The Prime G2 is also missing the equation library from the 48G+, which I found weird. Maybe they expect you to download what you need instead of using space in Flash for it.

I never used an Atari computer, nor did I know anyone who did, but I always wonder what the world would be like if Windows and macOS didn't "win".

If Atari and Amiga had won instead, what would the world look like?

What would the server world look like? Would there be some weird "Amiga Server Enterprise Edition"? Would servers just be Linux without any meaningful competition?

Would Atari have shook the world by introducing a new CPU that resulted in amazing battery life compared to the Amiga competition? Would some of us be using AtariPhones? Would Android be a thing?

Would retrocomputing folks talk about their Windows 3.1 boxes the way that Ataris and Amigas are currently talked about?

I'm very happy with Restic backing up to BackBlaze B2.

I have a "config file", which is really just a shell script to set up the environment (repository location, etc), run the desired backups, and execute the appropriate prune command to implement my desired retention schedule.

I've been using this setup for years with great success. I've never had to do a full restore, but my experience restoring individual files and directories has been fine.

Do you have any links related to the index corruption issue? I've never encountered it, but obviously a sample size of one isn't very useful.

Does anyone have an up-to-date comparison of Borg vs Restic? Or a compelling reason to switch from Restic to Borg?

I've previously used Borg, but the inability to use anything other than local files or ssh as a backend became a problem for me. I switched to Restic around the time it gained compression support. So for my use-case of backing up various servers to an S3-compatible storage provider, Restic and Borg now seem to be equivalent.

Obviously I don't want to fix what isn't broken, but I'd also like to know what I'm missing out on by using Restic instead of Borg.

ORMs could offer a unique advantage by allowing the user to describe an append-only table and generating the required triggers (or the appropriate CREATE TABLE options). They'd also be able to include helpers to make working with the table easier - like defaulting to selecting current rows only, or an easy way to specify that you want rows as-of a certain point in time.

I'm not sure if any ORMs actually support this though.

This could be enforced in the schema via triggers and/or security permissions. Cooperation from the client is not required.

EDIT: Oracle has append-only tables, and can also use "blockchain" to verify integrity. See the IMMUTABLE option on CREATE TABLE[0]. PostgreSQL doesn't appear to have append-only tables, so using security and/or triggers seems to be the only option there.

[0] https://docs.oracle.com/en/database/oracle/oracle-database/2...

> Python code used by Excel runs on the Microsoft Cloud with enterprise-level security as a compliant Microsoft 365 connected experience, just like OneDrive. The Python code runs in its own hypervisor isolated container using Azure Container Instances and secure, source-built packages from Anaconda through a secure software supply chain. Python in Excel keeps your data private by preventing the Python code from knowing who you are, and opening workbooks from the internet in further isolation within their own separate containers. Data from your workbooks can only be sent via the built-in xl() Python function, and the output of the Python code can only be returned as the result of the =PY() Excel function. The containers stay online as long as the workbook is open or until a timeout occurs. Your data does not persist in the Microsoft Cloud.

This is disappointing. A much easier way to 'keep your data private' would be to run it locally. Surely a bundled Python interpreter run inside a sandbox that prevents network access would be just as secure, and cheaper for Microsoft since they don't have to run any Azure resources to support it.

Thank you - this looks like exactly what I was hoping for!

I've literally added Pandas to some of my projects just so I could use a DataFrame to print a nicely formatted table instead of writing code like this.

Surely there's a library out there to do this job, it seems like such a common use-case. I'm surprised it's not in the standard library to be honest!

Alberta just announced that this is happening starting in the fall: https://www.cbc.ca/news/canada/calgary/alberta-classroom-cel...

> life improvements like, in order to clear some registers all one need to do is write 1 instead of the whole =& ~(REG | 0x8) (or something like that, it’s been a while since I write embedded C)

This is a really interesting feature since it addresses a shortcoming of the C language (inability to easily express bit set/clear) by introducing a new hardware feature.

> Ban all the SQL control characters in usernames/passwords and 400 any request that contains them. Hash and base64 both the username and password so they get converted to something where SQL injections are impossible because of the character set used.

The problem that this tries to solve has been solved by every SQL database for a long time. Bind-parameters in queries are your friend, never build a query using string concatenation.

I’ve got some Sengled E1C-NB7 plugs that I really like. The form factor is nice, they work perfectly with Zigbee2MQTT and Home Assistant, and they’ve got a power button on the device itself.

I want to buy more and they don’t seem to be available anymore.

This is actually really interesting!

We run a lot of containerized stuff too, but in AWS EKS. For us, access to the container host isn't really a thing, and I'm not even sure if it's possible to be honest. The container hosts are an implementation detail, any direct access to the containers is through `kubectl exec ...`, so the tools available there come from the container image and match from dev through to prod.

I do agree with you though. It really feels like the change from netstat to ss, ifconfig to ip, etc, is churn for the sake of churn. FreeBSD is nice because it's a comprehensive operating system. Linux is a kernel used by a whole bunch of different, but fairly similar, operating systems.

My favourite (ab)use of `make` is as a batch runner: https://news.ycombinator.com/item?id=32441602

This (ab)use of `make` runs multiple times a day, every day, and works perfectly every time.

The inspiration of this was an (ab)use of `make` as a way to paralellize Linux system startup: https://web.archive.org/web/20110606144530/http://www.ibm.co...

It seems like the real problem is that you've got a ton of drift between your Prod and Dev environments. How old is your Prod compared to your Dev?

Since you're running something in a container, you should be able to upgrade the host OS (more accurately, recreate the hosts with current images) very easily. I wouldn't expect there to be more than a few weeks of drift between Prod and Dev.

I use an ultrasonic sensor and ESPHome to monitor the water level in my sump pit. Depending on what you want out of your septic tank monitoring, this may be a useful option.

I must have only ever encountered it in "bookkeeper mode". That abstraction is likely what threw me off!

> if you're trying to understand a piece of software like Quickbooks and are not coming from an accounting background

Unfortunately, QuickBooks won't help you understand accounting. It's not a true double-entry accounting system, at least it wasn't the last time I touched it. That said, it still does its job and does it well enough, and real accountants are fine with dealing with it.

Simply Accounting is a better example of a true double-entry system.

The act of "posting" a transaction updates the ledger to reflect the current balance. Think of the ledger as "Current state" and the transactions as "how we got there".

> Don't store the account data. Instead store the transactions. Compute the accounts from that. The table "Transactions" should have the fields: Date, Amount, SourceAccount, TargetAccount, Description.

This is a bad design, please don't do this.

The better design is to have header and detail tables:

Header: TransactionID, Date, Description, (other fields as required, e.g., posting status, reconciliation status, etc) Detail: TransactionID, LineNumber, Account, Amount, Description, (other fields as required, e.g., reference numbers for subledgers, etc)

This allows a transaction to affect any number of accounts. In effect, the transaction ends up reflecting a business transaction which may affect many accounts.

It was at the time, it may not be now.

I honestly find it weird when I hear about companies like Facebook and Synology using it.

Facebook could easily work around failures, they've surely got every part of their infrastructure easily replaceable, and probably automated at some level. I'm sure they wouldn't tolerate excessive filesystem failures, but they definitely have the ability to deal with some level of it.

But Synology deploys thousands of devices to a wide variety of consumers in a wide variety of environments. What's their secret sauce to make BTRFS reliable that my work's commercial Linux distribution doesn't have? Surely there's more to it than just running it on top of md.

Maybe in the years since I was burned by it things have greatly improved. Once bitten, twice shy though - I don't want to lose my data, so I'm going to stick to things that haven't caused me data loss.

At work, this all happened on a commercial Linux distribution which we do pay for. As far as I recall, their support was unable to resolve the issue, hence rebuilding all those VMs. I’m not on the server team, so I don’t know many details, but I was affected by this issue and it caused a lot of grief across the organization.

So no, I don’t think we got what we paid for.

Anecdotally, this is untrue.

Personally, BTRFS is the only filesystem that has ever caused me any data loss or downtime. I was using a single disk, so it should have been the perfect path. At some point the filesystem got into a state where the system would hang when mounting it read/write. I was able to boot off of a USB stick and recover my files, but I was unable to get the filesystem back into a state where it could be mounted read/write.

At work, we used to run BTRFS on our VMs as that was the default. Without fail, every VM would eventually get into a state where a regular maintenance process would completely hang the system and prevent it from doing whatever task it was supposed to be doing. Systems that wrote more to their BTRFS filesystems experienced this sooner than ones that didn't write very much, but eventually every VM succumbed to this. Eventually the server team had to rebuild every VM using ext4.

I know that anecdotes aren't data, but my experience with BTRFS will keep me from using it for anything even remotely important.

Wal-Mart tried it here in Canada for a bit, but it didn't last long at all.

I've never used NetBSD, but this announcement is rekindling my desire to install it on my old PowerBook G4.

Why do you consider it a waste of time?

I'm torn on this.

On one hand, I'd love to see intersections react to traffic in real-time to optimize traffic flow.

On the other hand, I have an "intelligent" intersection near my house and the cycle that the lights follow is something I can't figure out. There are four traffic directions, left and right turns from all traffic directions, and an LRT line parallel to one of the roads. I'm absolutely sure there's a pattern, but given the number of inputs I don't think I'll ever figure it out. Some of the inputs are invisible (e.g., incoming LRT cars hidden by a hill).

I wonder if there's been any study weighing the benefits of a predictable light cycle vs an intelligent cycle.

The FreeBSD answer to containers is jails, but I'm not sure how the capabilities of jails maps to the functionality provided by cgroups.