The

Programmer
Dream

My personal Strategy to
coding in months

By Rehteel
 Hi girlie
You have nothing
to worry about. In
this mini guide I
will tell you about
what you need to
learn and my
personal strategy
on how I learned
to code in 5
languages at once.
Yes, it’s easy and
yes you can do it.

Stay consistent,
manage your
time, and never
give up on
yourself.
 First and foremost,

I never ever recommend

learning from the basics.
I mean sure you want to
understand arrays, and
functions, and what an ‘if
else’ statement is. But after
you have covered the overall
meaning of every term. You
want to put it in practice.

All of the topics are the

SAME in every programming
language. What separates
them is the way they are
written depending on the
language.
 Languages

1. Python: Data science, web

development, automation.
2. JavaScript: Frontend and backend
web development, mobile apps.
3. Java: Enterprise applications,
Android development.
4. C++: System software, game
development.
5. C#: Web applications, game
development.
6. Ruby: Web development, scripting.
7. PHP: Web development, CMS.
8. Swift: iOS/macOS apps, server-side
development.
9. Go: Cloud services, microservices.
10. Kotlin: Android development, cross-
platform apps.
Here is what we will cover:
Languages and what
they are used for
Basics
Advanced Control Flow
Data Structures
Object-Oriented
Programming (OOP)
Functional
Programming
MY SPECIFIC
STRATEGY AND HOW I
LEARNED
 Basics
1. Syntax
2. Variables and Data
Types
3. Operators
4. Expressions
5. Control Structures
Conditional
Statements (if, else,
switch)
Loops (for, while,
do-while)
 Understanding Core Concepts

Syntax: The set of rules that define

the structure of code. Knowing the
syntax of a programming language
is fundamental for writing correct
code.

Variables and Data Types: Variables

store data, and understanding data
types (e.g., integers, floats, strings) is
essential for manipulating and using
this data effectively.

Operators: Operators (e.g.,

arithmetic, logical, comparison) are
used to perform operations on
variables and values. Knowing how
to use them is crucial for performing
calculations and making decisions.
Controlling Program Flow

Expressions: Combinations of
variables, operators, and values that
produce a result. They are the building
blocks for more complex logic.

Control Structures:
Conditional Statements (if, else,
switch): Allow the program to make
decisions based on certain
conditions, leading to different
execution paths.

Loops (for, while, do-while): Enable

repetitive execution of code blocks,
making it easier to perform tasks
that require iteration.
Building and Organizing Code

Functions/Methods: Encapsulate
blocks of code into reusable units,
promoting modularity and
reducing code duplication.
Functions are fundamental for
structuring code and managing
complexity.

Error Handling

Basic Exception Handling:

Mechanisms to manage and respond
to errors and exceptional conditions
during program execution. This is
crucial for building robust and
reliable applications.
Advanced Control
Flow

1. Functions/Methods
2. Recursion
3. Exception Handling
4. Concurrency and
Parallelism
5. Asynchronous
Programming
Functions/Methods

Encapsulation and Reusability:

Functions allow you to
encapsulate a block of code,
making it reusable and easier to
manage.

Modularity: Functions break

down complex problems into
smaller, manageable pieces,
facilitating modular design and
development.

Abstraction: They provide a way

to abstract away details,
focusing on the high-level
functionality.
Recursion

Simplifying Problems:
Recursion provides a way to
solve problems that can be
broken down into similar sub-
problems (e.g., tree traversal,
factorial calculation).

Elegant Solutions: Recursive

solutions can be more elegant
and easier to understand than
their iterative counterparts for
certain problems.
Exception Handling

Error Management: Exception

handling mechanisms allow you
to manage and respond to
runtime errors, improving the
robustness and reliability of
your code.

Separation of Error Handling

Logic: It separates the error-
handling logic from the main
logic of the program, making
the code cleaner and easier to
maintain.

Graceful Degradation: Helps in

creating programs that fail
gracefully rather than crashing
unexpectedly.
Concurrency and Parallelism

