programming-concepts/programming_concepts.txt at master · speakingcode/programming-concepts · GitHub

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
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
Programming Concepts
copyright @speakingcode (http://speakingcode.com)
Creative-Commons Attribution-ShareAlike 4.0 International License (CC BY-SA 4.0)

This is an outline of programming concepts and related topics of interest to new and seasoned programmers alike.

Basic Programming
  variables
  primitive types
    string
    integer
    decimal/float
    char
    boolean
    ...

  operations
    add
    multiply
    divide
    concatenation
    comparison (==, >, <, !=, etc...)
    ...

  collections
    array/list
    dictionary/hash/associative array

  loops
    while
    for

  execution flow
    if
    switch/case

  functions
    function calls
    defining functions
    return types
    parameters
    local variables
    pass-by-balue
    pass-by-reference

  event-driven programming
    asynchronous operations
    callbacks


Object Oriented Programming
  classes/objects
  member variables/fields
  methods
  message passing/method calls
  interfaces
  inheritence
  polymorphism
  encapsulation
  cohesion
  coupling

  OOP design principles
    KISS
    DRY
    SOLID
      single repsonsibility principle
      open/closed principle
      liskov substitution principle
      interface segregation principle
      dependency inversion principle
    GRASP
    packaging/namespacing
    abstraction/refactoring
    design patterns
      singleton
      factory
      command
      decorator
      iterator
      memento
      dependency injection
      observer/publish-subscribe
      ...


Data Structures & Algorithms
  ADTs
  arrays
  circular arrays
  linked-lists
  doubly-linked lists
  hashes/maps
  stacks
  queues
  trees
  binary trees
  balanced trees
  r/b-trees
  heaps
  tries

  run-time complexity
    asymptotic bounds/big oh
    operation costs (insert, remove, append, find)

  sorting
    insertion sort
    bubble sort
    merge sort
    quick sort
    heap sort
    bucket sort

  searching
    binary search

  recursion
  dynamic programming

Databases
  relational
    tables
    primary keys
    foreign keys
    data integrity
    cascade operations
    views
    normalization

    SQL
      insert
      update
      select
      delete
      joins

    PostgreSQL
    MySql

  non-relational/no-sql
    key-value stores
      redis, etc.
    document databases
      mongodb, etc.

Web/Enterprise
  HTTP
    GET
    POST
    PUT
    DELETE
  REST
  JSON
  XML
  SOAP (ew?)

Programming in Practice

  general
    interpreters/repl shells
    compilers

  reuse
    libraries/modules/packages

  architecture/platform
    frameworks
    SDKs

  version control
    git
      commit
      stash
      branch
      merge
      fork
      ...

  debuggers
    break points
    step through/into
    inspection
    ...

  grep/regex/pattern matching