impetus | Agnostic utility for adding momentum | Frontend Framework library

Recently started C coding on Linux and ran into a 'multiple definition' error (sources A.c and B.c below)

gcc -Wall A.o B.o -o C

/usr/bin/ld: B.o: in function "Hello":
B.c:(.text+0x0): multiple definition of `Hello'; A.o:A.c:(.text+0x0): first defined here

Searching thru S.O, it was suggested to use this linker command line option

--allow-multiple-definition (-z muldefs)
Normally when a symbol is defined multiple times, the linker will report a fatal error.
These options allow multiple definitions and the first definition will be used.

Running this command bypassed the error message

gcc -Wall -Wl,--allow-multiple-definition A.o B.o -o C

It seemed peace was restored, however, it output

./C

Hello A
Hello A
World B

I was expecting this output below and "assumed" the linker would smoothly resolve any symbol conflicts, but at least keep the existing code functionality

Hello A
Hello B
World B

However, the resulting C ELF binary was modified as follows by examining the assembly output from objdump -S -M intel C

• Removed the duplicate Hello() in B.c
• Re-pointed any calls to Hello() in A.c

Questions

1. Is renaming the symbol Hello() the only correct solution?
2. Is it bad practice to use --allow-multiple-definition option?
3. If possible, should the linker be more sentient about intended code functionality by restricting a functions visibility i.e., understand that Hello() is a duplicate symbol in B.o and calling it from World() should be confined to B.o instead of looking into A.o?

gcc -Wall -c A.c

This isn't exactly the best stack overflow question because it's opinion-based, but I'm going to try to ask it in a way that will lend itself relatively to an answer with some degree of factuality (as opposed to opinion).

I know you can switch projects (https://docassemble.org/docs/playground.html#projects), which is of course very useful. What I'm thinking about in particular is that I have seen some tutorials that abstract code out of interviews in .py files -- this seems reasonably useful to me, not the least of all because of linting (tangent: is there a docassemble linter?).

Because of the way docassemble does inheritance, I think I would rather have my entire playground be one big directory with subdirectories for projects (rather than starting from scratch with new projects ... some of the .yml file, .py files, static files, etc. are probably able to be written in a way that they can be re-used across interviews and I'd love to do that in a way that's less clunky than re-importing them into a new project when I need them.

1. Can we organize the playground in docassemble, or are we stuck with a one-level directory?
2. If the playground can be organized (eg. into directories, subdirectories, etc.), are there any community-accepted or JHPyle-reccomended best-practices around that? (i.e. although I assume less formal, I'm thinking something like PEP) I know it's probably easy-enough to come up with a file naming convention with similar effect, but that's a bit hacky.
3. Is in possible, as an alternative, to simply directly edit the packages?

The main thing I'd like to accomplish, and the main impetus for this question, is keeping my code DRY by using helper functions / helper .yml files.

I have a CSS issue. Firefox renders the content the way I intend, however, chrome collapses the grid and does not display the image at the height it is supposed.

My intent: The image should be as large as possible without exceeding the width of the column. The row height should be taken from the resulting height of the image.

The recommendations discussed in this thread result in the issue below: Controlling the size of an image within a CSS Grid layout

relevant HTML:

Is there a good way to store de-identified voting data related to an election, while still ensuring people can't cast multiple votes? What is the best practices for storing this kind of data, particularly over longer periods of time?

I am one of a few web admins and database administrators for a recreational club. We have over 500 members. Each year, we hold an election to vote for new board members, and election data is stored in our database. We have the following database tables that store over a decade of voting data:

• Election: Holds general election details, such as the start and end time for voting in a particular election.
• ElectionCandidates: Holds information about the candidates, their bios, etc.
• ElectionVotes: Holds individual votes along with the memberID of the member who voted.

We're rewriting parts of website, including election-related content, and so it seemed like a good opportunity to think more critically about this database structure and whether it conforms with best practices. My main concern is storing memberIDs associated with each election vote. A further impetus for putting a spotlight on this practice is that one of the members who is running for the board this year happens to be a web administrator will full access to the database.

At the end of the day, I trust these folks, and I'm not too worried about anything bad happening. But I'm curious what should be considered a best practice for handling this kind of data.

While not directly relevant, we use ASP.NET Membership right now (but soon will be switching to ASP.NET Identity).

The concept equality_­comparable_with is intended to declare that objects of type T and U can be compared equal to each other, and if they are, then this has the expected meaning. That's fine.

However, this concept also requires common_reference_t to exist. The primary impetus for common_reference and its attendant functionality seems to be to enable proxy iterators, to have a place to represent the relationship between reference and value_type for such iterators.

That's great, but... what does that have to do with testing if a T and a U can be compared equal to one another? Why does the standard require that T and U have a common reference relationship just to allow you to compare them equal?

This creates oddball situations where it's very difficult to have two types which don't reasonably have a common-reference relationship that are logically comparable. For example, vector and pmr::vector logically ought to be comparable. But they can't be because there's no reasonable common-reference between the two otherwise unrelated types.