reuse | ️ Reuse React components to create new ones | Frontend Utils library

Because each fetch produces its own packfile and one packfile is more efficient than multiple packfiles. A lot more efficient. How?

First, the checkouts are a red herring. They don't affect the size of the .git/ directory.

Second, in the first example only the first git fetch origin does anything. The rest will fetch nothing (unless something changed on origin).

Why are multiple packfiles less efficient?

Compression works by finding common long sequences within the data and reducing them to very short sequences. If

long block of legal mumbo jumbo appears dozens of times it could be replaced with a few bytes. But the original long string must still be stored. If there's a single packfile it must only be stored once. If there's multiple packfiles it must be stored multiple times. You are, effectively, storing the whole history of changes up to that point in each packfile.

We can see in the example below that the first packfile is 113M, the second is 161M, the third is 177M, and the final fetch is 209M. The size of the final packfile is roughly equal to the size of the single garbage compacted packfile.

Why do multiple fetches result in multiple packfiles?

git fetch is very efficient. It will only fetch objects you not already have. Sending individual object files is inefficient. A smart Git server will send them as a single packfile.

When you do a single git fetch on a fresh repository, Git asks the server for every object. The remote sends it a packfile of every object.

When you do git fetch ABC and then git fetch DEFs, Git tells the server "I already have everything up to ABC, give me all the objects up to DEF", so the server makes a new packfile of everything from ABC to DEF and sends it.

Eventually your repository will do an automatic garbage collection and repack these into a single packfile.

We can reduce the examples. I'm going to use Rails to illustrate because it has clearly defined tags to fetch.

TDLR: always close database connections

The RDS proxy sits between your application and the database & should not result in any application change other than using the proxy endpoint.

Should I close the connection after executing my queries or leave it open for the RDS Proxy to handle?

You should not leave database connections open regardless of if you use or don't use a database proxy.

Connections are a limited and relatively expensive resource.

The rule of thumb is to open connections as late as possible & close DB connections as soon as possible. Connections that are not explicitly closed might not be added or returned to the pool. Closing database connections is being a good database client.

Keep DB resources tied up with many open connections & you'll find yourself needing more vCPUs for your DB instance which then results in a higher RDS proxy price tag.

And if I should close the connection, then what's the point of using an RDS Proxy in the first place?

The point is that your Amazon RDS Proxy instance maintains a pool of established connections to your RDS database instances for you - it sits between your application and your RDS database.

The proxy is not responsible for closing local connections that you make nor should it be.

It is responsible for helping by managing connection multiplexing/pooling & sharing automatically for applications that need it.

An example of an application that needs it is clearly mentioned in the AWS docs:

Many applications, including those built on modern serverless architectures, can have a large number of open connections to the database server, and may open and close database connections at a high rate, exhausting database memory and compute resources.

To prevent any doubt, also feel free to check out an AWS-provided example that closes connections here (linked to from docs), or another one in the AWS Compute Blog here.

Short Answer

tracemalloc was started too late to track the inital block of memory, so it didn't realize it was a reuse. In the example you gave, you free 27999860 bytes and allocate 27999860 bytes, but tracemalloc can't 'see' the free. Consider the following, slightly modified example:

Parallel Inheritance Hierarchies makes many unnecessary classes and makes code very fragile and tightly coupled. For example, we have class Sportsman and its Goal's.

You may use a shared_ptr with custom deleter that would prevent the object from being destroyed:

So I've re-opened this question because, while Do I need re-add packages after upgrade Julia touches on one part of the solution, there's a more robust option not mentioned there that may serve you well throughout package operations — offline mode! This is precisely why I asked the question I did in the comments.

Offline mode will force Pkg to re-use already-downloaded packages, even when re-adding them, even across versions. Of course the operation will fail if no versions of the package (and its dependencies) are downloaded, but it'll at least try to make the already-downloaded stuff work.

This is essential because it also allows you to create local environments without hitting the network, too. Of course, you'll need to go back online to actually grab new packages and updates, but this may help some slow network speeds.

This is probably one of the cases where you need to pick one between being DRY and using enums.

Enums don't go very far as far as code reuse is concerned, in Java at least; and the main reason for this is that primary benefits of using enums are reaped in static code - I mean static as in "not dynamic"/"runtime", rather than static :). Although you can "reduce" code duplication, you can hardly do much of that without introducing dependency (yes, that applies to adding a common API/interface, extracting the implementation of asListString to a utility class). And that's still an undesirable trade-off.

Furthermore, if you must use an enum (for such reasons as built-in support for serialization, database mapping, JSON binding, or, well, because it's data enumeration, etc.), you have no choice but to duplicate method declarations to an extent, even if you can share the implementation: static methods just can't be inherited, and interface methods (of which getMessage would be one) shall need an implementation everywhere. I mean this way of being "DRY" will have many ways of being inelegant.

If I were you, I would simply make this data completely dynamic

give workflow privillege when created token in GitHub:

If you are the only one working on that branch, you should do a git rebase -i (interactive rebase) in order to re-order your commits, putting first the one that should be merged to master, and leaving as most recent the one for branch only.