Научите основе доброг размишљања програмера за 15 минута

„Тешко је извршити и мале промене“

„Кршење функционалности софтвера уношењем промена“

„Представљање нове грешке поправљањем друге“

„Имплементација кода који је непотребан“

„Готово је немогуће додати нову функцију због компликованог кода“

„Производ који се никад не испоручује“

„Бацање кода и његово преписивање испочетка“

Да ли су све горе наведене изјаве познате?

Сваког минута програмер из било ког дела света каже (или мисли) било коју од горе наведених изјава и жели да заплаче. Зашто?

То су уобичајена питања о којима програмери врло често говоре. Те су приче искусне у сваком развојном тиму.

Постоји много малих фактора који полако и постепено штете пројектима програмера. Они нису одмах деструктивни. Већина њих само наноси дуготрајну штету. Нешто што штету нећете видети годину дана или више. Па кад их неко предложи, често звуче безазлено.

Чак и кад почнете да их примените, они могу изгледати у реду. Али како време пролази - а посебно како се све више њих нагомилава - сложеност постаје све очитија и расте све док не постанете још једна жртва те тако честе хорор приче.

Да бисте избегли да будете једна од жртава, требало би да прихватите основне законе софтвера. Требали бисте развити начин размишљања који би требало да има сваки програмер. Овакав начин размишљања ће вам помоћи да доносите боље одлуке на вашем свакодневном програмском путовању. Софтвер можете учинити што једноставнијим. Можете га заштитити од тога да буде неукротив и сложен систем.

Ево кључних тачака које сваки програмер мора да савлада.

1. Схватање сврхе софтвера

Пре свега, требали бисте разумети сврху софтвера. У ствари, постоји само једна сврха целог софтвера: да помогне људима .

Запамтите: сврха софтвера није да покаже колико сте интелигентни. - Макс Канат-Александар, Једноставност кода

Програмери који не могу да схвате сврху софтвера написаће лош софтвер. Шта је лош софтвер? Сложен систем који људима не помаже толико.

Када доносите одлуке о софтверу, требали бисте се водити тако што ћете увек имати на уму ово: Како можемо помоћи? На овај начин чак можете да одредите приоритете за захтеве функција.

2. Циљеви софтверског дизајна

Сваки програмер је дизајнер.

Када је софтвер тешко створити или модификовати, програмери проводе већину свог времена усредсређујући се на то да ствари „само раде“, а мање времена помажући се корисницима. Дизајн софтвера има за циљ да програмерима олакша посао што је више могуће како би се могли усредсредити на оно што је важно. Створићете софтвер који ће помоћи корисницима, а ваш софтвер ће им још дуго помагати.

Међутим, ако дизајнирате лош систем, животни век вашег софтвера биће кратак.

Ово нас доводи до најважнијег циља дизајна софтвера:

Да дизајнирају системе које њихови програмери могу да креирају и одржавају на најлакши могући начин, како би могли да буду - и биће и даље - од помоћи. - Макс Канат-Александар, Једноставност кода

Дакле, овде постоје две кључне тачке: Ваш дизајн треба да буде лак за вас и користан за друге.

3. (Не) разумевање

Програмери који не разумеју потпуно свој рад теже да развијају сложене системе. То може постати зачарани круг: неразумевање доводи до сложености, што доводи до даљег неразумевања итд.

Заправо, један од најбољих начина да побољшате своје дизајнерске вештине је да будете сигурни да у потпуности разумете системе и алате са којима радите.

Разумевање је кључна разлика између лошег програмера и доброг програмера. - Макс Канат-Александар, Једноставност кода

Лоши програмери не разумеју шта раде, а добри програмери. Заиста је тако једноставно.

4. Једноставност

Једноставност је крајња софистицираност. - Леонардо да Винчи

Програмирање је чин смањивања сложености на једноставност. „Лош програмер“ је само неко ко не успева да смањи сложеност. „Добар програмер“ чини све што је у њиховој моћи да код учини што једноставнијим за друге програмере.

Добар програмер ствара ствари које су лако разумљиве тако да је заиста лако истрести све грешке.

