neandrake

I imagine that especially for a command line utility you also gained an easier deployment story when using rust, given the static linking and lack of interpreter. Requiring PHP to be installed to use a tool has caused me issues, especially with some of the recent PHP 8 updates introducing breaking changes. It’s a better story for PHP on a server where it’s more centrally managed.

This has been my experience, along with most great product leaders I’ve known have been “promoted” from developers/engineering as opposed to from the business end. Most devs/engineers I know also don’t want to take on this responsibility because they would rather be developing rather than overseeing product development.

I’ve been using CodeBook for several years and have been pretty happy with it. One time cost (per OS) and can sync over WiFi or to Dropbox/google drive. No browser plugins, instead it provides a global hot key activation which authenticates you (Touch ID or password), lets you search for the account then auto-types the password. On iPhone it integrates well for providing passwords to sites and they just recently added a feature which will also auto-copy 2FA TOTP into clipboard if one exists.

https://www.zetetic.net/codebook/

I can't speak to the foundation's performance or communication, but the purpose is more than holding its trademarks; it's for holding any/all assets for the organization. I thought the main catalyst for the rust foundation was there being many people/organizations which wanted to donate/fund development of rust but no means for handling the money (responsibly).

I’m not an expert but I think RSA is discouraged these days because it’s strength is dependent on the key size which is regularly outdated as computers get faster/parallelize. Ten years ago a 512bit key was considered secure but these days I think 4096 is the recommended minimum length for a keypair that’s considered secure. Because of this it requires cycling through keys every now and again which can be tedious and even painful if you build PKI using it. The latter happened with a project I worked on where we’ve had to cycle our users keys for an application a few times now, I think jumping from 512 to 2048 and recently to 4096. This is even more tedious in a zero-knowledge system where the keys can only be unlocked with user authentication but deadlines for updating exist..

I’m not positive but I don’t think Elliptic Curves have the same issue, or key lengths have longer predicted life spans.

It’s probably worth noting that the backwards compatibility breaking changes I think only applies to the language and not the standard library. I’m unable to look up the details right now but I believe there’s a trait function defined in stdlib which is deprecated, supersede, but can’t be removed even as part of an Edition, or it would break older code.

For anyone looking for a personal password manager that is not a browser extension but also provides the functionality to auto-type passwords into the focused field I highly recommend codebook

https://www.zetetic.net/codebook/

It's a one-time fee (per device~ish) and you can connect & sync it to Google Drive, Dropbox, Local folder, or to another device over WiFi. I've been using it for a few years and it has great iPhone and macOS integration. The Windows integration is also good but not quite as smooth as being integrated with FaceID or thumb print ID.

Do you know where there is more information about this type of design or what it might be called, in blog or book format? I ended up designing a very simplified (and modified) version of this same thing a decade ago for a web application:

Data is owned by some account (user or group). Users have membership/roles associated with an account (either a share or a membership) which enumerate all the operations that user is allowed to perform on data owned by that account. During a request a graph is built mapping the current user to the data's owning account via user->account shares/memberships or group->account shares/memberships. The graph is traversed ensuring that the action being taken exists on every role through the path (e.g. a user can share data with another user but can only grant a maximum of the same permissions that user has).

The big challenge I had was getting others to expand on this system as the product grew. Particularly as new features were added there was reluctance or ignorance that the actions introduced by features had to be enumerated in the roles/permissions. Though, when adding new actions it is difficult to know how to insert those into existing defined roles (as our roles are entirely customizable and not some constant set). That required account managers to go in and update their role definitions to specify where new actions should be allowed. The desire to avoid doing that led others to "just do an admin check" that would proliferate through the codebase as a means to simplify the logic, defeating the purpose of this flexible system. Early on I had eliminated the isAdmin check by ensuring all accounts had an un-editable Admin role whose list of permitted actions always contained everything. However an isAdmin check was added later which looked for the user having the role with all the permissions, instead of doing a check for that specific action.

Edit: Apparently this type of design is called Role-Based Access Control and information about it can be found by searching this term. And oso (the product made by the people who wrote the parent article) is a library for implementing an RBAC.

https://en.wikipedia.org/wiki/Role-based_access_control

My guess would be due to the recent news about Linux development incorporating rust. Though it was already a fairly large discussion here. Most of the other news items seem pretty regular.

https://news.ycombinator.com/item?id=27746130

In this situation the original project is no longer receiving regular updates. The fork is intended to continue maintaining the project, like updating to newer versions of PHP as older ones EOL, in addition to some new feature development.

As a note, we're planning to have a separate landing page on https://phorge.it, which is why it currently doesn't redirect.

That being said, if anyone is interested in participating we have a Zulip up at

https://temp-community-phab.zulipchat.com/

As well as working on the effort on https://we.phorge.it

Please see my other comment. The community is still forming around this and working on setting up the proper fork. This project is not yet ready for announcement.

There is an effort working to establish Phorge as a community-maintained fork but it is not yet in a state for announcement/release. There's still work being done to establish the organization, the fork itself, and the community. Please bear in mind that this is in it's infancy.

As part of practicing giving the hard feedback you can also practice framing the feedback to have the best impact. I've found focusing the feedback around behaviors and observed outcomes is the best.