Performance Optimization:
Concurrency and parallelism are
used to improve performance by
executing multiple tasks
simultaneously, making efficient
use of multi-core processors.

Responsiveness: They are

essential for creating responsive
applications, particularly in user
interfaces where tasks like data
loading should not block the main
thread.

Resource Management: Efficiently

manage resources and time,
especially in systems where
multiple tasks need to be handled
concurrently (e.g., web servers,
real-time systems).
Asynchronous Programming

Non-Blocking Operations:
Asynchronous programming
allows for non-blocking
operations, enabling programs to
handle I/O-bound and network-
bound tasks efficiently.

Improved Throughput: It
improves the throughput and
responsiveness of applications by
allowing other tasks to run while
waiting for I/O operations to
complete.

Event-Driven Architectures:
Essential for event-driven
programming where operations
depend on the occurrence of
events (e.g., user actions, message
passing).
 Data Structures

1. Arrays
2. Lists
3. Stacks
4. Queues
5. Trees
6. Graphs
7. Hash
Tables/Maps/Dictionaries
8. Sets
9. Tuples
10. Linked Lists
Arrays

Definition: A collection
of elements, typically of
the same type, stored in
contiguous memory
locations.

Uses: Efficiently access

elements by index, store
and manipulate
collections of data.

Examples: Storing a list

of items, implementing
other data structures
like stacks and queues.
Lists

Definition: An ordered
collection of elements that
can grow and shrink
dynamically.

Types: ArrayLists
(dynamic arrays),
LinkedLists (nodes with
pointers to next/previous
nodes).

Uses: Flexible data

storage where the size
can change, implementing
queues and stacks.
Stacks

Definition: A collection of
elements that follows
Last-In-First-Out (LIFO)
principle.

Operations: Push (add

element), Pop (remove
element), Peek (view top
element).

Uses: Function call

management (call stack),
backtracking algorithms,
undo mechanisms
Queues
Definition: A collection of
elements that follows First-
In-First-Out (FIFO)
principle.

Operations: Enqueue (add

element), Dequeue (remove
element), Front (view first
element).

Uses: Task scheduling,

breadth-first search (BFS)
in graphs, buffering in
data streams.
Trees

Definition: A hierarchical data

structure consisting of nodes,
with a single root and
potentially many levels of
additional nodes.

Types: Binary Trees, Binary

Search Trees, AVL Trees, B-
Trees, Heaps.

Uses: Represent hierarchical

data (file systems,
organization charts), search
and sort operations (binary
search tree), priority queues
(heaps).
Graphs

Definition: A collection of
nodes (vertices) connected
by edges.

Types: Directed and

undirected graphs,
weighted and unweighted
graphs.

Uses: Representing
networks (social networks,
computer networks),
pathfinding algorithms
(Dijkstra’s, A*), dependency
resolution.
 Hash
Tables/Maps/Dictionaries

Definition: A data
structure that maps keys
to values for efficient
lookup.

Operations: Insert, delete,

and search by key.

Uses: Fast data retrieval

(database indexing,
caches), implementing
sets and dictionaries.
Sets

Definition: A collection
of unique elements.

Operations: Add,
remove, check
membership.

Uses: Eliminating
duplicates,
mathematical set
operations (union,
intersection).
Tuples

Definition: An ordered
collection of elements,
typically of different
types, that is
immutable.

Uses: Returning
multiple values from a
function, grouping
related data.
Linked Lists

Definition: A linear collection

of elements, called nodes,
where each node points to
the next node.

Types: Singly Linked List,

Doubly Linked List, Circular
Linked List.

Uses: Dynamic memory

allocation, easy
insertion/deletion of
elements, implementing
other data structures like
stacks and queues.
 Object-Oriented
Programming (OOP)

1. Classes and Objects

2. Inheritance
3. Polymorphism
4. Encapsulation
5. Abstraction
6. Interfaces and
Abstract Classes
Classes and Objects

Class: A blueprint for

