Most companies where I worked have a history of rebuilding their applications every 3 to 5 years, some even 2 years. This has extremely high costs, it has a major impact on how successful the application is, and therefore how successful the company is, besides being extremely frustrating for developers to work with a messy code base, and making them want to leave the company. A serious company, with a long-term vision, cannot afford any of it, not the financial loss, not the time loss, not the reputation loss, not the client loss, not the talent loss.

From these considerations, I hope the reader will un-derstand that in a way I never " s t a r t " writing on a project;I am writing continuously, either in a more personal vein,in the files, in taking notes after browsing, or in moreguided endeavors

Now let’s consider an alternative situation: the BSCU Autobrake provides two separate discrete control actions to Start Braking andto Stop Braking

Coordination: More environments require more coordination. Teams need to track which feature is deployed to which environment. Bugs need to be associated with environments. Every environment represents a particular ‘state’ of the codebase, and this has to be tracked somewhere to make sure that customers & stakeholders are seeing the right things;

GitOps doesn’t provide a solution to propagating changes from one stage to the next one. We recommend using only a single environment and avoid stage propagation altogether. But if you need multiple stages (e.g., DEV, QA, PROD, etc.) with an environment for each, you need to handle the propagation outside of the GitOps scope, for example by some CI/CD pipeline.

were (or were not) solved

If we renamed things more often, then it probably wouldn’t be so hard to name them in the first place.

Keep in mind that as a software developer, of any degree, learning is continuous. New technologies, new ways to write code, not so new approaches, persisting patterns. Read books, watch online courses, follow tutorials, keep learning!

Got a bit sidetracked into refactoring the Element visitor code, so haven't actually started on the event handler stuff per se, but that'll come soon. Element stuff is starting to feel a bit more logical and easier to follow.

It is important to notice that if you are planning on making your application a PWA, you don’t have to rewrite all the logic.

Third, you can create value in any span of time. If we see our work as creating these intermediate packets, we can find ways to create value in any span of time, no matter how short. Productivity becomes a game of matching each available block of time (or state of mind, or mood, or energy level) with a corresponding packet that is perfectly suited to it.

Second, you have more frequent opportunities to get feedback. Instead of spending weeks hammering away in isolation, only to discover that you made some mistaken assumptions, you can get feedback at each intermediate stage. You become more adaptable and more accountable, because you are performing your work in public.

But maybe this PR should still be merged until he finds time for that?

You are not sure which path to take between the big re-write or continuous improvements(using refactoring)

Have adopted CI best practices and are defining their CI/CD pipelines as code

It is often assumed that if we want to deploy software more frequently, we must accept lower levels of stability and reliability in our systems. In fact, peer-reviewed research shows that this is not the case—high performance teams consistently deliver services faster and more reliably than their low performing competition.

GitLab CI/CD

It involves continuously building, testing, and deploying code changes at every small iteration, reducing the chance of developing new code based on bugged or failed previous versions.

What a lot of people don't realize is that a source control system is a communication tool. It allows Scarlett to see what other people on the team are doing. With frequent integrations, not just is she alerted right away when there are conflicts, she's also more aware of what everyone is up to, and how the codebase is evolving. We're less like individuals hacking away independently and more like a team working together.

We check in our code at the entry point of a pipeline, version control (Git and Github in our case), and then it’s taken through a series of steps aimed at assuring quality and lowering risk of releases. Automation helps us keep these steps out of our way while maintaining control through fast feedback loops (context-switching is our enemy). If any step of the pipeline breaks (or fails) we want to be alerted in our communication channel of choice (in our case Slack), and it needs to happen as quickly as possible while we’re in the right context.

Never compile the same project twice Nix allows to easily share build results across machines. If the CI has built the project, developers or servers can download the build results instead of re-building the same thing.

2.1.8 Automatic data frame discretization

Valdomiro Bilharvas - Squads mais eficientes com Devops

João Brito - CI/CD - Pense um pouco além das ferramentas

Implementando CI com GitLab

the explicit nature of future improved systems would be highly affected by (expected) changes in our technology or in our understanding of the human being

evaluating the possible relevance of work and knowledge from existing fields and for assimilating whatever is relevant

giving the human the minute-by-minute services of a digital computer equipped with computer-driven cathode-ray-tube display, and (2) developing the new methods of thinking and working that allow the human to capitalize upon the computer's help.

that any one such improvement can be expected to trigger a chain of coordinating improvements

since its purpose is neither resolution nor stasis but continuing process.

permafrost