E.g. instead of "please stop posting excessive memes on code reviews", "when you post memes on code reviews it pollutes the timeline and makes it difficult for reviewers".

I don’t think it’s clear but mercurial has two solutions for large file support. The original “largefiles” which had all the same designs and issues as Git LFS they bring up in the blog post, and “lfs” which is newer.

I’ve used largefiles and ran into these issues and ended up having to turn it off after a few years because it’s so problematic with the tooling since it modifies the underlying mercurial commit structure like git lfs.

However it sounds like mercurial lfs is different in that it only modifies the transport layer, though I’m not totally clear on the details and have been meaning to look into it further.

Losing Facebook as a contributor and community member is the larger loss, regardless of how much their internal vcs resembles or integrates with mercurial.

I’m not sure what commenter means by PR stunt but it is interesting that this company had a massive (and massively under-reported) pipeline leak scandal in the past year. I imagine Colonial is still managing that crisis and now have this new one to deal with. If they’re needing to do repairs or assessments for the earlier pipeline leaks now might be an opportunity to do so under a different headline which can blame an external adversary instead of themselves.

Aside from being a little small, the layout of this page is very easy on my eyes and also holds my attention compared to most news sites I come across. It also loads and displays content really well without requiring external javascript.

I can't speak to the clinical aspect of medical imaging but I've done some development with medical images. If you end up pursuing your diff concept here are a few things which might help point you in the right area or give you some additional keywords when searching:

1. CT images measure densities of tissue (in Hounsfield units).

2. The images will first need to be aligned/registered/fused. There are different ways to do this but it can be difficult if the two scans were done with different protocols/hardware as the image resolutions and dimensions can differ but also anatomy regularly changes (not as much in the head area).

3. Fusions are often described as having a primary (unchanged) and a secondary (the image that's modified to align to the primary).

4. Fusions can be very basic rigid alignments (like moving one photo on top of another) or be fancy by moving voxels independently (often called deformable registration, like cutting a photo into squares and moving them) however these are difficult to evaluate for correctness.

5. Fusions are often viewed as a transparency overlay of one image on top of another (in the case of deformable it's the deformed image over top the primary).

6. After doing a fusion a subtraction can be performed to find the difference in image values (the densities).

Best of luck and enjoy the field.

I identify with the motivations outlined in this post. One additional thing I'll add is that refactoring allows me to learn and understand the existing code base. Being able to move and rewrite code reminds me of playing with Play-Doh. This practice lets me immerse myself into the code a bit more so I can grok it more easily. Half the time my refactoring is thrown out or shelved for ages so there's nothing in the project history to show for it other than my new-found knowledge.

This article is repetitive and doesn’t include many details. Searching around the first several hits on windows 10 segment heap also don’t have much detail on why it’s an improvement over the existing.

It looks like segment heap has been available for several years in windows for UWP applications and the big update this year is that it’s now available to win32 applications. According to a white paper from IBM in 2016 it sounds like Microsoft Edge used this before so may have lost it with the recent migration to using chromium.

(PDF) https://www.blackhat.com/docs/us-16/materials/us-16-Yason-Wi...

Usually the other orthogonal assessment in addition to severity is frequency. If the bug is unlikely to be seen during regular use then even if severity is high the priority might be lowered. This is usually how risk is managed in my experience.

Sorry - by "own" I meant that it's in their system, a "walled garden". Any other vendor system looking to integrate has to sign business deals with Epic in addition to whatever institution is using it. I did not mean that Epic gets access to see and use that data as what seems to be a separate concern people have of Google.

There might be some fear of competition. Google is offering healthcare solutions some of which seem to be angled at "owning" the healthcare data. I'm only vaguely familiar with Epic's offerings but a lot of these solutions that Google offers seem to encroach in that territory:

https://cloud.google.com/solutions/healthcare-life-sciences/

https://cloud.google.com/solutions/modernize-legacy-apps/

https://cloud.google.com/healthcare/

> Surprising to hear a near-monopoly call for regulation.

Regulation can often mean a higher bar to entry for competitors. Compliance costs time/money and Facebook has plenty.

I’ve seen a similar effect in myself and others at work but I don’t think it’s only a symptom of the language. After we switched from java 6 to 8 a handful of devs including myself went overboard modeling problems to be solved with streams API when it wasn’t necessary. These days it’s leveled out and use of the api is on a much more appropriate level.

I think this is a process of learning. While learning a new tool you start to model problems so you can practice, even though not necessary. Once comfortable you realize when to use the tool and when not.

I heard that google has been shipping HTTP2 and/or HTTP3 functionality which would largely work only between the chrome client and servers which support those. That might also result in those pages appearing to load faster between different browsers.

I use codebook which allows syncing directly between devices, to a local folder, to Google Drive, or to Dropbox. It doesn’t have Linux support though.

I’ve been really happy with it, and it’s a one-time cost (per device though). The company who makes it also makes an open source encryption layer for SQLite.

https://www.zetetic.net/codebook/

There's also Phabricator as a self-hosted (and open source) solution for Mercurial (and Git and SVN) repositories.

https://phacility.com/