Coding

Case style

Consistency of case styles.
- camelCase : myFunction
- snake_case : my_function
- PascalCase : MyFunction
What is your team standard?
For python, you must follow PEP8
For GO, it's just built-in.

Variable

Variable name
- No ambiguous naming. To avoid naming confusion, give a equal weight in the same group.
  For example:
  var counter = 0; var processCounter = 0;
  When you have complicated codes, it's easy to get confused with those two names.
  You need to explicit what each variable for and to name them equivalent weight. For example:
  var elementCounter = 0; var processCounter = 0;
  Make your model clear(object/table), give each model a distinguish name.
Naming consistency.
When abbr is used in the variable name : For example:
```
  var prev = 0;
  var cur = 0;
```
It's better to name them in the same length. For example:
```
  var prev = 0;
  var curr = 0;
```
Better house keeping, easy to maintain and easy to read.
Variable verbose For example : Good
```
  key = "hello"
  value = "world"
  call(key, value)
```
- Clear variables definition.
- Easy to understand and maintain.
- Easy to debug.
  Not wrong, but no Good.
  call("hello", "value")

Variable i, j, k Only use in for loop counter.

  for (var i=0; i <length; i++) {

  }

It's no good to be a variable which is implicit.

  var i = "hello".indexOf("l");

Try this way :

  var idx = "hello".indexOf("l");

Singular or Plural
- When a variable is to hold a collection, then name it with Plural.
  For examples :
  1. Plural
    var books = getBooks()
  2. List, Array
    var bookList = getBookList()
    It's to recommend to use 2.
  3. You want to get away getBook() and getBooks() typo.
  4. You want to get away the irregular plural,
    like getCategory() and getCategories()

Use variable or not? In triplet count python code, there are 3 of i*r

  def count_triplets(arr, r):
          count = 0
          dict = {}
          dictPairs = {}

          for i in reversed(arr):
                  if i*r in dictPairs:
                                  count += dictPairs[i*r]
                  if i*r in dict:
                                  dictPairs[i] = dictPairs.get(i, 0) + dict[i*r]

                  dict[i] = dict.get(i, 0) + 1

          return count

Let's just give a variable for it

  def count_triplets_3(arr, r):
          count = 0
          dict = {}
          dictPairs = {}

          for i in reversed(arr):
                  prod = i*r
                  if prod in dictPairs:
                                  count += dictPairs[prod]
                  if prod in dict:
                                  dictPairs[i] = dictPairs.get(i, 0) + dict[prod]

                  dict[i] = dict.get(i, 0) + 1

          return count

It's worthy to give a varible for it? Let's take a look at the performance at 1000000.

  d:\dvp\python\hackerrank>python src\count_triplets.py
  count_triplets  : 0:00:02.621734
  count_triplets_3: 0:00:02.252786

  d:\dvp\python\hackerrank>python src\count_triplets.py
  count_triplets  : 0:00:02.626448
  count_triplets_3: 0:00:02.250635

  d:\dvp\python\hackerrank>python src\count_triplets.py
  count_triplets  : 0:00:02.632636
  count_triplets_3: 0:00:02.246863

The change has better performance in a long run. That can be arguable if without extensive looping. To avoid compute the same thing again, should have a variable for this.

Global variable
- Unless global constant, avoid to use that.
- Be careful multiple threads.
Typo
- It's your foe and friend.
- Turn on your spellChecker.
  - In VS code, code spell checked can check all words spelling, included camel case and snake case.
- Read again after typing.
- In the VSCode, just get used to intelliSense.
  It's your code hint and pick the variable from the dropdown.
  If not in there, you have typo.

Block

Code block
- Easy to read
  - In a logic section, try to fit in a "visible" screen.
  - Then, you reduce to scroll your screen up/down.
  - You certainly want to focus to work on your code, not lost after jumping around.
- Logical section
  - Avoid long codes in a function.
  - Break into small inner function or make logical section.
  - Space and line break : leave a space line in between logic section
- For long function, please each argument to each line. For example
  call( arg1, arg2, arg3, arg4, ... )
  not very good
  call(arg1, arg2, arg3, arg4, ...)
  - You read code from top down with logic connected, not scrolling left right to trace your logic.
  - The same rule apply to chaining function.
- Function/Block
  - Define the variable in the beginning.
  - Return the result at the end.
  - Logic in the middle.
- End of line
  - In the javascript, always put ";" at the end of line.
Bracket match
- {} () match Use
  if (a > b) { a++; }
  Not in shorter
  if (a > b) a++;
  The paired bracket symbols may get your codes more verbose, but more organized.
Indentation
- Tab / Space Consistency
  - My favor : two spaces for a tab key.
  - I consider this is most important when coding.
- For Python, follow PEP8 style guide
- For IDE, please apply lint.

Comment

Function : write a description and explain all parameters.
- If you have very obvious name, still put one line function.
  In the future, you may ask for to delivery document, then you are happy to go.

Inside code:

  def get_second_high_number(arr):
          ''' Get the second large number '''
          # Sort unique list with set
          sorted_set = set(arr)
          # Convert set back to list
          sorted_arr = list(sorted_set)
          second_high_number = 0
          #check if array is more than one item
          if len(sorted_arr) > 1:
              # Get the last second number as second high number
              second_high_number = sorted_arr[-2]
          return second_high_number

Looking good or something wrong?

How about regroup comments like this

  def get_second_high_number(arr):
          ''' Get the second large number '''
          # Sort unique list with set(sorted_set)
          # Convert set back list (sorted_arr)
          # Get the last second number as second high number (second_high_number)
          sorted_set = set(arr)
          sorted_arr = list(sorted_set)
          second_high_number = 0
          if len(sorted_arr) > 1: #check if array is more than one item
              second_high_number = sorted_arr[-2]
          return second_high_number

Try to got logic connected.

Actually, it's not really to have such verbose comments if you can all of variable naming clear.

TODO: Add TODO comment if need further polish.

Brain Melting Coding

With sugar syntax, condense multiple line codes into one line.
- Make you look smart.
- Keep your job secure?
- Modern language trend?
This is a balance between better coding and easy understanding.
The Rule of thumbnail to use that:
- Debugger can make a stop to this single value
- Necessary modern language trend.
- Good code structure.

Best practice

Team's decision > Yours
Follow the standard.
- For example : use PEP8 style for python.

PreviousArray NextAPI

Last updated 4 years ago

Was this helpful?