glenjamin

Docker layer caching is complicated!

CircleCI has an implementation that used to use a detachable disk, but that had issues with concurrency

It’s since been replaced with an approach that uses a docker plugin under the hood to store layers in object storage

https://circleci.com/docs/docker-layer-caching/

I have to disagree with this.

Yes existing terms have meaning, but they also have baggage.

Forming a new term is a reasonably effective way to shed that baggage and attempt to start the cycle all over again.

Seeing a term you’re not as familiar with and needing to look up the definition (whether that’s a local or a global definition) is usually a good thing IME.

> Is this a real problem? If there's a function signature that accepts `Operation`, the caller must explicitly cast the `int` to `Operation`. At that point, it's the caller's own fault.

You would think that, but that isn't always the case: https://play.golang.com/p/Ze3pfNEVTVs

It's very easy to create an enum value that isn't actually in the defined range

If you're producing more than a full-time colleague, does the 50% pay cut seem a bit harsh?

A sales team gets measured on the sales they make - but they don't own the end to end process of building the thing that they're selling.

It's entirely possible to measure teams on business outcomes without having them own things end-to-end, but to be really effective in this they'll need to collaborate with the other teams across the company - which is generally a desirable outcome.

Are you suggesting that the macroeconomic environment in terms of funding and performance expectations of startups hasn't changed signficantly in the last few years?

VC-money and ZIRP is a convenient shorthand for what's changed, neither are terms I think particularly encapsulate what did change, but I think it's very hard to argue that it's still just as easy to get a bunch of funding without a business model. (aside from in AI perhaps?)

In my opinion the best antidote to overly complex architectures is to have engineering teams and the engineers in them be rewarded based on actual business outcomes.

I suspect the era of VC-money and ZIRP led to a large number of engineers who were disconnected from successful long-term business outcomes, so there was no incentive to simplify.

Am I missing something?

Couldn’t they allow you open PWAs in Safari, or fall back to opening a URL in another browser?

Is there some part of the DMA which demands full feature parity?

Personally I’d have separated finding the Author line from pulling out the contents of that line - but still used Regex

it's also worth noting that even on the same platform, compiling with CGO enabled creates a dynamic link against `glibc`, which creates a dependency on having the matching version in your deployment target.

We ran into this recently as our CI system is running a newer OS than we currently deploy to - and disabling CGO was an easy way to sidestep this requirement

I once attended an internal presentation while working for the UK's Ministry of Justice.

A large number of contraband mobile phones had been confiscated, and a team performed some data analysis to see what they'd been used for.

The overwhelming conclusion was that the phones had been primarily used to keen in touch with family.

There's also a whole bunch of research that showed that maintaining ties with the outside world while incarcerated led to reduced rates of reoffending (and the inverse was also true - isolation led to increased rates).

Allowing free phone calls in and out of prisons makes a lot of sense both socially and economically.

Obligatory: "What do you mean I'm not supposed to use Pie Charts?!" https://www.geckoboard.com/blog/pie-charts/

In the alignment example from the post there’s a missed opportunity to align the components vertically based on their role

The caches should be next to each other, and the servers should be too, leaving the DB up top and the lib between the servers

Although personally I’d also then flip it to put the DB at the bottom so the server becomes the headline, and if one server is public and the other internal, then I’d push the internal one down half a row too

Have you considered going for a walk?

Using only spans is surprisingly effective!

I did a talk about this at QCon London last year

https://www.infoq.com/presentations/event-tracing-monitoring...

Did you read the article?

> The compiler will always support old code written against older editions, but the language can still introduce breaking changes in newer editions. Developers can either opt in to new editions and migrate their code, or do nothing, and things continue to work fine. There is seamless/transparent interoperability.

This is exactly what the GODEBUG scheme described in the article is intended to allow.

The purpose of pair programming and the purpose of code review are not quite the same.

Pair programming is a high-context activity where two programmers collaborate closely on building something.

Code review is a tool to simulate looking at code that you haven't just worked on with high-context, and seeks to assess whether it is understandable to someone in that position. Since code is read far more often than it is written, code review can be a very effective tool for maintaining the long-term health of a code-base when applied in this way.

If you're only monitoring user-facing symptoms, and the application restarts quickly enough to not cause a blip in service, then:

a) It's highly likely that your monitoring is not going to spot an occasionally restarting service

b) It's probably a good choice not to waste cycles on that sort of monitoring

This is a great cautionary tale about what happens if you don’t continuously integrate changes in an incremental fashion.

I used to work at CircleCI. It was often suggested to us that because of the usage-based pricing we were not incentivized to make builds faster.

In reality the opposite was true - experience had shown us that every time builds got faster, people ran more builds (likely because faster feedback means more iterations).

Do you have any plans in ingest trace/span data in future?

The government can also buy things (like infrastructure) and employ people to provide public services, which directly injects money into the economy by paying it to the people who do that work.

The current UK government has not been doing much of this.

Remote work doesn't force you to stay in your house all week.

I work 100% remote with semi-flexible hours and a big part of this is the freedom to leave my house and do things during the day, like meet up with friends, or go exercise while the sun is out in winter etc.

If you think those words are made up, wait until you hear about how we got all of the other ones.

I think the comments on this post would probably less hostile if the title said something like "detect the number of unique visitors", which is what I believe it's doing, rather than detecting unique visitors using unique timestamps, which is what many seem to be guessing based on the headline alone.

There was an excellent talk at Strange Loop a few years ago by Emily Shea about how she'd learnt to code vim using her voice to combat RSI.

https://www.youtube.com/watch?v=YKuRkGkf5HU

The demos are in Ruby, but I could imagine that languages with strong type-aware auto-completion could be easier to do.

Something I think hasn’t been discussed much in these comments is what the alternative would look like, and why that is undesirable.

If you only perform the refactoring after making a change (eg. adding a ticket for cleanup later), then (a) you made it hard to do the change, but also (b) it’s now far less vital to perform the refactoring - as the desired outcome has already been reached.

Refactoring for refactorings sake can be hard to figure out what the goal or end-state is. Making a refactoring in order to facilitate a particular desired change acts as a great forcing function for helping you decide what to change and why.

My mental model of JavaScript is that the name/label “a” in that scope was re-used 3 times, but for a different value each time

For web-style application code my experience writing Go code says that you totally can stop using logs and just use traces and have just as much visibility into a running process, if not more.

For library code or other deployment models I’m not sure - it’s not something I’ve had a need to experiment with

A counter or a timer is clearly no substitute for a log, that would be an absurd statement for me to have made - which is why I said no such thing.

A span as modelled by OpenTelemetry is a a bag of developer-chosen structured data containing a name, a timestamp and some auto-generated IDs to correlate it with others.

It is effectively an open standard for how to collect good structured logs - although it is currently not commonly pitched that way by either tracing advocates or structured logging advocates.

These are commonly used to create trace waterfalls, but can also be used to derive metrics or simple dev-debug output.

I have used this approach myself to great effect, and also spoken to a number of people who have also found success with such an approach - but currently the momentum of existing approaches (and the fact that traditional logging still works well-enough for most people) has not led to wide adoption