3,478 karma · joined June 22, 2010
> (66) [...] Exceptions to the obligation to provide information and offer the right to refuse should be limited to those situations where the technical storage or access is strictly necessary for the legitimate purpose of enabling the use of a specific service explicitly requested by the subscriber or user. Where it is technically possible and effective, in accordance with the relevant provisions of Directive 95/46/EC, the user’s consent to processing may be expressed by using the appropriate settings of a browser or other application. [...]
Hence, so long as the use of cookies or similar is strictly necessary for the specific service requested by the user, a website doesn't have the obligation to obtain their permission.
[1] https://edps.europa.eu/sites/default/files/publication/dir_2...
1. Your decision makers recognized that the important number to pursue is "engaged users", not "number of emails in the list".
2. You have a large enough subscriber base so that Gmail/Outlook realize you're a good player. This wouldn't happen if you only sent a few thousand mails per week.
3. You have the technical expertise to properly maintain the list and the surrounding (unsubscribe, etc.) infrastructure. Usually the budget is allocated to _create_ the list/service and then assumed that it will continue working forever with 0 investment.
IF you can get these things right too you'll (eventually) have a similar experience. If you fail on any of them... you're screwed like everyone else is saying. Of course, having to send large volumes of email to ensure that "the big guys" treat you fairly is why many people running small/personal email servers complains about them.
GPT got confused at some point and tried to play illegal moves, but then it seemed to regain the games' thread. He never finished the game because he hit the usage limit, but it was already won by Hikaru. The explanations ChatGPT gave in the opening were fine, but the ones for the mid-game were mostly nonsensical.
Says who? 2/3 of amercians live paycheck-to-paycheck [1]. The only thing that a banking system has to provide them is day-to-day operations plus a small cushion (much smaller than 250k).
For that people accumulating over 250k is a privilege, one thay may as well come with the risk of getting it wiped out in very rare events such as this one.
[1] https://www.prnewswire.com/news-releases/23-of-the-us-popula...
> yet tons of people think this is "socializing losses and privatizing gains."
Think about the 2/3rds of americans above. Why shouldn't they think that?
According to [1] 14.5% of all EU workers are self-employed (i.e.: they have their own business, as small as it may be) whereas only 6.6% are in the USA.
Your reasoning is acknowledged in those links, and then they explain that this narrative sounds good but the data proves it wrong.
Some things really are mind boggling :)
> The past two years have not been as rosy for Amazon’s stock price. It fell 2.3% in 2021 and a whopping 49.5% last year.
This explains the headline. I guess that the figures depend on the specific dates you pick?
I'd say that over 99.999% of the people who saw that message, created memes about it, etc.. did not have a corporate credit card and the power to use it at their discretion. If you want money from corps, THOSE are the guys you need to find and ask money from.
However, there is still a line that, when crossed, turns you into a regular old spammer. You are walking _very_ close to that line.
The Valhalla platform was "launched" 2 months ago. Even today there's ZERO public technical documentation on it. You can only find a bunch of marketing slides, SEO-ridden blog posts etc. saying that it's great, plus a video showing a few queries against a regular GraphQL server.
Please stop pretending that this quasi-vaporware platform is the best thing since french fries. Thanks.
This sounds ridiculous to me. The "powerful build and content orchestration tooling" of Gatsby Inc. is basically the same stuff that everyone else is doing in this space. This includes:
- The traditional Gatsby competitors (Vercel, GH Pages).
- Heroku, Fly.io and similar.
- Cloud-specific options such as AWS Amplify.
Of course, this means that you'll not just stop, but completely destroy the old container and start a new one (created from the new image). You can get this to happen without service downtime by using the very same techniques that you'd use on any high availability / multi-server enviornment (rolling upgrades, canary deployments, etc.).
If you need to have some files that persist across these upgrades, then you use volumes and/or bind mounts. These allow you to have folders that persist independently of the container's lifecycle. They are typically used to store things like a sqlite database that the container uses, the set of configuration files that you can edit on a per-instance basis, etc.
Finally, there's a big case where you ignore all of the above: when you use containers as a development tool. In that case, particuarly for "interpreted" languages (python, php, ruby, etc.) it becomes extremely useful to bind-mount your pograms' sources inside a development container. You can then develop normally but also change the entire system where your app runs extremely easily. You can also keep different environments (language version, libraries, configuration of all those) for different projects without any change for conflicts between them, etc.
I definitely see the utility, and the cost (6USD/month for the top tier) to "please keep this up" signaling ratio seems pretty good to me. I can see myself subscribing if I played even 10% of some people I know.
Our conclusion was that you absolutely must be on top of things or you'll end up disappointed.
It is very possible that this hasn't ocurred because google has not enforced the same level of privacy-related restrictions that apple has (which reportedly costed facebook ~10 billion dollars [1]).
I'm a strong supporter of device owners being able to do what they please with their devices, but the risks are there and are very real.
[1] https://www.forbes.com/sites/kateoflahertyuk/2021/11/06/appl...
Minio _was_ just files on disk. They don't support that mode anymore since 2022-10-29 (see the big yellow warning box at [1]).
[1] https://min.io/docs/minio/linux/operations/install-deploy-ma...
- Storage is not the hard part of all those proposals. Standard formats and a shared ontology between all players is the actual hard part. Medical records are useless if you can't read them.
- Immutable storage is not hard to do in a centralized fashion and can be made much more efficient. Do blockchain-based systems offer the bandwidth to ingest _all_ medical records produced worldwide? I'd say the required amount of records-per-second would surprise you (as well as the potential size of those records, where some are high resolution scans and stuff like that).
- Usually you _don't_ want immutable records, even when it seems like you do. What happens when you want to advance the formats stored in the blockchain? You can't edit old records (to update them to the new format), so your only options become: create a new blockchain and/or keep the cruft forever.
- Storing anything private via encryption poses problems in many domains: sometimes you want certain third-parties to be able to access that information (e.g.: the hospital should have access to your medical records if you get there unconscious in an ambulance). I've seen no real solution to the kind of issues that arise there.
These are very serious limitations against blockchains _shining_ if you ask me. Of all your proposed use-cases the only one that I can't see hitting those issues is the company registry records one (and maybe that's because I'm not acquainted enough with that domain).
To be clear, I'm not bashing on GTK. I'm saying that it definitely isn't as simple as the above comment implies ;)
Second, splitting a general role ("backend engineering") in arbitrary atomic skills doesn't make sense because there's no end to it. Backend engineering -> OS fundamentals -> Driver programming -> Hardware design -> Boolean logic -> Set theory -> and so on...
Third, all engineering roles have cross-cutting concerns. You do need some network knowledge to be a "backend guy"... but also to be a sysadmin, devops, etc.. It's not like all these roles exist in a vacuum and you're starting from 0 if you switch between them.
Finally, most people that think of themselves as experts in some role, language or framework end up in the "1 year of experience repeated 10 times" trap. True experts are also somewhat generalists too, because you can't built a tall knowledge without growing the base too (pun intended).
[1] https://www.bbc.com/future/article/20121114-gladwells-10000-...
- Do you want to add a header in this "location" block? Great, you better remember to re-apply all the security headers you've defined at a higher level (server block for instance) because of course adding a new header will reset those.
- Oh, you mixed prefix locations with exact location with regex locations. Great, let's see if you can figure out by which location block will a request end up being processed. The docs "clearly" explain what the priority rules for those are and they're easy to grasp [1].
- I see you used a hostname in a proxy_pass directive (e.g.: http://internal.thing.com). Great, I will resolve it at startup and never check again, because this is the most sensible thing to do of course.
- Oh... now you used a variable (e.g.: http://$internal_host). That fundamentally changes things (how?) so I'll respect the DNS's TTL now. Except you'll have to set up a DNS resolver in my config because I refuse to use the system's normal resolver because reasons.
- Here's an `if` directive for the configuration. It sounds extremely useful, doesn't it? Well.. "if is evil" [2] and you should NOT use it. There be dragons, you've been warned.
I could go on... but I think I've proved my point already. Note that these are not complaints, it's just me pointing out that nginx's configuration has its _very_ significant warts too.
[1] https://nginx.org/en/docs/http/ngx_http_core_module.html#loc...
[2] https://www.nginx.com/resources/wiki/start/topics/depth/ifis...
1. Cloudflare has been great at rapidly iterating (compare the timeline between HTTP/3 support in Cloudflare vs Cloudfront... let alone AWS's ALB that still doesn't support it). Introducing hardware accelerators would surely hinder those efforts (ouch, we need Y to do this that the hardware can't do, and the vendor says it'll take 1 year to have new production-ready cards).
2. Cloudflare has been a good upsteram contributor for the projects they depend on (the kernel, the rust language, etc.). Partnering with a hardware vendor inevitably means closed source, deviations from upstream and ultimately a much larger hurdle to be a good citizen to the open-source community.
As you can see, the reasons are entirely selfish. I'd understand it if you do it anyways because the numbers make sense for your company. In the meantime... thanks for holding out until you really can't justify it anymore!
This is one of those things that "everyone knows". It may have been true at some point, but it definitely isn't true anymore. The reality is that most discussons here treat PHP fairly, giving it credit where it deserves it and also pointing out its weaknesses.
Examples:
- (2022) https://news.ycombinator.com/item?id=32325055 : top comment praising PHP
- (2022) https://news.ycombinator.com/item?id=30219984 : the top comment is a fairly positive comment overall, without falling into zealotry.
- (2019) https://news.ycombinator.com/item?id=19917655 : the top comment is someone praising Laravel and the "modern" approach to php. The general feeling is that PHP got some things right (shared-nothing), doesn't offer anything particularly unique but is surprisingly effective in reality.
- That 24% number is for youngsters who would like to work from home 100% of the time.
- Right next to that number the study finds that the "average desired number of days to work from home" is 2.57 in that age bracket.
- The study also finds that there's a significant gap between the desired amount of WFH by employees vs what the employers offer.
Even if we accept the study's findings at face value (though it smells quite biased to me), the findings don't support the headline at all.
https://wfhresearch.com/wp-content/uploads/2022/07/WFHResear...
In case anyone is curious, we went that route.
- ECS + Fargate + CDK took one of us two (8h/day) weeks for the initial setup. We've sprinkled a few more days here and there since then.
- Cloudwatch logs are "setup-free" (your containers' logs get sent there by default when using CDK constructs).
- ACM... we don't use directly. CDK will easily setup TLS-enabled (with AWS-emitted certificates) ALB (Application Load Balancer(s)) for you.
- Lambdas we don't use much.
- Metrics & Alarms are easy to set up but they generally suck. The custom language for computed metrics is clumsy and quite limited. The anomaly detection sucks. And it is expensive even by cloud standards (don't create metrics and alarms willy-nilly or you'll feel it in the next invoice).
- Our application code doesn't know much about AWS (we do use libraries for S3 and SES, but these are just easy to swap adapters).
- We ended up with ~3k lines of CDK definitions in typescript. These are very easy to read, and only moderately hard to write (you do need to look up the docs). However, I can say without a doubt that it's been the easiest infrastructure definition/description language that I've ever used.
I don't have enough experience with K8s to know whether that route would have been better or worse, but I can say this route hasn't been a pain point for us.
The point is that you don't do this. You do:
const App = () => {
// Client-side counter
const [count, setCount] = useState(0);
useEffect(() => {
setTimeout(
() => {setCount(count+1)},
1000
);
}, [count, setCount]);
// HTML-rendering part
return (
<div>Count: {count}</div>
);
}
The framework (next, fresh, whatever) grabs this and generates:- Some sort of "bundle.js" that contains the component (as well as the framework to render it).
- An "index.html" that contains "<div>Count: 0</div>" (and references the above bundle).
- When the "bundle.js" is loaded, it runs the App component in the browser and reconciles the in-memory vdom with the browser's dom (that has the div because it came in the .html)
- From then on, the component runs normally (i.e.: the counter keeps increasing and you see it increase on the screen).
In vanilla-land, you would:
- Write "<div>Count: <span id="count">0</span></div>" in an index.html that also loads a "counter.js"
- Write the counter.js file with something like:
document.addEventListener('ready', () => {
const count = document.getElementById('count');
let value = 0;
setInterval(() => {
count.innerText = value++;
}, 1000);
});
Less code, you don't need frameworks, hydration nor anything similar and it's probably much more performant.However:
- If you want to change the counter's initial value, you have to update both the html and the js file
- If another dev adds some element with id="count" to the html the whole thing breaks.
- If you want to modify the generated html structure, you have to edit both the html and js file
- When the logic gets more complex, you will have to implement it both in your backend-code-that-generates the html as well as in the js
That is, even though it doesn't seem like it in a simple example such as this one, the developer ergonomics of having a vdom are much better when things get hairy. The million dollar question then becomes "how can we achieve a performance and code-size similar to the vanilla approach while keeping the ergonomics of the vdom".
In the jquery aprroach the in-memory model is built straight from what's on the page (the dom). This removes an entire class of problems (there's no mis-synchronization possible) but has its own set of issues (the model you build may not end up being what you expected while coding).
More importantly, "hydration" use implies that the HTML that gets sent to the client is a Server-Side Rendered version generated from the same JS code that runs in the page. The very big advantage here is that there's a single place where the page's content is controlled from (the js/jsx/whatever code) instead of having to manually maintain the html/js relationship by hand like in the jquery case.
Furthermore, the jquery approach is global in nature (you can manually scope jquery-fiddling, but if you make a mistake you may end up modifying stuff elsewhere on the page) whereas this cannot happen in the vdom approach.
In general, the vdom approach makes code more manageable at the cost of runtime performance. That's why many people recommend react and/or other vdom-based frameworks for the complicated cases (lots of dynamic stuff on the page) but vanilla/jquery/etc. when the in-page interactivity is lower.
Today's crop of "frontend frameworks" (such as nextjs, fresh here, etc.) are trying to achieve the benefits of the vdom approach while minimizing its' drawbacks (and full-page hydration is a big drawback because it takes "a lot" of time decreasing the page's Time-To-Interactive metric).