15 perc alatt megismerheti a jó fejlesztői gondolkodásmód alapjait

"Nehéz még apró változtatásokat is végrehajtani"

„A szoftver funkcionalitásának megtörése változtatásokkal”

„Új hiba bemutatása egy újabb javításával”

„Felesleges kód megvalósítása”

"Szinte lehetetlen új funkciót felvenni a bonyolult kód miatt"

„A soha nem szállítható termék”

„Kód eldobása és a semmiből történő újraírás”

A fenti állítások ismerősek?

Minden percben egy fejlesztő a világ bármely részéről mondja (vagy gondolja) a fenti állítások bármelyikét, és sírni akar. Miért?

Ezek olyan általános kérdések, amelyekről a fejlesztők nagyon gyakran beszélnek. Ezeket a történeteket minden fejlesztői csapat tapasztalja.

Sok apró tényező van, amely lassan és fokozatosan károsítja a fejlesztői projekteket. Nem azonnal romboló hatásúak. Legtöbbjük csak hosszú távú kárt okoz. Valami, amit egy évig vagy annál tovább nem fog látni. Tehát amikor valaki javasolja őket, gyakran ártalmatlannak tűnnek.

Még akkor is, ha elkezded végrehajtani őket, rendben lehetnek. De ahogy telik az idő - és főleg, ha egyre több ilyen halmozódik fel - a komplexitás nyilvánvalóbbá válik és növekszik, amíg nem leszel újabb áldozata annak a mindig is elterjedt horrortörténetnek.

Annak elkerülése érdekében, hogy az áldozatok közé tartozzon, be kell tartania a szoftver alapvető törvényeit. Olyan gondolkodásmódot kell kialakítania, amellyel minden fejlesztőnek rendelkeznie kell. Ez a gondolkodásmód segít abban, hogy jobb döntéseket hozzon a napi programozási út során. A szoftverét a lehető legegyszerűbben tarthatja. Megvédheti, hogy kezelhetetlen és összetett rendszer legyen.

Itt vannak a legfontosabb pontok, amelyeket minden fejlesztőnek el kell sajátítania.

1. A szoftver céljának megtervezése

Először is meg kell értenie a szoftver célját. Valójában minden szoftver egyetlen célja van: az emberek megsegítése .

Ne feledje: a szoftver célja nem az, hogy megmutassa mennyire intelligens. - Max Kanat-Alexander, Kód egyszerűség

Azok a fejlesztők, akik nem tudják elképzelni a szoftver célját, rossz szoftvereket írnak. Mi a rossz szoftver? Összetett rendszer, amely nem segít annyira az embereknek.

A szoftverekkel kapcsolatos döntések meghozatalakor mindig szem előtt kell tartania: Hogyan tudunk segíteni? Akár a funkciókéréseket is rangsorolhatja így.

2. A szoftvertervezés céljai

Minden programozó tervező.

Amikor a szoftvert nehéz létrehozni vagy módosítani, a fejlesztők idejük nagy részét arra összpontosítják, hogy a dolgok csak működjenek, és kevesebb időt fordítsanak a felhasználók megsegítésére. A szoftver tervezésének célja, hogy a fejlesztők a lehető legegyszerűbb munkát végezzék, és így a lényeges dolgokra összpontosíthassanak. Létrehoz egy szoftvert, amely segíti a felhasználókat, és a szoftvere hosszú ideig továbbra is segítségükre lesz.

Ha azonban rossz rendszert tervez, akkor a szoftver élettartama rövid lesz.

Ezzel elérkeztünk a szoftvertervezés legfontosabb céljához:

Olyan rendszerek megtervezése, amelyeket a fejlesztőik a lehető legkönnyebben létrehozhatnak és fenntarthatnak, hogy minél hasznosabbak lehessenek - és továbbra is -. - Max Kanat-Alexander, Kód egyszerűség

Tehát két kulcsfontosságú pont van itt: A tervezésnek könnyűnek kell lennie az Ön számára és hasznosnak kell lennie mások számára.

3. (Mis) megértés

Azok a fejlesztők, akik nem értik teljesen a munkájukat, általában összetett rendszereket fejlesztenek ki. Ördögi körforgássá válhat: a félreértés összetettséghez vezet, ami további félreértéshez vezet stb.

Tulajdonképpen az egyik legjobb módszer a tervezési készségek fejlesztésére, ha meggyőződik arról, hogy teljes mértékben megértette azokat a rendszereket és eszközöket, amelyekkel dolgozik.

