SlideShare a Scribd company logo

Perfect Code

Artem Tabalin, profile picture
Artem Tabalin

The document discusses principles and best practices for writing high-quality code, including keeping code simple, avoiding duplication, using object-oriented design principles like SOLID, giving variables and methods meaningful names, properly structuring classes, methods and variables, and applying principles of encapsulation and inheritance. It emphasizes that code quality is important to reduce development costs and improve productivity.

Software
Related topics:
Insights on Software Development
1 of 66
Downloaded 123 times
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
Perfect Code! How to write high-quality code! ARTEM TABALIN!
Motivation! Why should we always improve our code?! Why code that just works is not enough? !
Code Quality Control Law ! Improving code quality reduces development costs! Why?! Developer average productivity is! 10-50 lines per day! Writing code – 10%! Reading code, testing, debugging – 90%! !
Productivity vs Time! Productivity decreases with entropy increasing! Time Productivity
Software Development Paradox! 1. Low-quality code slows down development! 2. Devs reduce code quality to meet a deadline! Paradox: “Devs have no time to work rapidly”! The clue: #2 is wrong! Impossible to successfully meet a deadline messing up the code! Continuously maintain high code quality!
The Boy Scout Rule! It’s not enough to write code well - prevent “rotting”! ! “Leave the campground cleaner than you found it”! !
Software Development Principles! KISS, YAGNI, DRY, SOLID!
Keep Code Simple! KISS (Keep It Simple, Stupid)! Simplicity is a key goal! Components should be integrated tightly or weakly (?)! Try to reduce influence between components! Follow “Divide and Conquer” principle! !
Division of Responsibilities! • System → packages! • Package → classes! • Class → methods! • Method → control statements! Low coupling on each level!
Use Patterns! Don’t reinvent the square wheel! • Reduce complexity! • Less mistakes! • Simplify communication! ! Examples: Repository, Factory, Adapter, Strategy, Observer!
No Unnecessary Code! YAGNI (You Aren’t Gonna Need It)! Implement things only when you really need them! !
Avoid Duplication! DRY (Don’t Repeat Yourself)! ! “Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.”! !
Object-Oriented Design! SOLID! 1. Single Responsibility (SRP)! 2. Open-Closed (OCP)! 3. Liskov Substitution (LSP)! 4. Interface Segregation (ISP)! 5. Dependency Inversion (DIP)!
Single Responsibility Principle! “A class should have one and only one reason to change”! !
Open-Closed Principle! Class should be opened to extension and closed for modification! GraphicEditor +drawShape Shape +draw Rectangle +draw Circle +draw violation +drawCircle +drawRectangle +drawTriangle Triangle +draw
Liskov Substitution Principle! Objects implementing an interface can be used interchangeably! ! GraphicEditor +resize(IResizable) IResizable +bounds +resize Shape +bounds +resize Image +bounds +resize violation resize(IResizable obj) { if(obj is TextBlock) return; obj.resize(); } TextBlock +bounds +resize
Interface Segregation Principle! Clients should not depend on interfaces they don’t use! ! Shape +resize +move +select IResizable +resize violation IGraphic +resize +move +select ISelectable +select IMovable +move
Dependency Inversion Principle! Abstractions should not depend on details! GraphicEditor +logger: ILogger ILogger violation GraphicEditor() { logger = new FileLogger(); } EmailLogger FileLogger SystemLogger
Meaningful Names! Naming principles. Name length. Variable names. ! Class names. Method names.!
Naming Principles! Name should show your intention! int d; // elapsed time Is it good enough?! Which name is better?! int elapsedTimeInDays; int daysSinceCreation; ! !
Naming Principles! What does the following code do?! function getItems(items) { var list1 = []; for(var i = 0; i < items.length; i++) { var x = items[i]; if(items[i]["Field"] === 12) { list1.push(x); } } return list1; } !
Naming Principles! What is about this one?! function getMarkedCells(cells) { var result = []; for(var i = 0; i < cells.length; i++) { var cell = cells[i]; if(cell.Status === CellStatus.Marked) { result.push(cell); } } return result; }
Naming Principles! No implementation details! HashSet<Account> accountHashSet; Is it good enough? Why?! What if we decide to use List?! Which name is better?! HashSet<Account> accounts; !
Naming Principles! Choose easy-to-pronounce name! class Cstmr { private int prsnid; private DateTime genTstmp; private DateTime modTstmp; } class Customer { private int personId; private DateTime generationTimestamp; private DateTime modificationTimestamp; } !
Naming Principles! • Single word for concept (avoid synonyms)! fetch / retrieve / get controller / manager / driver! • Names from patterns and algos! RenderStrategy, JobQueue! • Names from user stories! Credit, Debit, Asset! • Antonyms! begin / end first / last min / max next / previous! old / new opened / closed source / target up / down! !
Naming Convention! The most important is to follow to the convention! Example:! • CONSTANT • ClassName • localVariable • _privateMember
Name Length! What is the optimal length for a name?! x → maximumNumberOfPointsInEachLine short / long name pros & cons! short names – lacks of information! long names – harder to read and write! ! 10-16 characters is the optimal length! if < 10 ask: is meaningful enough?! if > 16 ask: isn’t verbose?!
Loop Variable Names! • Simple loop! for(int i = 0; i < data.length; i++) { data[i] = 0; } • Complex loop! for(int teamIndex = 0; teamIndex < teamCount; teamIndex++) { for(int playerIndex = 0; playerIndex < count; playerIndex++) { playerStore[teamIndex][playerIndex] = 0; } }!
Loop Variable Names! • Variable used outside of the loop int recordCount = 0; while(moreRecords()) { data[recordCount] = getNextRecord(); recordCount++; } // … recordCount is accessed here !
Temporary Variable Names! Avoid pointless names! temp = sqrt(b^2 -­‐ 4*a*c); root[0] = (-­‐b + temp) / (2*a); root[1] = (-­‐b -­‐ temp) / (2*a); How to improve?! discriminant = sqrt(b^2 -­‐ 4*a*c); root[0] = (-­‐b + discriminant) / (2*a); root[1] = (-­‐b -­‐ discriminant) / (2*a); !
Boolean Variables and Methods! Use verbs is, has, can for booleans! • isSupported! • hasNext! • canExecute!
Class Names! Use nouns and noun combinations for classes! • Client! • Window! • UserAccount! • FileLoader!
Method Names! Use verbs and verb phrases for methods! • Save! • Close! • GetAccount! • LoadFile!
Variables! Declaration. Initialization. Lifetime and scope.!
Declaration! • Declare all variables! • Turn off implicit variable declaration! JavaScript: “use strict” VB: Option Explicit On php: error_reporting(E_STRICT); !
Initialization! Initialize variables at declaration! var total = 0; or at first occurrence in code! Dim total As Double ' another code total = 0.0 ' code using total !
Lifetime and Scope! Variables lifetime and scope should be minimal! Why?! Does code follow the principle?! function summarizeData() { var oldData = getOldData(); var totalOldData = summarize(oldData); printData(totalOldData); saveData(totalOldData); var newData = getNewData(); var totalNewData = summarize(newData); printData(totalNewData); saveData(totalNewData); }
Lifetime and Scope! Code might look like! function summarizeData() { var oldData = getOldData(); var newData = getNewData(); var totalOldData = summarize(oldData); var totalNewData = summarize(newData); printData(totalOldData); printData(totalNewData); saveData(totalOldData); saveData(totalNewData); } ! !
Lifetime and Scope! • Single purpose principle! int value = getValue(); int result = calcResult(value); // some code value = val1; val1 = val2; val2 = value; • Avoid global variables! • Prefer the most restrictive access level! private → public! var swap = val1; val1 = val2; val2 = swap; →
Methods (Functions)! Purposes. Principles. Order. Parameters.!
Purposes! • Simplify code! • Improve readability! • Documentation defines abstraction! • Eliminating duplication most popular! • Inheritance support method overriding!
Principles! Method should be small! How many lines?! not more than 20 lines and better even less! Example:! public ReportContainer BuildReport(IList<Order> orders) { var report = new ReportContainer(); report.Lines = BuildReportLines(orders); report.Total = BuildReportTotal(report.Lines); return report; } !
Principles! Method should have! • blocks (if, else, for, while) 1-3 lines long! • indent level not more than 2! private IList<ReportLine> BuildReportLines(IList<Order> orders) { IList<ReportLine> result = new List<ReportLine>(); foreach (Order order in orders) { ReportLine reportLine = BuildReportLine(order); if (reportLine.IsVisible) result.Add(reportLine); } return result; } !
Principles! Single Thing Rule! Function should do one thing, do it only, and do it well! Examples:! • BuildReport – makes report! • BuildReportLines – prepares report lines! • BuildReportTotal – summarizes report! Criteria: function cannot be divided into sections!
Principles! Single Abstraction Level! Mixing up abstraction levels increases complexity! Does code follow the principle? Why?! private Report BuildReport(Order order) { var result = new Report(); result.Header = BuildReportHeader(order.Title); result.Body = ReportHelper.TextToHtml(order.Description); result.Footer = "<b>" + APP_NAME + "</b>"; result.Footer += " CopyRight © " + DateTime.Now.Year; return result; } !
Principles! Better! private Report BuildReport(Order order) { var result = new Report(); result.Header = BuildReportHeader(order.Title); result.Body = ReportHelper.TextToHtml(order.Description); result.Footer = BuildReportFooter(); return result; } Much Better! private Report BuildReport(Order order) { var result = new Report(); result.Header = BuildReportHeader(order.Title); result.Body = BuildReportBody(order.Description); result.Footer = BuildReportFooter(); return result; } !
Principles! Command-Query Separation (CQS)! Method performs an action OR returns data! Does code follow the principle?! if (SetAttribute("username", "Admin")) { // code } How to fix? if (HasAttribute("username")) { SetAttribute("username", "Admin"); // code }
Order! The Stepdown Rule! Read code from top to bottom (by abstraction levels)! public Report BuildReport(IList<Order> orders) { // uses BuildReportLines and BuildReportTotal } private Report BuildReportLines(IList<Order> orders) { // uses BuildReportLine } private Report BuildReportLine(IList<Order> orders) { // code } private Report BuildReportTotal(IList<Order> orders) { // code }
Arguments! How many parameters should a method have?! • Ideally 0! • Avoid methods with more than 2 arguments! Why?! • Harder to read (remember passing values)! • Increase coupling! • Harder to test (combinatorial growth of variants)!
Arguments! Avoid boolean arguments! Why?! • Usually can be divided into two sections! • Hard to understand a purpose of an argument! BuildReportLine(order, true); private Report BuildReportLine(Order order, bool isMarked) { if (isMarked) { // build marked report line } else { // build simple report line } }
Classes! Purposes. Principles. Interface. Encapsulation. Inheritance.!
Purposes! • Simplify code • Improve readability! • Limit the scope of changes! • Hide implementation details (encapsulation)! • Allow to prepare generic solution (abstraction)! • Eliminate duplication (delegation & inheritance)! • Provide extensibility (inheritance)! • Allow to work with real domain entities!
Principles! • Encapsulation! Hide as much as possible! • Compactness! Reduce class responsibilities (SRP)! • Abstraction! Program to an interface, not an implementation! • High Cohesion! Fields and methods should belong together!
Interface! Methods should be on the same abstraction level! Does code follow the principle? Why?! class Program { public void InitializeCommandStack(); public void PushCommand(Command command); public Command PopCommand(); public void ShutdownCommandStack(); public void InitializeReportFormatting(); public void FormatReport(Report report); public void PrintReport(Report report); public void InitializeGlobalData(); public void ShutdownGlobalData(); }
Interface! Programming over semantic! • Programming – can be checked by compiler! Amount of arguments! Argument types! • Semantic – cannot be checked by compiler! Method A should be called after method B! Method A throws exception when argument is not initialized! !
Encapsulation! • Not public should be private ! private → public! • No direct access to fields! private decimal _x = 0; public decimal X { get { return _x; } set { _x = value; } } • No assumptions about class clients! // param2 should be > 0, in other case method fails public int Method(int param1, int param2) !
Inheritance! Should be able to say that child ‘is’ parent! Circle is Shape HtmlParser is Parser! Does code follow the principle?! class Customer { public int ID { get; set; } public string Name { get; set; } } class Bank: Customer { public string CorrespondentAccount { get; set; } } Depends on whether a bank can be a customer or not! !
Inheritance! Move common methods to base class! abstract class Stream { public void Write(byte[] bytes); public byte[] Read(); } class SecureStream: Stream { public void Init(StreamConfig config); } !
Inheritance! Avoid following situations:! • Parent class has only one child! • Child overrides method leaving it empty! • Too many hierarchy levels! better not more than 3 levels!
Comments! Commenting principles. Bad comments. Good comments.!
Commenting Principles! • Comments do not redress bad code! clean code much better than bad code with comments! • Do not comment tricky code – rewrite it! tricky code = bad code! • Try to explain with code! // is employee eligible for bonus if ((employee.Schedule == HOURLY_SCHEDULE) && employee.Age > 65) { … } ! Better! if (employee.IsEligibleForBonus()) { … }
Commenting Principles! Comment says “why” not “how”! • How! // if flag equals to zero if (accountFlag == 0) • Why! // if new account created if (accountFlag == 0) • Code instead of comment! if (accountType == AccountType.NewAccount)
Bad Comments! • Redundant comments! obvious and repeating code! // closing connection Connection.Close(); • Commented code! remove unnecessary code, VCS is for the rescue InputStream response = new InputStream(); response.SetBody(formatter.ResultStream, formatter.BytesCount); //InputStream resultStream = formatter.ResultStream; //StreamReader reader = new StreamReader(resultStream); //response.SetContent(reader.Read(formatter.BytesCount));
Good Comments! • Legal comments! license, copyright, author! • Explanations! provide info about inevitable tricks // NOTE: postpone execution to refresh UI setTimeout(function() { // code }); • TODOs! notes for future to avoid “broken windows” // TODO: get rid of tricky workaround function badFunction() { // tricky workaround here });
Thank you!! Your questions, please!! ARTEM TABALIN!
References! • Steve McConnell Code Complete! • Robert C. Martin Clean Code! • Hunt A., Thomas D. The Pragmatic Programmer ! • Craig Larman Applying UML and Patterns! • Kent Beck Implementation Patterns! • Eric Evans Domain-Driven Design!

More Related Content

PDF
Perfect Styling - How to write better CSS
Artem Tabalin
 
PDF
Software Patterns
Artem Tabalin
 
PDF
From Stairway to Heaven onto the Highway to Hell with Xtext
Karsten Thoms
 
ZIP
URUG Ruby on Rails Workshop - Sesssion 5
jakemallory
 
KEY
Xtext Best Practices
Sebastian Zarnekow
 
PPTX
Cucumber_Training_ForQA
Meenakshi Singhal
 
PDF
Cucumber in Practice(en)
Kyosuke MOROHASHI
 
PPTX
WordPress Coding Standards & WP Hooks
Eunus Hosen
 
Perfect Styling - How to write better CSS
Artem Tabalin
 
Software Patterns
Artem Tabalin
 
From Stairway to Heaven onto the Highway to Hell with Xtext
Karsten Thoms
 
URUG Ruby on Rails Workshop - Sesssion 5
jakemallory
 
Xtext Best Practices
Sebastian Zarnekow
 
Cucumber_Training_ForQA
Meenakshi Singhal
 
Cucumber in Practice(en)
Kyosuke MOROHASHI
 
WordPress Coding Standards & WP Hooks
Eunus Hosen
 

What's hot (20)

PDF
What is-sass-by-lucas-castro
Lucas Castro
 
PPTX
10 Ways To Abuse T-SQL
Tracy McKibben
 
KEY
Testing gone-right
Jesse Wolgamott
 
KEY
Why are preprocessors divisive
Kianosh Pourian
 
PDF
Scala Bay Meetup - The state of Scala code style and quality
Jaime Jorge
 
PPTX
Active Record PowerPoint
Elizabeth Cruz
 
PPT
Know Before it Goes: Testing Your Email Design
Litmus
 
PPTX
Productive development with react js
Tim (dev-tim) Zadorozhniy
 
PDF
Funtional Ruby - Mikhail Bortnyk
Ruby Meditation
 
PDF
Vimperl
Ynon Perek
 
PPTX
International SEO
Pradeep Kumar Sharma
 
PDF
5 hs mpostcustomizationrenefonseca
ssuserfadb24
 
PDF
Graduates Gone Mad: Innovations in Software
Alper Kanat
 
PDF
Five Enterprise Development Best Practices That EVERY Salesforce Org Can Use
Salesforce Developers
 
PPTX
Spsbe using js-linkanddisplaytemplates
Paul Hunt
 
PDF
C++ 11 Style : A Touch of Class
Yogendra Rampuria
 
PPTX
Functional programming
Prateek Jain
 
PPTX
Up to speed in domain driven design
Rick van der Arend
 
PPTX
06 integrating extra features and looking forward
Марина Босова
 
PPTX
How To Write Beautiful Code
2C Development Group
 
What is-sass-by-lucas-castro
Lucas Castro
 
10 Ways To Abuse T-SQL
Tracy McKibben
 
Testing gone-right
Jesse Wolgamott
 
Why are preprocessors divisive
Kianosh Pourian
 
Scala Bay Meetup - The state of Scala code style and quality
Jaime Jorge
 
Active Record PowerPoint
Elizabeth Cruz
 
Know Before it Goes: Testing Your Email Design
Litmus
 
Productive development with react js
Tim (dev-tim) Zadorozhniy
 
Funtional Ruby - Mikhail Bortnyk
Ruby Meditation
 
Vimperl
Ynon Perek
 
International SEO
Pradeep Kumar Sharma
 
5 hs mpostcustomizationrenefonseca
ssuserfadb24
 
Graduates Gone Mad: Innovations in Software
Alper Kanat
 
Five Enterprise Development Best Practices That EVERY Salesforce Org Can Use
Salesforce Developers
 
Spsbe using js-linkanddisplaytemplates
Paul Hunt
 
C++ 11 Style : A Touch of Class
Yogendra Rampuria
 
Functional programming
Prateek Jain
 
Up to speed in domain driven design
Rick van der Arend
 
06 integrating extra features and looking forward
Марина Босова
 
How To Write Beautiful Code
2C Development Group
 
Ad

Viewers also liked (20)

PDF
Refactoring
Artem Tabalin
 
PDF
eXtreme Programming
Artem Tabalin
 
PPTX
SOLID, DRY, SLAP design principles
Sergey Karpushin
 
PPT
SOLID Design Principles
Andreas Enbohm
 
PPTX
A Software Architect's View On Diagramming
meghantaylor
 
PDF
The principles of good programming
Angelin R
 
PDF
Offline Web Apps
Artem Tabalin
 
PPTX
Agile Agile: Adapting Practices to Support Explosive Growth by Ben Foster
LitheSpeed
 
PPTX
Interview: a Learning Conversation
Jane Prusakova
 
PPTX
Lets talk About Good Code (Dallas TechFest 2014)
Jane Prusakova
 
PDF
Smacss e-css-faz-bem
Just Digital
 
PDF
Guide to Human Activity System (HAS) Mapping
David Alman
 
PDF
Ewan developing the agile mindset for organizational agility
Magneta AI
 
PPTX
вольфсон построение собственного Agile-фреймворка (шаблон)
Magneta AI
 
PPTX
Clean Code I - Design Patterns and Best Practices at SoCal Code Camp San Dieg...
Theo Jungeblut
 
PDF
Nguyen Vu Hung: Beyond Agile - Practices and Mindset - Agile Tour Vietnam (Ha...
Vu Hung Nguyen
 
PPT
Design Smells
Giorgio Vespucci
 
PPT
Software Programming Principles
Sven Peters
 
PPTX
GRASP Principles
Raheel Arif
 
PPT
The Smells Of Bad Design
guest446c0
 
Refactoring
Artem Tabalin
 
eXtreme Programming
Artem Tabalin
 
SOLID, DRY, SLAP design principles
Sergey Karpushin
 
SOLID Design Principles
Andreas Enbohm
 
A Software Architect's View On Diagramming
meghantaylor
 
The principles of good programming
Angelin R
 
Offline Web Apps
Artem Tabalin
 
Agile Agile: Adapting Practices to Support Explosive Growth by Ben Foster
LitheSpeed
 
Interview: a Learning Conversation
Jane Prusakova
 
Lets talk About Good Code (Dallas TechFest 2014)
Jane Prusakova
 
Smacss e-css-faz-bem
Just Digital
 
Guide to Human Activity System (HAS) Mapping
David Alman
 
Ewan developing the agile mindset for organizational agility
Magneta AI
 
вольфсон построение собственного Agile-фреймворка (шаблон)
Magneta AI
 
Clean Code I - Design Patterns and Best Practices at SoCal Code Camp San Dieg...
Theo Jungeblut
 
Nguyen Vu Hung: Beyond Agile - Practices and Mindset - Agile Tour Vietnam (Ha...
Vu Hung Nguyen
 
Design Smells
Giorgio Vespucci
 
Software Programming Principles
Sven Peters
 
GRASP Principles
Raheel Arif
 
The Smells Of Bad Design
guest446c0
 
Ad

Similar to Perfect Code (20)

PPTX
Clean Code - Writing code for human
NETKO Solution
 
PDF
Guidelines to clean coding
Janak Porwal
 
PPTX
Writing High Quality Code in C#
Svetlin Nakov
 
PDF
What's in a name
Koby Fruchtnis
 
PPTX
Variables
Maha Saad
 
PDF
Clean Code
Chris Farrell
 
PPT
Clean Code summary
Jan de Vries
 
PPTX
Programming style guildelines
Rich Nguyen
 
PPT
c-coding-standards-and-best-programming-practices.ppt
VinayakHospet1
 
PDF
Clean code and code smells
Md. Aftab Uddin Kajal
 
PPTX
C# coding standards, good programming principles & refactoring
Eyob Lube
 
PPT
Clean code
Uday Pratap Singh
 
PPT
Coding standard
Shwetketu Rastogi
 
PDF
Clean code
Alvaro García Loaisa
 
PDF
Clean Code .Net Cheetsheets
NikitaGoncharuk1
 
PDF
76829060 java-coding-conventions
slavicp
 
PPT
Coding Standards & Best Practices for iOS/C#
Asim Rais Siddiqui
 
PPS
Coding Best Practices
mh_azad
 
PDF
Clean code
Arturo Herrero
 
PDF
Seven Ineffective Coding Habits of Many Programmers
Kevlin Henney
 
Clean Code - Writing code for human
NETKO Solution
 
Guidelines to clean coding
Janak Porwal
 
Writing High Quality Code in C#
Svetlin Nakov
 
What's in a name
Koby Fruchtnis
 
Variables
Maha Saad
 
Clean Code
Chris Farrell
 
Clean Code summary
Jan de Vries
 
Programming style guildelines
Rich Nguyen
 
c-coding-standards-and-best-programming-practices.ppt
VinayakHospet1
 
Clean code and code smells
Md. Aftab Uddin Kajal
 
C# coding standards, good programming principles & refactoring
Eyob Lube
 
Clean code
Uday Pratap Singh
 
Coding standard
Shwetketu Rastogi
 
Clean code
Alvaro García Loaisa
 
Clean Code .Net Cheetsheets
NikitaGoncharuk1
 
76829060 java-coding-conventions
slavicp
 
Coding Standards & Best Practices for iOS/C#
Asim Rais Siddiqui
 
Coding Best Practices
mh_azad
 
Clean code
Arturo Herrero
 
Seven Ineffective Coding Habits of Many Programmers
Kevlin Henney
 

Recently uploaded (20)

PDF
iTop VPN Crack Latest Version Full Key 2025
hashmianya37
 
PPTX
WiFi Honeypot Detecscfddssdffsedfseztor.pptx
singlesrihari
 
PDF
Time Tracking Features That Teams and Organizations Actually Need
Orangescrum
 
PDF
Wondershare Recoverit Full Crack New Version (Latest 2025)
hashmi66g66
 
PPTX
GSA Content Generator Crack (2025 Latest)
halimaanam8
 
PPTX
Computer Software and OS of computer science of grade 11.pptx
GauravDahal9
 
PDF
Salesforce Agentforce AI Implementation.pdf
Robert Mark
 
PPTX
Trending Python Topics for Data Visualization in 2025
IT IDOL Technologies
 
PPTX
Patient Appointment Booking in Odoo with online payment
AxisTechnolabs
 
PPTX
AMADEUS TRAVEL AGENT SOFTWARE | AMADEUS TICKETING SYSTEM
philipnathen82
 
PDF
Designing Intelligence for the Shop Floor.pdf
nikglvk
 
PDF
wealthsignaloriginal-com-DS-text-... (1).pdf
skmiani786
 
PDF
How AI/LLM recommend to you ? GDG meetup 16 Aug by Fariman Guliev
HusseinMalikMammadli
 
PPTX
Advanced SystemCare Ultimate Crack + Portable (2025)
adanataj41
 
PDF
EaseUS PDF Editor Pro 6.2.0.2 Crack with License Key 2025
halimaanam8
 
PDF
Digital Systems & Binary Numbers (comprehensive )
fyfhqfhtv2
 
PPTX
chapter 5 systemdesign2008.pptx for cimputer science students
KemalHussen2
 
PDF
Top 10 Software Development Trends to Watch in 2025 🚀.pdf
KodekX
 
PDF
DuckDuckGo Private Browser Premium APK for Android Crack Latest 2025
hashmi66g66
 
PDF
MCP Security Tutorial - Beginner to Advanced
Harish Ramadoss
 
iTop VPN Crack Latest Version Full Key 2025
hashmianya37
 
WiFi Honeypot Detecscfddssdffsedfseztor.pptx
singlesrihari
 
Time Tracking Features That Teams and Organizations Actually Need
Orangescrum
 
Wondershare Recoverit Full Crack New Version (Latest 2025)
hashmi66g66
 
GSA Content Generator Crack (2025 Latest)
halimaanam8
 
Computer Software and OS of computer science of grade 11.pptx
GauravDahal9
 
Salesforce Agentforce AI Implementation.pdf
Robert Mark
 
Trending Python Topics for Data Visualization in 2025
IT IDOL Technologies
 
Patient Appointment Booking in Odoo with online payment
AxisTechnolabs
 
AMADEUS TRAVEL AGENT SOFTWARE | AMADEUS TICKETING SYSTEM
philipnathen82
 
Designing Intelligence for the Shop Floor.pdf
nikglvk
 
wealthsignaloriginal-com-DS-text-... (1).pdf
skmiani786
 
How AI/LLM recommend to you ? GDG meetup 16 Aug by Fariman Guliev
HusseinMalikMammadli
 
Advanced SystemCare Ultimate Crack + Portable (2025)
adanataj41
 
EaseUS PDF Editor Pro 6.2.0.2 Crack with License Key 2025
halimaanam8
 
Digital Systems & Binary Numbers (comprehensive )
fyfhqfhtv2
 
chapter 5 systemdesign2008.pptx for cimputer science students
KemalHussen2
 
Top 10 Software Development Trends to Watch in 2025 🚀.pdf
KodekX
 
DuckDuckGo Private Browser Premium APK for Android Crack Latest 2025
hashmi66g66
 
MCP Security Tutorial - Beginner to Advanced
Harish Ramadoss
 

Perfect Code

  • 1. Perfect Code! How to write high-quality code! ARTEM TABALIN!
  • 2. Motivation! Why should we always improve our code?! Why code that just works is not enough? !
  • 3. Code Quality Control Law ! Improving code quality reduces development costs! Why?! Developer average productivity is! 10-50 lines per day! Writing code – 10%! Reading code, testing, debugging – 90%! !
  • 4. Productivity vs Time! Productivity decreases with entropy increasing! Time Productivity
  • 5. Software Development Paradox! 1. Low-quality code slows down development! 2. Devs reduce code quality to meet a deadline! Paradox: “Devs have no time to work rapidly”! The clue: #2 is wrong! Impossible to successfully meet a deadline messing up the code! Continuously maintain high code quality!
  • 6. The Boy Scout Rule! It’s not enough to write code well - prevent “rotting”! ! “Leave the campground cleaner than you found it”! !
  • 7. Software Development Principles! KISS, YAGNI, DRY, SOLID!
  • 8. Keep Code Simple! KISS (Keep It Simple, Stupid)! Simplicity is a key goal! Components should be integrated tightly or weakly (?)! Try to reduce influence between components! Follow “Divide and Conquer” principle! !
  • 9. Division of Responsibilities! • System → packages! • Package → classes! • Class → methods! • Method → control statements! Low coupling on each level!
  • 10. Use Patterns! Don’t reinvent the square wheel! • Reduce complexity! • Less mistakes! • Simplify communication! ! Examples: Repository, Factory, Adapter, Strategy, Observer!
  • 11. No Unnecessary Code! YAGNI (You Aren’t Gonna Need It)! Implement things only when you really need them! !
  • 12. Avoid Duplication! DRY (Don’t Repeat Yourself)! ! “Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.”! !
  • 13. Object-Oriented Design! SOLID! 1. Single Responsibility (SRP)! 2. Open-Closed (OCP)! 3. Liskov Substitution (LSP)! 4. Interface Segregation (ISP)! 5. Dependency Inversion (DIP)!
  • 14. Single Responsibility Principle! “A class should have one and only one reason to change”! !
  • 15. Open-Closed Principle! Class should be opened to extension and closed for modification! GraphicEditor +drawShape Shape +draw Rectangle +draw Circle +draw violation +drawCircle +drawRectangle +drawTriangle Triangle +draw
  • 16. Liskov Substitution Principle! Objects implementing an interface can be used interchangeably! ! GraphicEditor +resize(IResizable) IResizable +bounds +resize Shape +bounds +resize Image +bounds +resize violation resize(IResizable obj) { if(obj is TextBlock) return; obj.resize(); } TextBlock +bounds +resize
  • 17. Interface Segregation Principle! Clients should not depend on interfaces they don’t use! ! Shape +resize +move +select IResizable +resize violation IGraphic +resize +move +select ISelectable +select IMovable +move
  • 18. Dependency Inversion Principle! Abstractions should not depend on details! GraphicEditor +logger: ILogger ILogger violation GraphicEditor() { logger = new FileLogger(); } EmailLogger FileLogger SystemLogger
  • 19. Meaningful Names! Naming principles. Name length. Variable names. ! Class names. Method names.!
  • 20. Naming Principles! Name should show your intention! int d; // elapsed time Is it good enough?! Which name is better?! int elapsedTimeInDays; int daysSinceCreation; ! !
  • 21. Naming Principles! What does the following code do?! function getItems(items) { var list1 = []; for(var i = 0; i < items.length; i++) { var x = items[i]; if(items[i]["Field"] === 12) { list1.push(x); } } return list1; } !
  • 22. Naming Principles! What is about this one?! function getMarkedCells(cells) { var result = []; for(var i = 0; i < cells.length; i++) { var cell = cells[i]; if(cell.Status === CellStatus.Marked) { result.push(cell); } } return result; }
  • 23. Naming Principles! No implementation details! HashSet<Account> accountHashSet; Is it good enough? Why?! What if we decide to use List?! Which name is better?! HashSet<Account> accounts; !
  • 24. Naming Principles! Choose easy-to-pronounce name! class Cstmr { private int prsnid; private DateTime genTstmp; private DateTime modTstmp; } class Customer { private int personId; private DateTime generationTimestamp; private DateTime modificationTimestamp; } !
  • 25. Naming Principles! • Single word for concept (avoid synonyms)! fetch / retrieve / get controller / manager / driver! • Names from patterns and algos! RenderStrategy, JobQueue! • Names from user stories! Credit, Debit, Asset! • Antonyms! begin / end first / last min / max next / previous! old / new opened / closed source / target up / down! !
  • 26. Naming Convention! The most important is to follow to the convention! Example:! • CONSTANT • ClassName • localVariable • _privateMember
  • 27. Name Length! What is the optimal length for a name?! x → maximumNumberOfPointsInEachLine short / long name pros & cons! short names – lacks of information! long names – harder to read and write! ! 10-16 characters is the optimal length! if < 10 ask: is meaningful enough?! if > 16 ask: isn’t verbose?!
  • 28. Loop Variable Names! • Simple loop! for(int i = 0; i < data.length; i++) { data[i] = 0; } • Complex loop! for(int teamIndex = 0; teamIndex < teamCount; teamIndex++) { for(int playerIndex = 0; playerIndex < count; playerIndex++) { playerStore[teamIndex][playerIndex] = 0; } }!
  • 29. Loop Variable Names! • Variable used outside of the loop int recordCount = 0; while(moreRecords()) { data[recordCount] = getNextRecord(); recordCount++; } // … recordCount is accessed here !
  • 30. Temporary Variable Names! Avoid pointless names! temp = sqrt(b^2 -­‐ 4*a*c); root[0] = (-­‐b + temp) / (2*a); root[1] = (-­‐b -­‐ temp) / (2*a); How to improve?! discriminant = sqrt(b^2 -­‐ 4*a*c); root[0] = (-­‐b + discriminant) / (2*a); root[1] = (-­‐b -­‐ discriminant) / (2*a); !
  • 31. Boolean Variables and Methods! Use verbs is, has, can for booleans! • isSupported! • hasNext! • canExecute!
  • 32. Class Names! Use nouns and noun combinations for classes! • Client! • Window! • UserAccount! • FileLoader!
  • 33. Method Names! Use verbs and verb phrases for methods! • Save! • Close! • GetAccount! • LoadFile!
  • 35. Declaration! • Declare all variables! • Turn off implicit variable declaration! JavaScript: “use strict” VB: Option Explicit On php: error_reporting(E_STRICT); !
  • 36. Initialization! Initialize variables at declaration! var total = 0; or at first occurrence in code! Dim total As Double ' another code total = 0.0 ' code using total !
  • 37. Lifetime and Scope! Variables lifetime and scope should be minimal! Why?! Does code follow the principle?! function summarizeData() { var oldData = getOldData(); var totalOldData = summarize(oldData); printData(totalOldData); saveData(totalOldData); var newData = getNewData(); var totalNewData = summarize(newData); printData(totalNewData); saveData(totalNewData); }
  • 38. Lifetime and Scope! Code might look like! function summarizeData() { var oldData = getOldData(); var newData = getNewData(); var totalOldData = summarize(oldData); var totalNewData = summarize(newData); printData(totalOldData); printData(totalNewData); saveData(totalOldData); saveData(totalNewData); } ! !
  • 39. Lifetime and Scope! • Single purpose principle! int value = getValue(); int result = calcResult(value); // some code value = val1; val1 = val2; val2 = value; • Avoid global variables! • Prefer the most restrictive access level! private → public! var swap = val1; val1 = val2; val2 = swap; →
  • 40. Methods (Functions)! Purposes. Principles. Order. Parameters.!
  • 41. Purposes! • Simplify code! • Improve readability! • Documentation defines abstraction! • Eliminating duplication most popular! • Inheritance support method overriding!
  • 42. Principles! Method should be small! How many lines?! not more than 20 lines and better even less! Example:! public ReportContainer BuildReport(IList<Order> orders) { var report = new ReportContainer(); report.Lines = BuildReportLines(orders); report.Total = BuildReportTotal(report.Lines); return report; } !
  • 43. Principles! Method should have! • blocks (if, else, for, while) 1-3 lines long! • indent level not more than 2! private IList<ReportLine> BuildReportLines(IList<Order> orders) { IList<ReportLine> result = new List<ReportLine>(); foreach (Order order in orders) { ReportLine reportLine = BuildReportLine(order); if (reportLine.IsVisible) result.Add(reportLine); } return result; } !
  • 44. Principles! Single Thing Rule! Function should do one thing, do it only, and do it well! Examples:! • BuildReport – makes report! • BuildReportLines – prepares report lines! • BuildReportTotal – summarizes report! Criteria: function cannot be divided into sections!
  • 45. Principles! Single Abstraction Level! Mixing up abstraction levels increases complexity! Does code follow the principle? Why?! private Report BuildReport(Order order) { var result = new Report(); result.Header = BuildReportHeader(order.Title); result.Body = ReportHelper.TextToHtml(order.Description); result.Footer = "<b>" + APP_NAME + "</b>"; result.Footer += " CopyRight © " + DateTime.Now.Year; return result; } !
  • 46. Principles! Better! private Report BuildReport(Order order) { var result = new Report(); result.Header = BuildReportHeader(order.Title); result.Body = ReportHelper.TextToHtml(order.Description); result.Footer = BuildReportFooter(); return result; } Much Better! private Report BuildReport(Order order) { var result = new Report(); result.Header = BuildReportHeader(order.Title); result.Body = BuildReportBody(order.Description); result.Footer = BuildReportFooter(); return result; } !
  • 47. Principles! Command-Query Separation (CQS)! Method performs an action OR returns data! Does code follow the principle?! if (SetAttribute("username", "Admin")) { // code } How to fix? if (HasAttribute("username")) { SetAttribute("username", "Admin"); // code }
  • 48. Order! The Stepdown Rule! Read code from top to bottom (by abstraction levels)! public Report BuildReport(IList<Order> orders) { // uses BuildReportLines and BuildReportTotal } private Report BuildReportLines(IList<Order> orders) { // uses BuildReportLine } private Report BuildReportLine(IList<Order> orders) { // code } private Report BuildReportTotal(IList<Order> orders) { // code }
  • 49. Arguments! How many parameters should a method have?! • Ideally 0! • Avoid methods with more than 2 arguments! Why?! • Harder to read (remember passing values)! • Increase coupling! • Harder to test (combinatorial growth of variants)!
  • 50. Arguments! Avoid boolean arguments! Why?! • Usually can be divided into two sections! • Hard to understand a purpose of an argument! BuildReportLine(order, true); private Report BuildReportLine(Order order, bool isMarked) { if (isMarked) { // build marked report line } else { // build simple report line } }
  • 51. Classes! Purposes. Principles. Interface. Encapsulation. Inheritance.!
  • 52. Purposes! • Simplify code • Improve readability! • Limit the scope of changes! • Hide implementation details (encapsulation)! • Allow to prepare generic solution (abstraction)! • Eliminate duplication (delegation & inheritance)! • Provide extensibility (inheritance)! • Allow to work with real domain entities!
  • 53. Principles! • Encapsulation! Hide as much as possible! • Compactness! Reduce class responsibilities (SRP)! • Abstraction! Program to an interface, not an implementation! • High Cohesion! Fields and methods should belong together!
  • 54. Interface! Methods should be on the same abstraction level! Does code follow the principle? Why?! class Program { public void InitializeCommandStack(); public void PushCommand(Command command); public Command PopCommand(); public void ShutdownCommandStack(); public void InitializeReportFormatting(); public void FormatReport(Report report); public void PrintReport(Report report); public void InitializeGlobalData(); public void ShutdownGlobalData(); }
  • 55. Interface! Programming over semantic! • Programming – can be checked by compiler! Amount of arguments! Argument types! • Semantic – cannot be checked by compiler! Method A should be called after method B! Method A throws exception when argument is not initialized! !
  • 56. Encapsulation! • Not public should be private ! private → public! • No direct access to fields! private decimal _x = 0; public decimal X { get { return _x; } set { _x = value; } } • No assumptions about class clients! // param2 should be > 0, in other case method fails public int Method(int param1, int param2) !
  • 57. Inheritance! Should be able to say that child ‘is’ parent! Circle is Shape HtmlParser is Parser! Does code follow the principle?! class Customer { public int ID { get; set; } public string Name { get; set; } } class Bank: Customer { public string CorrespondentAccount { get; set; } } Depends on whether a bank can be a customer or not! !
  • 58. Inheritance! Move common methods to base class! abstract class Stream { public void Write(byte[] bytes); public byte[] Read(); } class SecureStream: Stream { public void Init(StreamConfig config); } !
  • 59. Inheritance! Avoid following situations:! • Parent class has only one child! • Child overrides method leaving it empty! • Too many hierarchy levels! better not more than 3 levels!
  • 60. Comments! Commenting principles. Bad comments. Good comments.!
  • 61. Commenting Principles! • Comments do not redress bad code! clean code much better than bad code with comments! • Do not comment tricky code – rewrite it! tricky code = bad code! • Try to explain with code! // is employee eligible for bonus if ((employee.Schedule == HOURLY_SCHEDULE) && employee.Age > 65) { … } ! Better! if (employee.IsEligibleForBonus()) { … }
  • 62. Commenting Principles! Comment says “why” not “how”! • How! // if flag equals to zero if (accountFlag == 0) • Why! // if new account created if (accountFlag == 0) • Code instead of comment! if (accountType == AccountType.NewAccount)
  • 63. Bad Comments! • Redundant comments! obvious and repeating code! // closing connection Connection.Close(); • Commented code! remove unnecessary code, VCS is for the rescue InputStream response = new InputStream(); response.SetBody(formatter.ResultStream, formatter.BytesCount); //InputStream resultStream = formatter.ResultStream; //StreamReader reader = new StreamReader(resultStream); //response.SetContent(reader.Read(formatter.BytesCount));
  • 64. Good Comments! • Legal comments! license, copyright, author! • Explanations! provide info about inevitable tricks // NOTE: postpone execution to refresh UI setTimeout(function() { // code }); • TODOs! notes for future to avoid “broken windows” // TODO: get rid of tricky workaround function badFunction() { // tricky workaround here });
  • 65. Thank you!! Your questions, please!! ARTEM TABALIN!
  • 66. References! • Steve McConnell Code Complete! • Robert C. Martin Clean Code! • Hunt A., Thomas D. The Pragmatic Programmer ! • Craig Larman Applying UML and Patterns! • Kent Beck Implementation Patterns! • Eric Evans Domain-Driven Design!