Skip to content

Latest commit

 

History

History
151 lines (132 loc) · 8.03 KB

13-Conclusion.md

File metadata and controls

151 lines (132 loc) · 8.03 KB

Conclusion

Programming Paradigms are Just Different Styles to Structure and Organize Software

paradigms
  • The different paradigms are not better or worse than each other, they are just different styles to structure the state and behavior of software to provide a solution.
  • Paradigms are not independent, Different paradigms can be combined to create a program that is easier to understand and maintain.
  • Paradigms are not frozen and are constantly evolving as new ideas are added to the software development methods to make creating software easier and more effective.
  • Each paradigm has its own benefits, costs, and trade-offs that must be considered when choosing which paradigm is appropriate for a particular problem.

    Often, the best solution is the simplest one.

  • Paradigms are not dogma, and should not be followed blindly, but should be used as a guide to help structure and organization the program to be easiest to understand and change.

You Can Only Learn Programming By Actually Programming

learning_programming
  • The best way to learn programming that I've found is to physically copy (actual typing) other programs and change them.

  • You can read all the books and watch all the videos you want, but you will not learn programming until you actually start solving problems, and seeing how other people solve them is a great start.

  • IT IS VERY IMPORTANT THAT YOU TRY TO CHANGE THE CODE AFTER YOU HAVE COPIED IT. THIS IS CRITICAL.

  • Doing "code katas" and "coding challenges" are a great way to practice programming and learn new programming languages and paradigms.

  • But after you know the mechanics, the bigger challenge is to learn how to structure and organize the state and behavior of the software to be easiest to understand and change.

  • This is a life-long learning process, and how to arrange ideas and concepts to make them easier to understand and change is a skill that takes time and practice to develop, and only comes with experience and some luck.

    Stop Studying Programming

    BEWARE THE PROGRAMMING TUTORIAL TAR-PITS

    • Always code-along with the tutorial, and change it afterward to make sure you understand.
    • Learn how to save your projects to GitHub, it's not hard, and you will be able to track your progress.

    If you ONLY just watch, it WILL BE A COMPLETE waste of time, even though you THINK you understand it.

QUIT LOOKING FOR SHORT-CUTS

short-cuts
  • The biggest problem I've seen with people trying to learn programming is that they are looking for a short-cut.

  • QUIT IT AND GET IN THERE AND START TYPING AND CHANGING CODE.

  • All developers must pay the same price to learn programming, and that price is time and effort.

Programming Will Always Be a Human Activity - AI Cannot Possibly Solve Everything and Requires Human Guidance

programming-is-human
  • Solution methods will become a bit more abstract in the future using tools like GitHub copilot, but the programmer will still need to know all these details to get the machine to do EXACTLY what they want it to do.

  • We are always going to need people who have various tastes and understandings about humans and the world to create software that is useful and effective FOR THOSE PARTICULAR HUMANS.

My Favorite Book on Learning Kotlin

$\textcolor{yellow}{Please\ consider\ giving\ me\ a\ STAR\ as\ THANKS!\ ⭐️ 🤩}$

History Graph of Selected Programming languages Referenced In This Document

history-graph

Keynote session: The History of Programming - Mark Rendle [DevCon 2016]

  graph TB
      MachineLanguage{{Machine Language}} -->|human readable mnemonics| AssemblyLanguage
      AssemblyLanguage{{Assembly Language}} -.->|Procedural & Interpreted|Basic
      AssemblyLanguage{{Assembly Language}} -->|Procedural|COBOL
      AssemblyLanguage{{Assembly Language}} -->|Procedural|Fortran
      AssemblyLanguage{{Assembly Language}} -->|Structured|Algol68
      AssemblyLanguage{{Assembly Language}} -->|Structured + low-level|BCPL
      AssemblyLanguage{{Assembly Language}} -->|Structured|C
      AssemblyLanguage{{Assembly Language}} -->|List-oriented|Lisp
      
      COBOL{{"COBOL"}} -.->|"Easy to
                            Learn Syntax
                            ⚡️️"|Basic
      Basic{{"BASIC"}} ---> VisualBasic
      Fortran{{"Fortran"}} -.->|"Evaluate 
                                Formulas
                                ✨"|Basic
      Algol68{{Algol60, Algol68}} -.->|"for structures, 
                              scopes & syntax
                              ⚡️️
                              "|C
      BCPL{{"BCPL"}} -->|"for types, structures 
                          low-level compilation
                          ✨"|C
      Algol68 --> BCPL 
      BCPL --> Simula67
      Algol68 --> Simula67
      Simula67{{"Simula67"}} -.->|"for pointers & 
                                  other concepts
                                  ✨"|C
      Simula67 -.->|for OOP ideas|Smalltalk
      C{{"C"}} -->Cplusplus
      C -.->Smalltalk
      Simula67 -.->|for COP ideas|Cplusplus
      Cplusplus{{"C++"}} -->|for COP/pseudo-OOP ideas|Java
      Smalltalk -..->|"absconded OOP term 🫤 
                      & some ideas
                      🤔🤨🧐"|Cplusplus
      Java{{Java}} -->Kotlin
      Java -->CSharp
      CSharp{{"C#"}}
      Fortran -.->Algol68
      Smalltalk{{"Smalltalk
                Originator of term OOP
                🙂"}} -.->|for OOP ideas|Javascript
      Smalltalk -.->|for OOP ideas|Ruby
      Smalltalk -.->|"encapsulation
                     messaging
                     🙂"|HyperTalk
      Basic -.-> |"for Interpreted & 
                  interactive
                  ⚡️"|Smalltalk
      AssemblyLanguage-.->|"for self-modifying 
                            code @ runtime
                            ✨"|Smalltalk
      
      Lisp{{"Lisp"}} -.->|internal syntax|Javascript
      Java--->|for syntax|Javascript
      Kotlin{{Kotlin}}
      Ruby{{Ruby}}
      HyperTalk{{HyperTalk}}
      Javascript{{Javascript}}
      VisualBasic{{"Visual Basic"}}
  
  X("X") ---> |means Y descended from X.| Y("Y")
  A("A") -..-> |means A influenced B.| B("B")
  Note("Conceptual Inheritance Graph of Selected Languages.
        OOP Ideas = classes, inheritance, polymorphism.
        
        Not exhaustive, not to time scale.
        ⨭⨂⨀⨁⨮")
  
Loading