A megértés a legfontosabb különbség a rossz fejlesztő és a jó fejlesztő között. - Max Kanat-Alexander, Kód egyszerűség

A rossz fejlesztők nem értik, mit csinálnak, a jó fejlesztők pedig. Ez tényleg ilyen egyszerű.

4. Egyszerűség

Egyszerűség a legnagyobb bölcsesség. - Leonardo da Vinci

A programozás a bonyolultság egyszerűséggé való csökkentése. A „rossz fejlesztő” csak valaki, aki nem képes csökkenteni a bonyolultságot. A „jó fejlesztő” mindent megtesz annak érdekében, hogy a kód a lehető legegyszerűbb legyen más programozók számára.

Egy jó fejlesztő olyan dolgokat hoz létre, amelyek könnyen érthetők, így nagyon könnyű kirázni az összes hibát.

A fejlesztők általában intelligens emberek, és egyikük sem szereti, ha idiótákként kezelik őket. Ironikus módon ez néha arra készteti őket, hogy kissé bonyolult dolgokat alkossanak. Alapvetően így gondolkodnak:

- Ó, más fejlesztők megértenek mindent, amit itt tettem. Írnom kell valami okos kódot, amelyet nehéz megérteni, hogy azt gondolhassák, nagyon okos vagyok.

A téves gondolkodásmód okozta hiba - nem feltétlenül a programozási képességek hiánya miatt. A legtöbb programozási hiba ezen mentalitás miatt következik be.

Ha okosnak mutatkozik, az nem segít nekik.

Azok a fejlesztők, akik újak a kódodban, nem tudnak róla semmit; meg kell tanulniuk.

Tehát fel kell tennie ezt a kérdést: „ Azt akarom, hogy az emberek megértsék ezt és boldogok legyenek, vagy azt akarom, hogy zavartak és csalódottak legyenek?

Az az igazság, hogy ha más fejlesztők, akik elolvassák a kódodat, könnyen megértik azt, az azt jelenti, hogy jót teszel.

A bonyolultságnak semmi köze az intelligenciához, az egyszerűséghez. - Larry Bossidy

A kérdés a következő: "Mennyire egyszerűnek kell lenned?"

Itt van a válaszod: Hülye, néma egyszerű.

5. Komplexitás

A komplexitás ellenőrzése a számítógépes programozás lényege. - Brian Kernighan

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.

Minden változás karbantartást igényel. Az egyszerűség és az összetettség a két fő tényező, amely befolyásolja a kód karbantartását. Bármely szoftver könnyű karbantartása arányos az egyes darabok egyszerűségével. A karbantartás erőfeszítései arányosak a szoftver összetettségével. Az egyik szabály, amelyet be kell tartania a karbantartással kapcsolatban: A legfontosabb, hogy csökkentse a karbantartási erőfeszítéseket, mint a megvalósítás erőfeszítéseit. - Max Kanat-Alexander, Kód egyszerűség

7. Következetesség

A következetesség az egyszerűség nagy része. Ha valamit egyféleképpen csinál egy helyen, akkor mindenhol így tegye. Például, ha egy változót thisIsVariable-nek nevez el, akkor az összes változót így kell megnevezni (otherVariable, anAnotherVariable stb. Nem other_variable). - Max Kanat-Alexander, Kód egyszerűség

A nem következetes kód nehezebben érthető. Ne kényszerítse a fejlesztőket arra, hogy újból megtanulják a rendszer működését, valahányszor megnézik annak egy új darabját.

Bármely csapatsportban a legjobb csapatok következetességgel és kémiával rendelkeznek. - Roger Staubach

8. Prioritás

Hogyan hozhat döntéseket a szoftverével kapcsolatban?

Amikor sok lehetséges irányba néz, hogyan döntse el, melyik a legjobb? Mire kell összpontosítania, és mely funkciókat érdemes megvalósítania?

A kérdések megválaszolásához három fontos tényező segíti a jobb döntés meghozatalát. Ezt az egyenletet nagyon jól megmagyarázza a Code Simplicity könyv:

  • A változás kívánatossága (D): Mennyire szeretné, hogy ez a változás bekövetkezzen?
  • Változás értéke (V): Mennyi értéket kínál a változás? Mennyire segít a felhasználóknak?
  • A változás végrehajtásához szükséges erőfeszítés (E): Mennyi munkát kell elvégeznie a változás végrehajtásához?

Az egyenlet egyszerű: D = V / E

