If you use your own Docker images, you lose one of the main benefits of Lambda, which is that AWS will take care of automatically patching all the security vulnerabilities in the infrastructure platform. My goal is always to outsource as much of the code as possible to AWS, and implement myself as little as possible.
In my view, the big promise of server-side WASM is to have an evergreen platform that doesn't need regular updates to the application. Just like HTML web pages work "forever" in browsers, WASM-based applications could work forever on the server-side.
Currently it is a huge PITA to have to update and redeploy your AWS Lambda apps whenever a Node.js or Python version is deprecated. Of course, usually the old code "just works" in the new runtime version, but I don't want to have to worry about it every few years. I think applications should work forever if you want them to, and WASM combined with serverless like Lambda will provide the right kind of platform for that.
I read the first volume a long time ago and enjoyed the view into how these open source projects have been designed, and what "architecture" actually means in their context. I think sometimes it's about making them easy to extend from the outside (with add-ons and configuration files), and sometimes it's about minimizing the effort needed to extend them from the inside (by adding and refactoring code).
I was just stating what the difference is to a closed market environment like Second Life. Whether it's good or bad is another matter. In my view experimentation is good. I would assume that nobody can control your in-game assets arbitrarily unless you grant them permission via some contract.
To my understanding, Second Life has always centrally controlled the currency (Linden dollar) and the purchase transactions of land and objects. So it hasn't been possible for players to create their own marketplaces, exchanges, tokens, etc. where trading would happen independently and peer-to-peer.
For me, it's just the opposite. I enjoy my work very much and like to work very intensively for 30 hours, usually at least 10 hours per day, and deliver lots of value. Then take a long break, spending time with family and hobby projects.
But we tend to forget all the outages we had while self-hosting datacenters and servers before 2010 ;-) Of course, times also changed since early days, so that it is more and more important to be up 24/7.
In my view, this is why cloud exists. You can externalize as much of your software stack as possible to the cloud platform, and only implement and maintain yourself the parts that differentiate. On AWS, this means using Lambda, Step Functions, AppSync, API Gateway, DynamoDB etc. and letting the cloud provider worry about maintaining most of the technology stack.
I would say the opposite. Surprisingly many games still require Windows, at least on Steam. I can sometimes find something interesting that runs on a Linux too, but all the indie games are usually Windows only.
Brushing teeth is a good example of activity where you use almost zero cognitive effort, because the daily routine is so automated. That's why it's so easy to forget to buy more toothpaste - you just don't think about it at all. I completely get the sentinel idea as a trigger that turns your brain back on. It's probably not just the different packaging, but also the different taste, that keeps reminding about it until you buy more of the usual stuff.
It would be very inconvenient to try to synchronize global gitignore settings to all my computers and development environments. When .gitignore files are part of the project, they are automatically distributed everywhere where they are needed.
I think it's important to understand that supporting dark mode by default makes websites work properly also in situations where you are not logged in, or you aren't using your regular web browser with all its customizations and extensions installed.
Very disappointing. CodeCommit had value in its APIs for managing and accessing Git repositories programmatically e.g. from Lambda functions. I've used it to implement simple, Git-compatible version control in some projects by calling the PutFile API. Now it will be much more complicated to achieve something similar.
Article resonates with me a lot. I've worked on countless projects where I put a lot of effort in designing things cleanly and correctly, only to find out afterwards that it wasn't really necessary. In many cases they were R&D projects that might have turned into concrete products but didn't. It's hard to design software systems and architectures in such a way that perfection is added incrementally as needed. But I think it's in the core of being productive.
Being used to automatic instant login with 1Password on most websites, forced magic email links are very frustrating. They make you switch windows, wait for the email to arrive, sometimes look for it in the spam folder, and finally also leave an unnecesary browser tab open. In my view, you should always offer a username/password/totp or at least passkey alternative.
I never use null in Javascript, because I don't want attributes of type null, I just want attributes to either be present or not. This usually simplifies all designs and there is no need to think about null separately; it's treated in code an invalid value for an attribute.
The remaining caveat is that when serializing an object, attributes of type undefined need to be skipped, and some libraries get that wrong. So sometimes it is necessary to delete them from objects before serialization.
So in my view, things would be better if null didn't exist at all and if assigning an undefined value to an object attribute would actually delete the attribute from the object. Of course the language can't be changed now, but that is the philosophy I try to use in code design.
I do realize there is the use case of passing an update object e.g. with HTTP PUT/PATCH and wanting to make a distinction between "don't update an attribute" and "remove an attribute". In that case, null kind of makes sense as a designator to remove an attribute.
I am of similar age and I've been betting on a combination of broad experience and productivity. Knowing basics of everything, but being really good at one thing (atm AWS and serverless), and applying latest productivity techniques to get things done efficiently (atm GitHub Copilot, ChatGPT, etc). So far I've had lots of work available.
I'm expecting that the "really good at one thing" will change in the upcoming decades, and that you need to be early in learning it to stay relevant. I put some effort in learning decentralized Web3 in case that would be the big thing, but currently it's not it. Trying to keep eyes open for what AI brings up next.
Lack of automatic dark mode support on websites is very annoying at night, when you've turned dark mode on and everything else is dark, except that one website you just opened, and it now hurts your eyes or bothers other people in the bedroom.
Back when cloud computing was mostly for early adopters, I used to work on many customer projects at the same time, or in quick succession, in an architect/developer role. It was great as long as the projects worked out as planned and I could deliver a working system in a few weeks or months and move on to the next project. It was easy to become a little overconfident until I faced unexpected difficulties in some projects and the tight schedules started to fall apart.
For instance, I learned that you should never trust what a customer says about reusing their existing code without actually looking at the code first. You can end up having to rewrite the code, and then have a dissatisfied customer, because the new code doesn't have the same problems as the old code and produces different results. It doesn't matter which one is correct, since the old code was already used for years and everything is based on it.
So the humbling experience has been not to become too optimistic and overconfident after some successful projects. You will become the bad guy if you over-promise and can't deliver, even if you feel someone else is actually to blame. Every time you start something new, you have to check for yourself what the requirements and conditions truly are before accepting a deadline. And you can never trust the documentation or description of an existing system without also looking at the actual system.
That's a good point, only very small data is cheaper in DynamoDB than S3. Also adding global secondary indexes tends to add cost, since writes are charged for each of them.
Interestingly, DynamoDB is cheaper than S3 though, compared by number of requests. DynamoDB costs $1.25 per million write request units and $0.25 per million read request units. While S3 is $5 per million PUT requests and $0.4 per million GET requests.
I think the main difference between WASM and JVM is that WASM was designed as a generic compilation target for all kinds of existing languages like C or Swift, while JVM is designed to specifically run Java bytecode with the features that Java-based languages support.
It's a nice number to advertise, but AWS really should make all CloudFormation deployments much faster. There's no reason why updating the code of a single Lambda function should take 30s or even several minutes. It should happen in less than a second, the time it actually takes to call the Lambda API. In general it is way too slow to update a big CloudFormation project comprising many stacks, when only a small portion of the resources are actually changed. This slows down development of CDK based projects for no good reason.
I think the usual part of AWS IAM is simple. You develop your app, it uses a Lambda role or an ECS task role, and you keep adding permissions to the role as needed. When you query a new table in DynamoDB, your app won't work until you add the missing permission. You always add those permissions to the CDK/CloudFormation definition of the role, so that the role works in any AWS account the app is deployed to. CDK actually handles most of this automatically, as you define the relationships between your cloud resources.
The more complicated stuff starts happening when you have many services that need to access each other's resources directly. Then you need to think a bit more about the architecture and how you expose resource names, managed policies and roles between services. It's no longer just simple role definitions within the CloudFormation stack, but you have to pass around account identifiers, regions and resource ARNs in the configuration.
This is not about crypto mining per se, but the electricity used:
> Impose a new 30 percent excise tax on electricity costs associated with digital asset mining
Seems like an effective incentive to migrate cryptocurrencies from Proof-of-Work to the more eco-friendly Proof-of-Stake. Ethereum already did this two years ago.