While other comments have discussed the technical utility of symbols, I believe symbols can also be seen as useful syntactic sugar that helps communicate intent. Strings used for indexes. named args, and other structural purposes can be represented in a way that is visually distinct from strings used as text.
The technical benefits are nice, but this type of ergonomic feature is why ruby has remained my favorite language for over a decade.
The traditional way a big tech company becomes the dominant provider is to embrace an open interoperable protocol to minimize the friction of switching from another provider. Later, when they have captured enough of the market, they extend the protocol to gradually reduce the de facto interoperability with other providers to increase the friction of switching to any other provider.
Using language like "fire fast" might presuppose a situation where someone is going to be "hired" - possibly involving a lot of work, life changes, and moving/other expenses - only to have their effort/money wasted when they are "fired fast".
What if instead of "fire fast", the idea was re-framed/restructured into the new employee initially working as some sort of consultant with a short term contract? Use telecommuting/work-from-home or other temporary workarounds to defer expensive/disruptive things like moving to live near the company until after the defined "trial" period. Instead of "firing fast", you either let the temporary consulting contract expire or you proceed with the actual hiring process and the deferred tasks.
Maybe this isn't possible in practice, but it seems like we could design a workaround to this problem if were sufficiently creative.
> think about the effects it has on others
Unfortunately, that takes proactive effort. Unless there is a mechanism to actively incentivize spending time and energy to protect others, most of the time that effort will be spent on "more important" things. ~sigh~
Reading point #4 on a site called "Hacker News" seems rather ironic.
I wonder how you might encourage deeper introspection into software infrastructure security vulnerabilities, both from closed source companies and from obscure open source projects, without "spreading breadcrumbs for the roaches"
In the beginning, there was a plan,
And then came the assumptions,
And the assumptions were without form,
And the plan without substance,
And the darkness was upon the face of the workers,
And they spoke among themselves saying,
"It is a crock of shit and it stinks."
And the workers went unto their Supervisors and said,
"It is a pile of dung, and we cannot live with the smell."
And the Supervisors went unto their Managers saying,
"It is a container of excrement, and it is very strong,
Such that none may abide by it."
And the Managers went unto their Directors saying,
"It is a vessel of fertilizer, and none may abide by its strength."
And the Directors spoke among themselves saying to one another,
"It contains that which aids plants growth, and it is very strong."
And the Directors went to the Vice Presidents saying unto them,
"It promotes growth, and it is very powerful."
And the Vice Presidents went to the President, saying unto him,
"This new plan will actively promote the growth and vigor
Of the company With very powerful effects."
And the President looked upon the Plan
And saw that it was good,
And the Plan became Policy.
And this, my friend, is how shit happens.
While some people certainly seem to subscribe to "feeling their masculinity/world-view is threatened" interpretation, the fundamental problem that q lot of people don't seem to understand is that the internet changed the mechanics of fame.
The best explanation I've seen - and possibly the most important video on youtube - is "This Is Phil Fish"[1] by Innuendo Studios. It's not really about Phil Fish; it's about everyone who isn't Phil Fish acted when they decided he became "famous". In the past, being "on tv" or "in a band" or other traditional examples of fame required some amount of buying into fame. Becoming famous required media access that was controlled by gatekeepers. You had to work with those gatekeepers if you wanted to be "on tv" or whatever, and because you had to choose to participate, people often see the decision to become famous as also accepting some amount of responsibility to "act like famous people are supposed to act".
This internet fundamentally changed the mechanics of fame, because the internet IS media access. Now it is possible to become famous - to become a "celebrity" with a "responsibility" to act in a certain way - simply by being yourself in your normal everyday life.
Regarding the creation and removal of a tempfile (line 72 & 85):
local tmpFile="${TMPDIR:-/tmp/bash-web-server.$$}"
# ...
rm "$tmpFile"
To avoid collisions when the PID is reused, and to clean up0 the tempfile on errors, I recommend using mktemp and trap:
local tmpfile="$(mktemp --tmpdir="${TMPDIR:-/tmp}" bash-web-server.XXXXXX)"
trap "rm -f \"${tmpfile}\"" RETURN EXIT
# ...
# Do nothing at the end of the function; trap will
# remove the file at RETURN automatically.
Otherwise, I like the implementation! It's nice to see good bash techniques like parsing with "IFS='&' read -ra data" and rewriting variables with %%/etc.
To spare you the trap you can open the file as FD in your bash process (e.g., exec {my_fd}>"$TMPFILE") and then directly delete it before doing anything else, and use the /proc handle to access it ("/proc/$$/fd/${my_fd}")
One more fun experiment: avoid the tempfile on disk/tmpfs by storing data into the pipe connecting two processes, where the first one can already exit for the pipe to give EOF when reading beyond the buffered data.
Since now, multiple concurrent connections will work after my patch. (Need to add subshell) i will need to consider using fd as output cache. Instead of temporary files.
This here is a simple echo server that uses tr to uppercase:
exec {checkfd}>/dev/null
CHECKFDPATH="/proc/$$/fd/${checkfd}"
(while [ -e "$CHECKFDPATH" ]; do sleep 1; done) > >(true) &
STDINPID="$!"
WRITER="/proc/$STDINPID/fd/1"
while IFS= read -r LINE; do
# only echo lines if we didn't close the connection yet
if [ -e "$CHECKFDPATH" ]; then
echo "$LINE" | tr '[:lower:]' '[:upper:]' > "$WRITER"
if [ "$LINE" = "bye" ]; then
exec {checkfd}<&-
fi
else
echo "received while closed: $LINE"
fi
done < <(nc -q 1 -l 8080 < "$WRITER")
if [ -e "$CHECKFDPATH" ]; then
# close checkfd to close writer pipe
exec {checkfd}<&-
fi
The fd will only be used to stor it temporary since, we first need to sent headers, and the headers need to be sent before the bofy. The server base os working fine now with accept and a patch request os already sent to bash. So probaböy on the next release accept will be full usable.
It's also useful for signaling between processes to have them continue doing something as long as this proc path exists (the fd can also just be backed with >/dev/null instead of a real file that needs to be removed)
Normally, the pid and fd could be reused, so you should either make it a known unique path and verify it's still the same, lock the pid via some means (not sure if and how it's possible), or use another technique.
If they are making false claims about you that cause serious damage to your reputation (like telling the FBI you look like a terrorist), then sue them for libel.
Wouldn't you have to prove you don't look like a terrorist?
Clearview is probably saying that if you convert an image, or set of images, of a person to vector(s) then there are some similar vectors that are associated with a terrorist. If they are saying it, it's because it's probably true in their implementation.
I probably do look like a terrorist somewhere. The problem isn't identifying that person and associating them with me, the problem is treating that information as significant, and that's on the FBI (in your hypothetical scenario).
> "What due diligence and groundwork have you done to prove that they are in fact a terrorist?"
The solution is to make this question their (Clearview) problem. If you are offering a service that makes damaging claims about people, then you need to be liable for any related damages if that claim is later found to be slander/libel.
The risk of a potentially huge ruling/settlement will be handled the same way it is handled in other professions: by paying for liability/malpractice insurance. Eventually, the insurance companies will handle the question of due diligence.
Unless you make a new liability law that is pretty specific to this use case, I don't think it's very possible to make slander/libel damages for it, especially considering the US's 1st amendment laws.
Clear view probably today says "I think this is %90 likely to be person X, but I could be wrong" in their UI. That turns it into opinion.
Also, after scrolling up, there is a 'settings' button (gear icon). Along with various options (including alternative shaders!), at the top there are 8 empty circles that are worth investigating...
I'm trying to avoid spoilers, so I'm obfuscating more specific hints:
# A good first step (very mild spoiler)
echo Q2hlY2sgdGhlIGNvbnNvbGUhCg== | base64 -d
# A direct hint about where to look
echo RmluZCB0aGUgaGlkZGVuIGFjaGlldmVtZW50cygpCg== | base64 -d
# A very spoilery JS statement that has side effects
echo YWNoaWV2ZW1lbnQoJ2NodHInKQo= | base64 -d
The technical benefits are nice, but this type of ergonomic feature is why ruby has remained my favorite language for over a decade.