andrewchambers

I am the author of bupstash - https://github.com/andrewchambers/bupstash which has many advantages over borg in my biased opinion (like air gapped decryption keys and better performance). Feel free to check it out.

I think its more fair if you say your intentions from the start so nobody feels ripped off.

Well they did block free movement in the country for a few months, not really sure how legal that was tbh.

Ok, I am saying a super computer the size of the moon that simulates a human an everything it interacts with.

The post said they simulated the universe (or you could assume just the parts close to earth), it would be simulating everything a human would interact with. I don't see the point this reply was trying to make.

They don't disagree on the facts, its just one description is an extremely uncharitable and insulting to the skills of our ancestors. There were talented and skilled healers who did the best they could with the knowledge of the time.

Hot water would need to first reach the temperature of the cold water (and overtake it) before freezing... Your explanation doesn't make sense.

It just says visual studio is statistically more likely to die out - as most software does.

I suppose ignorance is bliss after all - I mainly hope you are exaggerating when you say 'fumbling through'.

Do not use async rust when you are learning. It is ok once you are proficient in rust.

This sounds like a terrible way to exist.

You can already do this by using rqlite to redirect writes.

This is not really accurate, it stores keys as securely as it is able to. Also the heap is not inherently insecure - it depends on other factors such as network isolation, user permissions, containers and other kernel protections.

Many things like https and ssh servers store secrets on the heap when they are in use.

You are unfairly comparing ancient C with modern rust - Try comparing modern C with modern rust to avoid making a straw man argument. Like I said, I don't even disagree, I still think you are just doing everyone a disservice with this line of reasoning.

He said if he had used rust - I am saying if he had used C when rust was available 1. The bug would have been fixed. 2. He could have used valgrind. Modern C also has something called ubsan, and another thing called frama-C.

These tools may be inferior to what rust has, but ignoring they exist or comparing 10+ year old C with modern rust is a bad faith argument.

Or he could do the normal thing and run valgrind to instantly see exactly where the problem is. I don't even disagree with the premise, but these are straw man arguments.

This is not a good anecdote - You hit a 10 year old bug because your sysadmin was too lazy to update gcc and then formed a bad impression of the software?

Guess what, if you install a 10 year old version rust none of your code would not compile at all. Your logic is so flawed its hard to believe you are being serious. If anything it's impressive that a 10 year old C compiler worked most of the time when most other languages are not stable on these timescales.

A simple solution might be to just look for name aliases that match a type and report that to the user. I don't see why you can't name the shape of a structural type without having to use nominal types.

SSH certificates can sign a key with an expiration, thats a bit different to a password.

More great things:

- https://c9x.me/compile/

- https://github.com/vnmakarov/mir

I updated the readme to better explain what I meant.

It can assembly all the assembly generated by cproc - which can compile the tools it depends on including cproc itself. I will update the readme.

Author here, that's exactly what I meant. It can also assemble the cproc C compiler when it compiles itself - thus creating a loop. I updated the readme.

First there is perhaps some slight refactoring that could be done. Though it does sound nice to reduce the dependency tree.

One thing is I like the declarative nature of the peg, so I considered trying to make a tiny peg parser generator to go with it (Also worth noting that peg/leg itself is very small).

All that being said, a hand written parser could probably dramatically increase performance and not be that much more code - so I am still unsure - but probably.

> Examples, image editors need to load new formats

Alternatively, they could be designed to support plugins.

The benefit is mainly that it is interesting and easy to learn/experiment because it has a very small and tidy implementation..

Just an example, building cproc from source takes a few seconds - building gcc from source takes like 15 minutes at least.

I honestly don't mind going without C const (compared to C++ where it is more useful).

There is one, see pp.c.

Really once the secure channel between two processes running on each host is setup, there is no difference between the two methods. A pull backup can be tricked just as easily by presenting a false filesystem or backdooring the 'pull process' running on the compromised machine.

You want append only backups with secure timestamps and do forensics to find the last good snapshot. It is easier to set that up with pull backups, but not so hard with the right tools for push backups.

Full heap scans still happen, just not as often, then you get the alternative 'cringe' of having huge amounts of old data sitting idle for nondeterministic periods of time.

Well, a (more) compact bytecode representation is one of the design decisions made for web assembly... That is one reason why it is a stack machine.