Сада су програмери углавном интелигентни људи и нико од њих не воли да се према њему понашају као према идиотима. Иронично, то их понекад наводи да стварају ствари које су помало компликоване. Они у основи мисле овако:

Ох, други програмери ће разумети све што сам овде радио. Требао бих да напишем неки паметан код који је тешко разумети како би могли да мисле да сам веома паметан.

Грешка узрокована погрешним начином размишљања - не нужно недостатком програмских вештина. Већина неуспеха у програмирању се дешава због тог менталитета.

Показивање да сте паметни не помаже им.

Програмери који су нови у вашем коду не знају ништа о њему; морају научити.

Дакле, требало би да поставите ово питање: „ Да ли желим да људи то схвате и буду срећни или желим да буду збуњени и фрустрирани?

Истина је да ако други програмери који читају ваш код могу то лако да разумеју, то значи да радите добро.

Сложеност нема никакве везе с интелигенцијом, једноставност. - Ларри Боссиди

Питање је: „Колико једноставно мораш бити?“

Ево вашег одговора: Глупо, глупо једноставно.

5. Комплексност

Управљање сложеношћу је суштина рачунарског програмирања. - Бриан Кернигхан

The source of many software failures is complexity. You start out with a simple project that can be completed in one month. Then you add complexity, and the task will take up to three months. Then you start to add features that fulfill some other purpose. Things get very complex because you expand your software purpose for no reason. The tasks will take six months.

But that is not the end.

Then you take each piece of the feature and make it even more complex, and the task will take nine months. Then you start to introduce many new bugs because of the complexity in your code. Naturally, you start fixing them all without thinking how these fixes will affect other parts. At the end, when even small changes become hard. When bug fixes start to introduce new bugs, you will come to one of the most popular programming horror stories: Rewriting code from scratch.

So, how did you become a victim of this horror story? Nah, who cares. It’s better to ask: How could you avoid being a victim?

Well, it is simple. First, you will exactly know your software purpose and its definition. Second, you will be as simple as possible in every piece of code you write. Third, when a new feature or change request comes to the discussion table, you will evaluate them based on your software purpose and question them.

As a developer, your first behavior should be resistance to (unnecessary) change. This will prevent you from adding unnecessary codes into your software. When you are convinced that this change is a need, then you can implement it.

There are many factors that will increase complexity but those are the most popular ones. Aside from everything, there is only one rule that you should follow:

Your main purpose is to control complexity, not to create it.

6. Maintenance

Maintenance is one of the most important things in software development. Unfortunately, developers usually ignore how important it is. Quick coding and fast shipping look more important than code maintenance. This is the point where they make a mistake — ignorance of future code maintenance.

There will always be some implementation of changes. Not only you have to implement them, but you also have to maintain them over time. As a developer, thinking about future maintenance of changes is one of your main responsibilities.

Све промене захтевају одржавање. Једноставност и сложеност су два главна фактора која утичу на одржавање кода. Једноставност одржавања било ког дела софтвера пропорционална је једноставности појединих делова. Напор око одржавања пропорционалан је сложености софтвера. Једино правило које бисте се требали придржавати у вези са одржавањем је: Важније је смањити напор око одржавања него напор око имплементације. - Макс Канат-Александар, Једноставност кода

7. Доследност

Доследност је велики део једноставности. Ако нешто радите на један начин на једном месту, учините то на сваком месту. На пример, ако променљиву доделите тхисИсВариабле, тада би све ваше променљиве морале бити именоване на тај начин (отхерВариабле, анАнотхерВариабле итд. Не отхер_вариабле). - Макс Канат-Александар, Једноставност кода

Код који није доследан постаје теже разумљив. Не присиљавајте програмере да се поново уче како ваш систем функционише сваки пут када погледају нови његов део.

У било ком тимском спорту, најбољи тимови имају постојаност и хемију. - Рогер Стаубацх

8. Давање приоритета

Како доносите одлуке о свом софтверу?

Када се суочите са многим могућим упутствима, како одлучити која је опција најбоља? На шта се фокусирати и које функције бисте требали применити?

