How do you improve code quality and reduce the number of bugs in software without improving the quality of programmers...

How do you improve code quality and reduce the number of bugs in software without improving the quality of programmers? Is the answer to use intuitive, simple, highly abstract languages like Python so that programmers will make less mistakes? Or is it to switch the dominant programming paradigm from OOP to FP?

Attached: d45edf253fdade604665fb3691806a349d750bfa.jpg (771x1230, 458K)

increase the number of female programmers. women are intrinsically better than men at everything and by promoting women in tech the number of bugs will go to zero.

by enforce strict architectural rules

The premise is wrong.
As you gain experience, you become a better programmer.
Refactoring once you thoroughly know the codebase and its limitations will result in less possibilities for bugs by reducing mental overhead due to an optimized layout.

If braces can't be detected soon enough, (compile time), it's obvious that you could end in a quagmire before you can act. Expressive type systems are the future of software engineering.

*breaches

Abstract languages don't necessarily reduce bugs, just hide them. Really the answer is what said, you have to learn to write good code before you can start writing good code. FP might be useful in reducing some types of bugs but it isnt a paradigm you can use everywhere.

TDD

Higher level languages reduce bugs at the same rate for everybody, not strictly bad programmers. So shit programmers will still be shit comparatively to good programmers whether they use C or Python.
My pet theory is that enforcing TDD would result in bad programmers writing less bugs because writing testable code directly forces you to write code that's generally of higher quality but my experience is that bad programmers don't do TDD because they don't give a fuck and I've never worked at a place where TDD was enforced so I can only guess.

Enforcing TDD would reduce bugs to some extent but the problem you run into is pajeets who write tests so that their code passes, not the other way around. Really the tests have to be hidden from the programmer writing the critical code but that system leads to a problem of "Who the fuck can write perfect tests." It end up being a nightmare, so alot of places just skip on it and give up the benefits.

TDD induces shit architecture. You should have tests covering close to 100% of the code, but don't write them before.

Use a safe, garbage collected language, such as Kotlin, enforce modularity through architecture and have rigid code conventions.

I don't care about the religious shit of writing tests before the implementation, I always do it afterwards but I'll have to refactor if I realize testing is too much of a pain so the benefits are the same. Maybe that's my bad for saying TDD, what I really meant was writing unit tests for any file that contains a minimum of logic.

what do you smell first Jow Forums?

Forcing them with a knife to their throat to write unit tests.

Attached: e65.gif (500x280, 887K)

God I want to reproduce with her

how about you stop being a fucking pussy with slow fingers?

Attached: tdd.png (611x381, 192K)

But where will you get enough trannies to meet the demand?
Biological females are completely useless for programming, so it's all up to transwomen.

switching to fp will reduce the number of programmers maybe 20 times, the only solution is to use new and existing retard languages that allow bugs to be present in a program and still run to some degree and produce somewhat accurate results, also improving code quality can also mean reducing the standards of code quality so existing code will automatically become better

>less mistakes
You should start with being white and not being indian

god i wish that were me

Python is so simple we'll soon be able to automate the work of people who can only write in it with AI. More widespread use of FP would help, But OOP has its niche as well. The trouble with OOP up to now has been with zealots trying to force its use with everything. The key takeaway should be the more shared mutable state you have, the more problems you have.

Regardless of that, the biggest problem in IT is proper allocation of talent. I've seen top tier developers doing some real menial (even if well paid jobs). Some big tech firms hoard developers even if they don't need them to prevent their competitors getting access

Based and pinkpilled

Attached: b10ef49df8468d69377e0f63e9d85538.jpg (1280x986, 99K)