I've often thought that micro-services were more of a software engineering management solution rather than a technical one.
From the perspective of a high-level architect it makes delegating certain types of responsibility a bit easier and potentially reduces the need for communication between teams while maintaining centralized control of the overall system.
However, it always seems to come with such a high overhead that IMHO it's almost never worth doing unless there really isn't another option.
Looking through the pricing page I'm not sure what sort of workload this would make sense for. Just looking at the examples from the pricing page I think I'm getting sticker shock.
Example 1
> For example, your service uses 1 ECS Task, running for 10 minutes (600 seconds) every day for a month (30 days) where each ECS Task uses 1 vCPU and 2GB memory.
> Total vCPU charges = 1 x 1 x 0.00084333 x 600 x 30 = $15.18
> Total memory charges = 1 x 2 x 0.00021167 x 600 x 30 = $7.62
> Monthly Fargate compute charges = $15.18 + $7.62 = $22.80
So the total cost for 5 hours of running time is $22.80? Am I even reading this correctly? If so, what would this be cost effective for?
I think they mislabeled the pricing. If you look at the per-hour pricing ($0.0506/CPU-hour and $0.0127/GB-hour), that translates to $0.00084333 and $0.00021167 per minute, which is a pretty reasonable price. This also makes sense in light of their recent announcement of per-minute EC2 billing.
For large code bases in dynamic languages I think the advantage grows larger over time. Even a modest amount of test coverage will allow you to build new features without breaking existing features.
It's a lot faster to catch bugs when the tests run in your local development environment or in the CI pipeline than to wait until Q/A (hopefully) catches them in end-to-end integration testing and sends it back to you for rework.
The other advantage I've noticed is that the tests can serve as an additional form of documentation. New team members can look through the tests to see how code is supposed to work from the examples there. For some web API projects I've even been able to generate the documentation from the test cases.
Yup, agree. Depending if you are working with a good static type system or with a dynamic language the value of unit tests can vary.
When working with dynamic languages I always end up writing a bunch of unit tests and a bunch of integration tests. I've experimented some with type hinting and static analysis in some dynamic languages but it's not the same as having the compiler make guarantees.
If you want to create a large number of Objects (like for rows in a data set) using __slots__ saves a lot of memory over just using the standard __dict__. I've always used named tuples for this in the past, but this is a nice way to do it.
I think being born white, male, and good at math at this particular time in history is the very definition of luck. I'm definitely playing the game of life on "easy" mode.
That being said I think there is a minimum level of effort, intelligence, and resilience required to take advantage of certain lucky opportunities if they present themselves. When I look at how much some of my peers had to endure and overcome to reach those minimums compared to what I had to do, it's easy to see how lucky I've been.
> That being said I think there is a minimum level of effort, intelligence, and resilience required to take advantage of certain lucky opportunities if they present themselves.
Lucky you for having been born with willpower and smarts, then.
White people descended from Europeans are the seventh most successful ethic group in this country. The "luckiest" are Indian Americans, they beat Jewish Americans nearly 10k a year.
From the perspective of a high-level architect it makes delegating certain types of responsibility a bit easier and potentially reduces the need for communication between teams while maintaining centralized control of the overall system.
However, it always seems to come with such a high overhead that IMHO it's almost never worth doing unless there really isn't another option.