creating objects.
Defines a type, including
data attributes and
methods to manipulate
that data.

Object: An instance of a
class. Represents an
entity with attributes
(data) and behavior
(methods).
Encapsulation

Definition: Bundling data

(attributes) and methods
that operate on the data into
a single unit (class).

Access Control: Restricting

access to certain parts of an
object’s data and methods
using access modifiers
(private, protected, public).

Uses: Protecting the integrity

of an object’s data,
preventing unauthorized
access and modification.
Inheritance

Definition: Mechanism by which

one class (child or subclass) can
inherit attributes and methods
from another class (parent or
superclass).

Types: Single inheritance (one

parent), multiple inheritance
(more than one parent), and
multilevel inheritance (inheritance
chain).

Uses: Reusing existing code,

creating a hierarchical
relationship between classes,
extending or modifying
functionality.
Polymorphism

Definition: Ability of
different objects to
respond to the same
message (method call) in
different ways.

Types: Compile-time
(method overloading) and
runtime (method
overriding) polymorphism.

Uses: Designing flexible

and scalable systems,
allowing objects to be
treated as instances of
their parent class rather
than their actual class.
Abstraction

Definition: Hiding complex

implementation details and
showing only the necessary
features of an object.

Uses: Reducing complexity,

increasing efficiency, and
enhancing code readability
and maintainability.
These are topics that
are covered in most
languages.

These are short

definitions to
understand what you
are getting into! You
can dive deeper later
on depending on
what language you
are learning with
 My personal Strategy...
First go to Youtube. Trust me girl,
that is your best friend.

After you pick a language, search

for projects in that language.

PROJECTS ONLY.

Grab one to thirty projects and add

all of them to a playlist. I say this
number because you will be doing
this for a month. One project daily.

Pick the ones that appeal to you.

YOU know yourself best. Pick what
sparks your excitement and what
you look forward to completing!
 Continued....
In my personal experience, a 10
minuet project would take me
around an hour to complete. And
that is WITH understanding. A lot
of videos have vague
explanations, so that would
mean I have to step up and learn
on my own.

Manage your time and see how

long it would take you to do a 5
minuet project.

That way, you know what is

coming in the upcoming days for
projects that have a longer time
stamp.
 STEPS:
1. After you pick a project. Open
VScode, and text editor or
word document.
2. you will give yourself
directions on how you will
code the project.
3. Copy every line of code AS
YOU GO ALONG, and go to
chatgpt. Ask it to explain the
line of code to a 15 year old. It
will simplify it enough to keep
it professional + easy. Do this
LINE BY LINE. Not multiple at
once, unless it is a function.
4. You will either copy it or type
it in your own words. Under
your instructions you will give
yourself an explanation. Plus
the block of code at the very
end.
After you complete the full
project. Close the video, and
open a new VScode window.

Because now you will follow

your own instructions to do the
project. As you go along, read
the explanation.

RE- explain it to yourself while

you code.

repetition is golden here. Your

mind will soon pick up on what
the code is doing, what comes
first, and how it needs to be
formatted.
OPTIONAL:

CODE THE PROJECT

A THIRD TIME.
NO EXPLANATION
OR INSTRUCTIONS.
TEST YOURSELF.
 And that’s it!
By doing one project daily. A
short one. Twice, maybe three
times a day. You are training
your brain to become familiar
with the code implemented.

When you move to a different

project the next day, you
already have experience.

Not only are you building

projects and understanding
them... But you are also building
your portfolio and GitHub!
With this guide I have
added my personal
instructions to
myself when I built a
quiz app using
Javascript, HTML, and
CSS. After you read
through it, do your
best to follow along!
It won’t be easy.

Wake up earlier, sleep later, cancel

plans, distance yourself and find
passion in what you do.

Don’t wait for the perfect plan, or the

right moment, or for when you have
time.

Know you are not too late and you

are exactly where you need to be.
Trust yourself. Trust your learning
process. Most importantly, believe in
yourself. You got this.

Kisses - Rehteel