Да бисте одговорили на та питања, постоје три важна фактора који ће вам помоћи да донесете бољу одлуку. Ова једначина је врло добро објашњена у књизи Цоде Симплицити:

  • Пожељност промене (Д): Колико желите да се та промена догоди?
  • Вредност промене (В): Колику вредност нуди промена? Колико то помаже вашим корисницима?
  • Напор потребан да се изврши промена (Е): Колико ће вам посла требати да извршите ову промену?

Једначина је једноставна: Д = В / Е

Пожељност било које промене је директно пропорционална вредности промене и обрнуто пропорционална напору који је уложен у вршење промене. - Једноставност кода

Када дајете приоритет свом послу, требало би да се придржавате овог правила:

The changes that will bring you a lot of value and require little effort are better than those that will bring little value and require a lot of effort.

9. Solving Problems

The first step is understanding. Know exactly what is being asked. Most hard problems are hard because you don’t understand them. Write down your problem and try to explain it to someone else.

If you can’t explain something in simple terms, you don’t understand it. — Richard Feynman

The second step is planning. Don’t take action. Sleep on it. Give your brain some time to analyze the problem and process the information but don’t spend too much time on planning.

Think before acting.

The third step is dividing. Don’t try to solve one big problem. When you look at the problem as a whole, it can scare you. Divide it into smaller tasks and solve each sub-problem one by one. Once you solve each sub-problem, you connect the dots.

10. Good enough is fine

“Perfect is the enemy of good.” — Voltaire

Whether creating a new project or adding a feature to existing system developers tend to plan everything out in detail from the beginning.

They want the first version to be perfect. They don’t focus on the problem they will solve and how their software will help people.

They start by thinking of every small detail they could think about. Then assumptions and predictions come along followed by “What if” sentences. They have to predict the future because they were now so captivated by the imagination of the project in their mind and their project has to be as perfect as they imagined it.

Actually, they are not aware of what’s waiting for them and how much it will cost them by chasing perfection.

Let me tell you what will happen:

  • You will be writing code that isn’t needed
  • You will increase complexity by adding unnecessary codes
  • You will be too generic
  • You will be missing deadlines
  • You will be dealing with many bugs caused by the complexity

Do you want this to happen? I guess no.

What you should instead?

Start small, improve it, then extend.

Инкрементални дизајн треба да вам буде водич. Ево како бисте га користили за дизајн калкулатора:

  1. Планирајте систем који врши само сабирање и ништа друго.
  2. Проведите га.
  3. Побољшајте дизајн постојећег система тако да можете да додате и друге операције.
  4. Планирајте одузимање и поновите кораке 2 и 3.
  5. Планирајте множење и поновите 2. и 3. корак.
  6. Планирајте поделу и поновите 2. и 3. корак.

11. Предвиђања

„Предвиђање је једноставно прогноза да ће се нешто догодити у будућности. Може бити чињенично и засновано на некој врсти објективних података или на претпоставци “. Када се суоче са чињеницом да ће се њихов код променити у будућности, неки програмери покушавају да реше проблем дизајнирањем решења толико генеричког да ће се (верују) прилагодити свакој могућој будућој ситуацији. - Једноставност кода

Being too generic involves a lot of code that isn’t needed.

You can’t predict the future, so no matter how generic your solution is, it will not be generic enough to satisfy the actual future requirements you will have. Most probably, this time will never come and the code you wrote to solve future problems will increase complexity, make it hard to change the pieces of code and eventually it will become a burden that may destroy your software.

Don’t predict to future. Be only as generic as you know you need to be right now.

12. Assumptions

What is the assumption?

“An assumption is something that you accept as true or suppose to be true, although you have no conclusive proof.”

One of the great killers of a software project is assumptions. Let’s see how an assumption can kill a software project.

Програмер зна да мора да развије систем да би урадио Кс. Тада мисле да ће систем у будућности захтевати да раде И, а такође примењују И. Напишу хиљаде редова кода за дизајн И.

У будућности програмер схвата да су тренутни захтеви потпуно другачији од онога што су мислили. Али сада софтвер има непотребне кодове због којих је тешко бацити јер је све испреплетено. Потребни су месеци да се рефакторише код и сада мисле да препишу цео софтвер испочетка због чега ће изгубити месеце.

