Return to Answer

having proper IDE is more relevant than ever

That would actually be a severe misunderstanding of the basic norms of sanity in modern software development.

Modern projects utterly rely on the ability to have an automated build server which uses command-line type script tooling (itself maintained under version control) to automatically perform builds. Even if no testing of the build result is done (as it really should be), simply verifying that the build can still be done after the latest round of changes is key. In a sanely run project, the IDE is never the official build method, only a shortcut developers use to make initial builds for debugging - releases and their candidates always come from the build server.

If your project is properly configured such that it can be built by a build server (and it sounds like your co-worker's personal build tooling is precisely what would be needed for that), then no, it doesn't matter one bit what your co-worker uses to edit the code.

Concentrate instead on what does actually matter:

• Uniform code formatting, because it reduces commit noise. But you should have tooling which can do or check this outside of your personally preferred IDE, because such check should be part of your automated validation flow

• Code standards - you've rightly expressed concern here, but that's a subject for guidelines and reviews, not an IDE feature

• Selected languages - if your project wants python instead of perl, that's as much a political decision as a technical one, but unlike the IDE dispute, commonality actually matters and is worth arguing about.

So, separate your preferences from your needs, review the degree to which your own expectations are out of step with industry norms and then pick your battles accordingly. If code doesn't meet standards, it fails review. If perl isn't an allowed project language, a commit that adds some fails review, etc.

When the asker has separated out and and ceased insisting on getting their way in the areas where they are actually the one creating the "problem", and is left with only the actual problems created by their co-worker, they'll be in a much better position to obtain actual change in those remaining areas, and can point to the previous requests which they have now dropped as evidence of a willingness to find a technically sound compromise.

You'll have the most luck persuading your co-worker to recognize their contributions to the collective problem, when you start by recognizing your own.

Case in point:

having proper IDE is more relevant than ever

That would actually be a severe misunderstanding of the basic norms of sanity in modern software development.

Modern projects utterly rely on the ability to have an automated build server which uses command-line type script tooling (itself maintained under version control) to automatically perform builds. Even if no testing of the build result is done (as it really should be), simply verifying that the build can still be done after the latest round of changes is key. In a sanely run project, the IDE is never the official build method, only a shortcut developers use to make initial builds for debugging - releases and their candidates always come from the build server.

If your project is properly configured such that it can be built by a build server (and it sounds like your co-worker's personal build tooling is precisely what would be needed for that), then no, it doesn't matter one bit what your co-worker uses to edit the code.

Once you followed your co-worker's lead in using sound build tooling which makes the IDE dispute irrelevant, you can concentrate instead on finding a compromise resolution in areas which actually do matter, for example:

• Uniform code formatting, because it reduces commit noise. But you should have tooling which can do or check this outside of your personally preferred IDE, because such check should be part of your automated validation flow

• Standards for code style and organization - you've rightly expressed concern here, but that's a subject for guidelines and reviews, not an IDE feature. And it's not an axiomatic given that your preferences are technically best.

• Selected languages - if your project wants python instead of perl, that's as much a political decision as a technical one, but unlike the IDE dispute, commonality actually matters and is worth debating to an agreeable and technically sound group decision.

So, separate your preferences from your needs, review the degree to which your own expectations are out of step with industry norms and then pick your battles accordingly. If code doesn't meet standards, it fails review. If perl isn't an allowed project language, a commit that adds some fails review, etc.

When the asker has separated out and and ceased insisting on getting their way in the areas where they are actually the one creating the "problem", and is left with only the actual problems created by their co-worker, they'll be in a much better position to obtain actual change in those remaining areas, and can point to the previous requests which they have now dropped as evidence of a willingness to find a technically sound compromise.

having proper IDE is more relevant than ever

That would actually be a severe misunderstanding of the basic norms of sanity in modern software development.

Modern projects utterly rely on the ability to have an automated build server which uses command-line type script tooling (itself maintained under version control) to automatically perform builds. Even if no testing of the build result is done (as it really should be), simply verifying that the build can still be done after the latest round of changes is key. In a sanely run project, the IDE is never the official build method, only a shortcut developers use to make initial builds for debugging - releases and their candidates always come from the build server.

If your project is properly configured such that it can be built by a build server, then no, it doesn't matter one bit what your co-worker uses to edit the code.

Concentrate instead on what does actually matter:

• Uniform code formatting, because it reduces commit noise. But you should have tooling which can do or check this outside of your personally preferred IDE, because such check should be part of your automated validation flow

• Code standards - you've rightly expressed concern here, but that's a subject for guidelines and reviews, not an IDE feature

• Selected languages - if your project wants python instead of perl, that's as much a political decision as a technical one, but unlike the IDE dispute, commonality actually matters and is worth arguing about.

So, separate your preferences from your needs, review the degree to which your own expectations are out of step with industry norms and then pick your battles accordingly. If code doesn't meet standards, it fails review. If perl isn't an allowed project language, a commit that adds some fails review, etc.

When the asker has separated out and and ceased insisting on getting their way in the areas where they are actually the one creating the "problem", and is left with only the actual problems created by their co-worker, they'll be in a much better position to obtain actual change in those remaining areas, and can point to the previous requests which they have now dropped as evidence of a willingness to find a technically sound compromise.

having proper IDE is more relevant than ever

That would actually be a severe misunderstanding of the basic norms of sanity in modern software development.

Modern projects utterly rely on the ability to have an automated build server which uses command-line type script tooling (itself maintained under version control) to automatically perform builds. Even if no testing of the build result is done (as it really should be), simply verifying that the build can still be done after the latest round of changes is key. In a sanely run project, the IDE is never the official build method, only a shortcut developers use to make initial builds for debugging - releases and their candidates always come from the build server.

If your project is properly configured such that it can be built by a build server (and it sounds like your co-worker's personal build tooling is precisely what would be needed for that), then no, it doesn't matter one bit what your co-worker uses to edit the code.

Concentrate instead on what does actually matter:

• Uniform code formatting, because it reduces commit noise. But you should have tooling which can do or check this outside of your personally preferred IDE, because such check should be part of your automated validation flow

• Code standards - you've rightly expressed concern here, but that's a subject for guidelines and reviews, not an IDE feature

• Selected languages - if your project wants python instead of perl, that's as much a political decision as a technical one, but unlike the IDE dispute, commonality actually matters and is worth arguing about.

So, separate your preferences from your needs, review the degree to which your own expectations are out of step with industry norms and then pick your battles accordingly. If code doesn't meet standards, it fails review. If perl isn't an allowed project language, a commit that adds some fails review, etc.

When the asker has separated out and and ceased insisting on getting their way in the areas where they are actually the one creating the "problem", and is left with only the actual problems created by their co-worker, they'll be in a much better position to obtain actual change in those remaining areas, and can point to the previous requests which they have now dropped as evidence of a willingness to find a technically sound compromise.

having proper IDE is more relevant than ever

That would actually be a severe misunderstanding of the basic norms of sanity in modern software development.

Modern projects utterly rely on the ability to have an automated build server which uses command-line type script tooling (itself maintained under version control) to automatically perform builds. Even if no testing of the build result is done (as it really should be), simply verifying that the build can still be done after the latest round of changes is key. In a sanely run project, the IDE is never the official build method, only a shortcut developers use to make initial builds for debugging - releases and their candidates always come from the build server.

If your project is properly configured such that it can be built by a build server, then no, it doesn't matter one bit what your co-worker uses to edit the code.

Concentrate instead on what does actually matter:

• Uniform code formatting, because it reduces commit noise. But you should have tooling which can do or check this outside of your personally preferred IDE, because such check should be part of your automated validation flow

• Code standards - you've rightly expressed concern here, but that's a subject for guidelines and reviews, not an IDE feature

• Selected languages - if your project wants python instead of perl, that's as much a political decision as a technical one, but unlike the IDE dispute, commonality actually matters and is worth arguing about.

So, separate your preferences from your needs, review the degree to which your own expectations are out of step with industry norms and then pick your battles accordingly. If code doesn't meet standards, it fails review. If perl isn't an allowed project language, a commit that adds some fails review, etc.

having proper IDE is more relevant than ever

That would actually be a severe misunderstanding of the basic norms of sanity in modern software development.

Modern projects utterly rely on the ability to have an automated build server which uses command-line type script tooling (itself maintained under version control) to automatically perform builds. Even if no testing of the build result is done (as it really should be), simply verifying that the build can still be done after the latest round of changes is key. In a sanely run project, the IDE is never the official build method, only a shortcut developers use to make initial builds for debugging - releases and their candidates always come from the build server.

If your project is properly configured such that it can be built by a build server, then no, it doesn't matter one bit what your co-worker uses to edit the code.

Concentrate instead on what does actually matter:

• Uniform code formatting, because it reduces commit noise. But you should have tooling which can do or check this outside of your personally preferred IDE, because such check should be part of your automated validation flow

• Code standards - you've rightly expressed concern here, but that's a subject for guidelines and reviews, not an IDE feature

• Selected languages - if your project wants python instead of perl, that's as much a political decision as a technical one, but unlike the IDE dispute, commonality actually matters and is worth arguing about.

So, separate your preferences from your needs, review the degree to which your own expectations are out of step with industry norms and then pick your battles accordingly. If code doesn't meet standards, it fails review. If perl isn't an allowed project language, a commit that adds some fails review, etc.

When the asker has separated out and and ceased insisting on getting their way in the areas where they are actually the one creating the "problem", and is left with only the actual problems created by their co-worker, they'll be in a much better position to obtain actual change in those remaining areas, and can point to the previous requests which they have now dropped as evidence of a willingness to find a technically sound compromise.