Bármely változás kívánatossága egyenesen arányos a változás értékével és fordítottan arányos a változtatással járó erőfeszítéssel . - Kód egyszerűség

Munkája rangsorolásakor kövesse ezt a szabályt:

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.

Az inkrementális kialakításnak az Ön útmutatójának kell lennie. Így használhatja egy számológép megtervezéséhez:

  1. Tervezzen olyan rendszert, amely csak kiegészítést végez, és semmi mást.
  2. Végezze el.
  3. Javítsa a már meglévő rendszer kialakítását, hogy más műveleteket is hozzáadhasson.
  4. Tervezze meg a kivonást, és ismételje meg a 2. és 3. lépést.
  5. Tervezze meg a szorzást, és ismételje meg a 2. és 3. lépést.
  6. Tervezze meg a felosztást, és ismételje meg a 2. és 3. lépést.

11. Jóslatok

„Az előrejelzés egyszerűen azt az előrejelzést jelenti, hogy valami történni fog a jövőben. Lehet tényszerű és valamiféle objektív adatok alapján, vagy feltételezésen alapulhat. " Amikor szembesülnek azzal a ténnyel, hogy a jövőben megváltozik a kódjuk, egyes fejlesztők megpróbálják megoldani a problémát egy olyan általános megoldás megtervezésével, amely (szerintük) alkalmazkodik minden lehetséges jövőbeli helyzethez. - Kód egyszerűség

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.

Egy fejlesztő tudja, hogy ki kell fejleszteni egy rendszert az X elvégzéséhez. Aztán úgy gondolják, hogy a rendszer megköveteli tőlük, hogy a jövőben Y-t tegyenek, és ők is végrehajtják az Y-t. Több ezer sornyi kódot írnak az Y tervezéséhez.

A jövőben a fejlesztő rájön, hogy a jelenlegi követelmények teljesen mások, mint amit gondoltak. De most a szoftvernek felesleges kódjai vannak, amelyek megnehezítik az eldobást, mert minden összefonódik. Hónapokba telik a kód átdolgozása, és most azt gondolják, hogy az egész szoftvert a nulláról írják át, ami hónapokat veszít.

Annak elkerülése érdekében, hogy ilyen fejlesztő legyen, kövesse ezt az egyszerű szabályt:

A kódot annak alapján kell megtervezni, amit most tud, és nem arra, hogy mit gondol a jövőben. - Kód egyszerűség

13. Hagyja abba a feltalálást

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.

Ha nem tudja egyszerűbbé tenni a kódot, akkor adja hozzá a megjegyzést ennek a bonyolultságnak a magyarázatához.

Az igazi célja megjegyzések megmagyarázni „MIÉRT” tettél valamit, nem „MI” a kód csinál. Ha ezt nem magyarázza el, akkor más programozók megzavarodhatnak, és amikor megváltoztatják a kódot, eltávolíthatják annak fontos részeit. - Kód egyszerűség

Írjon megjegyzést a „MIÉRT” magyarázatához, ne pedig a „MI” magyarázatához.

Egy másik dolog a dokumentálás. Fontos, hogy rendelkezzen dokumentációval, amely ismerteti a szoftver architektúráját, valamint minden modulját és alkatrészét. Erre a szoftver magas szintű képének megtekintéséhez van szükség.

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,

Tegyük fel például, hogy úgy gondolja, hogy egy feladat két órán belül elvégezhető. De négy óra múlva még mindig csak a megtett út egynegyede van. A természetes ösztön: "De most nem tudom feladni, már négy órát töltöttem erre!" Tehát hős módba lépsz. Elhatározta, hogy működni fog (és kissé zavarban van, hogy még nem működik). Fogod a köpenyedet, és elzárod magad a világtól. - Jason Fried

Ne légy rögeszmés. Tudja meg, mikor kell kilépnie. Ne habozzon, kérjen segítséget.

25. Ne tegyen fel kérdéseket ... Kérjen segítséget

Ha van mit megvalósítanod, és nem vagy biztos a megoldásokban, ne kérdezd meg másoktól, hogyan kell ezt csinálni ... legalábbis nem azonnal. Ehelyett próbáljon ki mindent és mindent, ami csak eszébe jut. Ez annál fontosabb, hogy kevésbé érzi jól magát egy fogalom vagy nyelv esetében.

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.

Thanks for reading! I hope this guide helped you out!

You can read more of my articles at //huseyinpolatyuruk.com.