Да бисте избегли да постанете жртва попут овог програмера, следите ово једноставно правило:

Код треба дизајнирати на основу онога што сада знате, а не на основу онога што мислите да ће се догодити у будућности. - Једноставност кода

13. Престани да измишљаш

If, for example, you invent your own garbage collector when a perfectly good one exists, you’re going to be spending a lot of time working on the garbage collector, when you could just be working on your software.

The only times it’s okay to reinvent the wheel is when any of the following are true:

  • You need something that doesn’t exist yet
  • All of the existing “wheels” are bad technologies or incapable of handling your needs
  • The existing “wheels” aren’t being properly maintained

Simple rule:

Don’t reinvent the wheel.

14. Resistance

As a developer, your first reaction to changing requests should be “NO’’.

Always resist adding more code, more features until you are convinced that they are required and there is a need to implement them. Because unnecessary changes will increase defects in your software.

How can you know that there is a need for them?

Go back and remember your software purpose. Then remember the simple equation in prioritizing section.

From: [email protected] (Russ Cox)Subject: Re: [9fans] design clairvoyance & the 9 way Date: Thu, 8 May 2003 04:05:31 GMT > What does tomorrow's unix look like? I'm confident that tomorrow's Unix will look like today's Unix, only cruftier. Russ

15. Automation

Don’t spend your time on repetitive tasks. Set them up and forget about them. They can work while you are sleeping. When you realize that you are doing something again and again, just remember this rule:

If you can automate it, automate it.

16. Code measurement

Measuring programming progress by lines of code is like measuring aircraft building progress by weight.

— Bill Gates

I see developers who measure their software quality based on code lines. They think that more code lines mean that they are doing a great job. The software contains hundreds of thousands of lines of code, which means the software they work on is so big.

The question that pops up here is: Is it really that big, or there is something wrong there?

The answer is that most probably there is something wrong with their design. Most of the simple solutions don’t require a lot of code. You can achieve simplicity with a little bunch of code and solve the problem.

I’m not saying that fewer lines of code is always better. While you want to avoid having less code, you can easily fall in a trap that will cause you to write clever code that is hard to understand for others. You should find a balance.

The optimum code is a small bunch of code that is easy to understand, easy to read.

17. Productivity

How do you measure your productivity?

By writing more lines of code or by throwing hundreds of lines of code away?!

Your main goal should be keeping your code base as small as possible. The question is not “How can I write more code?” rather it should be “How can I remove more code?”

“One of my most productive days was throwing away 1000 lines of code.” — Ken Thompson

18. Testing

When should you add logging and error handling to your project?

You should add logging in a very early stage. This will help you to find the problem easily and save your time.

I see many mistakes when it comes to testing code. Let me give you an example. There were two conditions, a simple if-else block. The developer gave input to the software which will enter inside the if block. They tested it and committed code to source control. Done!

But what about the else block? When the software was shipped to production, that caused a lot of errors. When you test your code, you must execute all new lines at least once and you should start to test parts before the whole.

When you have a bug, first you should reproduce it. You shouldn’t guess the source of the bug and apply fixes based on your assumption. Most probably, you will be wrong. You should see it with your own eyes before applying the fix.

You should be reliable. When other developers in your team see that you committed new code to source control, everyone should know that your code is tested, and works.

Untested code is the code that doesn’t work.

19. (Under)Estimation

Developers’ estimation sucks.

Usually, they underestimate things rather than overestimate them. They underestimate the time and effort required to develop a small amount of code or a feature. In the end, this underestimation leads to missing deadlines.

The solution: Break the big thing into smaller things. The smaller it is, the easier it is to estimate. You’re probably still going to get it wrong, but you’ll be a lot less wrong than if you estimated a big project.

Remember:

Everything takes longer than you think.

20. Running Away From Rewriting

I believe that when you embrace the fundamental principles of software development mentioned in that article, you won’t come to this point. However, if, somehow you make these mistakes and find yourself thinking about rewriting your code, here is the main thing that you should know:

Rewriting code is often a developer delusion, not the solution in most cases.

