Here is what the positives do not tell you about the clean and developmental start -up code

According to a report issued by the start -up genome, 90 % of startups fail. This sober statistics shows the tremendous challenges of building a successful project. But why is this happening?

For more than 5 years, I worked for an emerging company where I was the first developer. They often ask their acquaintances who worked in multiple companies if it is boring in one place for a long time, but being part of an increasing startup that seems to be working in many companies simultaneously.

Here are some interesting outstanding points from my time there:

• The startup office has moved more than 10 times.
• We were part of the AWS accelerator alongside dozens of other wonderful startups.
• We explored countless techniques, frameworks and technologies along the way.

We have moved from a feature discussion with Сто and immediately launch it to production to PRD from 50 pages with a gradual version of a new feature within a few months.

However, regardless of multiple tasks, dealing with new tasks, and final dates, there are some other vital points that an emerging emerging company must consider.

1. Do not overcome engineering

It is important to remember the startup company to keep its symbol simple and easy to understand. Let me explain this with an example.

We were working on the feature of Mitri and we decided to make it as generally as possible. However, we did not use it in this way. Instead, we complicated the code, making it difficult to keep it in the future.

What does this mean in practice? You must write a code that solves the current problem. It should be simple and easy to understand. However, if you are considering adding another condition, be reviewed. There is a great opportunity because you will not need it.

Here are the steps that you must follow:

• Implementing the current solution.
• Determine restrictions.
• Return to the code only if the changes are necessary.

A principle bearing an attractive name completely picked up this idea: yagni – you will not need it. Do not add additional function unless it is really necessary.

2. Write (truly) a clean symbol and do not exceed checks

We had jobs that were thousands of long lines! Can you imagine the reaction of the developers who saw this for the first time?

It is a common belief that programmers spend most of their time writing their symbol. However, a scientific study conducted by the Institute of Electricity and Electronics Engineers in 2017 shows that developers spend most of their time – 58 % – to understand the code! This is a convincing reason to write a clear and readable symbol. Understanding the complex code costs is not only one programmer’s salary, but also at a time when the interrogation of the person who wrote it or even organizing meetings, which doubles the costs of the number of participants.

Now, we are on the same page about the importance of readable code, but the “good” code is still a mere concept.

There is a great way to implement ready -made frames in your CI/CD pipeline to examine code, and most importantly, Do not overcome them.

For biton, these packages can include such as:

• Bill: Check the code pattern to make sure that it corresponds to the PEP 8 and PEP 257 criteria and to add to them. For example, jobs with more than 1000 lines will definitely not pass (with a set of maximum length to 50).

• blackCode formats automatically according to PEP 8, ensuring consistency.

• MyPyChecks the presence of data types in the code.

This list is not in any way, but for beginners, it is more than enough. The key is to make sure it is used constantly. We have seen many initiatives spent a lot of time, just to give up tools and forget in the end.

Let’s also address some of the well -known principles that are in line with this approach:

Dry – do not repeat yourself.

How many times have you just released software instructions to realize that he had not changed anything? You may have free the wrong code and missed the relevant part elsewhere. Tools like Pylint helps to capture these frequent pieces of code and make sure to fix them.

Kiss – keep it simple, stupid.

Make the code and architecture as simple as possible. Reducing the number of variables and length of jobs makes things easier to read and understand. Maintaining simple things reduces confusion and enhances maintenance.

By sticking to these principles and using automatic checks, you will save time, improve your code clarity, and create an environment that can cooperate more easily.

3. Plan to expand

Let’s think of an example.

If we use AWS as our infrastructure, sooner or later, we will face limits on the number of API requests. Some shares can be increased immediately, but others have strict limits. This is something we need to take into account when designing systems.

One of the common exercises in technical interviews is to think about how the system behaves with a million users.

This is a very reasonable question. After all, you are building an emerging company that will grow.

Common bottlenecks:

You can even run a simple mental experience to determine where bottlenecks may occur and how we will respond when scaling. Nobody wants to fight fires when every customer is concerned.

Download test It is a good tool to treat this. If we are building an application programming interface, we can simulate thick traffic using Locust.

We increase the load on our end points and note any part of the system fails first. After that, we consider redesigning or replacing this component and continuing to increase pregnancy.

Another example: If you already have a certain amount of data in your database.

Just like the download test, try to hit the data. How do you behave the listing? How are the end points that read this data? If we use the SQL database, do you add indexes or divide performance improvement?

4. Don’t only depend on yourself

This approach provides a clear double benefit: not only helps to clarify your thoughts, but also provides valuable visions from a professional perspective.

Expressing architecture loudly, even for an uncivilized audience, can achieve unexpected clarity of your thinking. David Thomas and Andrew Hunt also highlighted Practical programmerthe “Correction rubber duck“Technology can be an amazing effective way to break up complex problems. By explaining your thoughts in simple phrases – whether to a rubber duck or an actual listener – I was forced to think critically about the problem, identify potential gaps, and consider alternative solutions.

However, when you take this step forward and consult with an experienced professional, you can hit the benefits. Not only the counselor listens – it brings experience, a new perspective, and often the ability to discover weaknesses or opportunities that may not be clear from within your team. Their experience through various projects and industries allows you to suggest best practices, warn you of the common pitfalls, and provide innovative solutions that you may not think about.

By consulting with an expert before planning new products or limiting current products, you invest in long -term success to start your operation. They can help you determine the risks and areas for early improvement, providing you with costly errors at the bottom of the line. Moreover, the counselor’s comments can often correspond to your team about common goals, providing clarity and direction while moving forward.

Everyone knows that you need to write well documented code, create tests, and create systems taking into account the expansion. Countless books, articles and videos are allocated to these principles. However, at the beginning of the startup, there is no time or resources often to follow all the ideal recommendations. For this reason, she focused on practical and high air advice-time distinguishing and financial costs while increasing the effect.