Why is it a delusion?

Well, because it’s harder to read code than to write it. This is why it is so hard to reuse code. This is why our subconscious mind whispers to us “Throw it away and start over” when we read another developer’s code.

There are many cases that you should consider to rewrite your code from scratch and you can read them here. But, here is simple advice for you:

Refactoring should be the first option.

21. Documentation and Commenting

One of the common misconceptions about commenting is that developers add comments that say what code is doing. This is wrong. That should be obvious from reading the code. If it’s not obvious, it means that it is not readable and it should be made simpler.

Када не можете да поједноставите код, додајте коментар да бисте објаснили ову сложеност.

Стварна сврха коментара је да објасни "зашто" јеси нешто, не "ШТА"код ради. Ако ово не објасните, други програмери могу бити збуњени и када крену да промене ваш код, можда ће уклонити његове важне делове. - Једноставност кода

Напишите коментар да бисте објаснили „ЗАШТО“, а не „ШТА“.

Друга ствар је документовање. Важно је имати документацију која објашњава архитектуру софтвера и сваки модул и компоненте. Ово је потребно да бисте видели слику свог софтвера на високом нивоу.

When a new developer joins your team, it will be easier for them to understand the software as a whole. When developers don’t have any clue about other parts of the software, they could easily make a mistake in their own part which can affect other parts also.

22. Picking Technologies (Tools, Libraries, etc.)

First things first, always remember this rule:

Don’t depend on external technologies.But when you have to do so, try to reduce your dependency on them as much as you can.

Why is that? Because they are another common source of complexity. They can kill your active development and make everything even harder.

When you are dependent so much on external technologies, you are not free. What if there is a major bug in that technology? You have to wait for the developers to fix that bug and if this technology is in the center of your project basically you are stuck, you can’t move forward. So that’s why it is so important to pick the right technologies for your project.

There are a few factors you should consider before you start using some technology:

  • Is there active development behind it?
  • Will it continue to be maintained?
  • How easy is it to switch away from?
  • What does the community say about it?

If you can find the right answer these questions, you can reduce the risk of picking the wrong technology.

23. Self-Development

Keep learning. Try out different programming languages and tools, read books on software development. They will give you another perspective. Every day small improvements will make a real difference in your knowledge and skills.

Be open-minded. Don’t be obsessive about one technology. Use the required technology to solve a specific problem. Don’t be in the unnecessary discussion like Microsoft vs Linux :)

Know that every specific problem has its own specific solution.

24. Don’t be a hero

A lot of times it’s better to be a quitter than a hero. As Jason Fried explains,

На пример, рецимо да мислите да се задатак може обавити за два сата. Али, након четири сата, још увек имате само четвртину обављеног пута. Природни инстинкт је помислити: „Али сада не могу одустати, већ сам потрошио четири сата на ово!“ Дакле, прелазите у херојски режим. Одлучни сте да то успете (и помало вас је неугодно што већ не ради). Зграбиш свој рт и затвориш се од света. - Јасон Фриед

Не буди опсесиван. Знајте када треба да одустанете. Не устручавајте се да затражите помоћ.

25. Не постављајте питања ... Затражите помоћ

Када имате шта да примените, а нисте сигурни у решења, не питајте друге како да то учине ... бар не одмах. Уместо тога, покушајте све и све што вам падне на памет. Ово је важније што вам се мање свиђа концепт или језик.

When you can’t think of anything on your own, search! Find answers and try them out. Modify those answers, see if you can understand why they work, adapt them to your code.

…But always seek advice.

When you have tried everything, and preferably after you have a working solution, now is the best time to seek advice. Look to peers and senior developers to review your code.

I tried to explain the fundamentals of a good developer mindset in this article. I used some part from Code Simplicity book which has a big impact on my thinking process as a developer. When I read this book, there was a lot of moment that I reacted “ohh I did this mistake, I did that too.” I mentioned some important parts of the book and combine them with my experience.

I strongly recommend you to read Code Simplicity from Max Kanat-Alexander.

Хвала за читање! Надам се да вам је овај водич помогао!

Више мојих чланака можете прочитати на // хусеиинполатиурук.цом .