
Controlling electronic components like sensors, buttons, LEDs, or even
motors has been made easy using an Arduino. The most basic example is the
ability to blink an LED. Once your skills and knowledge evolve so will your
projects. You could use the builtin LED that is located on the Arduino board
but for this example we will add our own LED. For this example I am using an
Arduino UNO R3 but any standard Arduino should work. The pictures you see
here were made using [TinkerCAD](https://www.tinkercad.com/), a free to use
software to practice using the Arduino without having any of the hardware!

### What you will need

- Computer to write code
- Arduino
- breadboard
- 2 male to male jumper cables (not pictured here)
- LED
- 220 ohm resistor

<Image src="/images/sketch.png" />

### Building the circuit

Luckily the circuit we are making is extremely simple with very little room
for errors. We will be hooking our components up to the breadboard. As
current can only flow in one direction through the LED, you will need to
ensure your wiring is correct or the LED will not work at all. The longer
and sometimes bent leg of the LED is known as the Anode(+). This is where
the power source should be connected. The other end which is usually shorter
is known as the Cathode (-). This is where you should connect the ground.

We will also be using a 220ohm resistor to connect the LED. The reason being
is that an average LED can only handle about 10-20mA. Without the resistor
the LED will shine brightly for a couple of seconds and burn out quickly
after.

Use the diagram below to connect everything. This complete circuit swill
have a signal or output coming from DIGITAL PIN 2, through the LED, the
resistor then back to the Arduino ground. We are using the digital pins
because we want to control the LED, alternatively you could just turn the
LED on by moving the wire from PIN 2 to 5V:

<Image src="/images/sketch1.png" />

### Coding the circuit

Now that our circuit is put together we can move on to writing the code to
implement the blinking LED. I will be using TinkerCad but for actual
projects it is recommended to create all of your programs though the
[Arduino IDE](https://docs.arduino.cc/software/ide-v2/tutorials/getting-started/ide-v2-downloading-and-installing).
With every program on an Arduino you will find two main functions. The
setup function and the loop function. In the setup function you general
assign the pins to a mode, usually INPUT or OUTPUT. It is usually a good
idea to assign variables in a program. Variables allow you to store
information that can be reused in different areas of the code

```c++
int ledPin = 2;
```

**int** is the identifier that tells the program what kind of value
will be stored in the variable ledPin. In our case it is an integer (int). You could
name it something other than ledPin like myPin but something more descriptive is
common convention. Next we want to assign our ledPin a mode. We will do this in the
setup function:

```c++
void setup() {
pinMode(ledPin, OUPUT);
}
```

After the setup is done we will create our loop. A function that literally
loops continuously unless power is cut or logic is in place to pause or stop
it. In this loop the LED will turn on for one second and then turn off for
one second and repeat.

```c++
void loop() {
    digitalWrite(ledPin, HIGH);
    delay(1000);
    digitalWrite(ledPin, LOW);
    delay(1000);
}
```

The complete code looks like this:

```c++
int ledPin = 2;

void setup() {
pinMode(ledPin, OUPUT);
}

void loop() {
    digitalWrite(ledPin, HIGH);
    delay(1000);
    digitalWrite(ledPin, LOW);
    delay(1000);
}
```

And that's it! Run or upload the code to the Arduino to start blinking the
LED! Try manipulating the microseconds for the delay to change how fast the
LED blinks!

Youtube video guide coming soon! Thanks for reading!


Blink a LED with an Arduino


Web development can be a daunting path if you don't know where to start or
what tools to use to get the job done quickly but efficiently.
In order to make your life easier, below you will find a list of some of the
most common tools that web developers use.

### Integrated Development Environment (IDE)

Before you start any project you will need an environment and/or text editor.
Arguably the most popular IDE used is known as [Visual Studio Code](https://code.visualstudio.com/)
or VS Code for short. VS Code offers an all in one solution for nearly any
web application or programming need. [Sublime Text](https://www.sublimetext.com/) is another great and popular option.
It may not be as robust as VS Code but it has everything you need to get started.

<Image src="/images/vscode.jpg" size="40rem" />

### Learning Resources

There is a near limitless amount of free and paid resources all over the
internet. The most familiar to you might be none other than YouTube. Just
simply find your favorite content creator and you're off to the races.
However, many channels may lack structure or a sense of consistency. A few
of my favorite creators that offer full series or videos that give you more
than enough basics to survive are [FreeCodeCamp](https://www.youtube.com/c/Freecodecamp),
[Web Dev Simplified](https://www.youtube.com/c/WebDevSimplified), and [Bryan Dunn](https://www.youtube.com/channel/UCf_Y89gbkB1bJGkmqiQIAnQ/videos).
If you don't mind paying a small fee for premium courses with much more
structure then [Udemy](https://www.udemy.com/) and [Codecademy](https://www.codecademy.com/)
are well worth the price of admission and frequently offer sales .

### Creative Common Images

One of the more annoying struggles when building web applications is the
need for images and scouring the web for creative common media that can be
freely used. Filtering through google with Creative Common license selected
in image search is useful but surprisingly limited in what is shown.
[Unsplash](https://unsplash.com/) is a great platform that offers images that can be used for placeholder
items or permanent places in your application since their content is free to
use, not excluding commercial use. A paid alternative is known as
[FreePik](https://www.freepik.com/), which offers of plethora of images, svgs, templates icon packs, and more.

### General Inspiration

When you start working in a Web Development career you will likely work with
one or more Designers that develop the User Interface (UI/UX) for your
product(s). As a Developer your job will be to make their concepts come to
life in production. That's all fine and dandy but what about working on your
own side project? Who will create your mock ups? Are you creative enough to
come up with detailed designs? If so, great. You can skip this part. Others
are not so lucky, and I for one am not very creative when it comes to UI
design. [Dribble](https://dribbble.com/) and [Pinterest](https://www.pinterest.com/)
have been the most useful by far. Dribble is specifically made for designers
and web developers. Whether you need ideas for a logo, animation or a cool dashboard
interface, Dribble is a great option. I encourage you to create an account and start
saving ideas in "collection" for future uses. Pinterest is for all that and more
but also have a large variety of UI concepts for inspiration.

<Image src="/images/dribble.png" size="35rem" />

### Color selection

Lastly, you will likely need a color scheme for your project if you are
looking to make things more visually appealing. You can browse a variety of
color palletes at [Coolors](https://coolors.co/), and even create your own that give you different shades, hex, or rgb
values to use directly. If you want some more insight in which color
combination you should use or the importance of color selection, check out
this [article](https://99designs.com/blog/tips/the-7-step-guide-to-understanding-color-theory/) on color theory.

<Image src="/images/coolors.png" size="28rem" />

### Summary

The mentioned resources and tools have helped me along the way but there are
many more. Take what you can and make your own list of resources. In
general, I.T. fields move fast so best practice is to find something
consistent that works for you and never stop learning. Best of luck. Here is
a list of all mentioned tools and resources:

- IDE
  - [Visual Studio Code](https://code.visualstudio.com/)
  - [Sublime Text](https://www.sublimetext.com/)
- Learning Resources
  - [FreeCodeCamp](https://www.youtube.com/c/Freecodecamp)
  - [Web Dev Simplified](https://www.youtube.com/c/WebDevSimplified)
  - [Bryan Dunn](https://www.youtube.com/channel/UCf_Y89gbkB1bJGkmqiQIAnQ/videos)
  - [Udemy](https://www.udemy.com/)
  - [Codecademy](https://www.codecademy.com/)
- Creative Common Images
  - [Unsplash](https://unsplash.com)
  - [Freepik](https://www.freepik.com/)
- General Inspiration
  - [Dribble](https://dribbble.com/)
  - [Pinterest](https://www.pinterest.com/)
- Color selection
  - [Coolors](https://coolors.co/)
  - [Color Theory article](https://99designs.com/blog/tips/the-7-step-guide-to-understanding-color-theory/)


Resources and Tools for Web Development


When pushing your web application to production or even GitHub, it is a good
idea to keep your API keys or other sensitive information away from prying
eyes. Creating environment variables is a great way to do this and the
python-decouple package makes it easy for us. To install, cd into your project and
activate your virtual environment if you have one.

```
pip install python-decouple
```

Next, create a .env file at the root of your project and add any environment
variables you wish. Here is an example .env file:

```python
SECRET_KEY=secretkeyvalue
DEBUG=True
EMAIL_BACKEND=django.core.mail.backends.smtp.EmailBackend
DEBUG=True
EMAIL_BACKEND=django.core.mail.backends.smtp.EmailBackend
EMAIL_HOST=smtp.gmail.com
EMAIL_PORT=587
EMAIL_USE_TLS=True
EMAIL_HOST_USER=user@gmail.com
EMAIL_HOST_PASSWORD=password
DBNAME=testdb
DBUSER=testuser
DBPASSWORD=password
DBHOST=localhost
```

In your settings.py file, import python-decouple like so.

```python
from decouple import config
```

Still in your settings.py file, here is an example of how to access the
values in your .env file.

```python
SECRET_KEY = config('SECRET_KEY')
```

With python-decouple you can cast values with the cast argument as
well as set default values in case the .env can't find the value or it is
missing entirely.

```python
DEBUG = config('DEBUG', default=False, cast=bool)
```

An extended example would be if you were to set up a database with Postgres,
you would access your .env values like this.

```python
DATABASES = {
    'default': {`
    'ENGINE': 'django.db.backends.postgresql',
    'NAME': config('DBNAME'),
    'USER': config('DBUSER'),
    'PASSWORD': config('DBPASSWORD'),
    'HOST': config('DBHOST') }
}
```

With this set up you can easily post the source code to GitHub without
worrying about exposing your application's secret key or any other sensitive
information. Just make sure you have a .gitignore file that doesn't upload
the .env file! Hopefully, this helps and makes your Django application that
much more secure.


Secure Django with Environment Variables


Whether you are familiar or not with the python programming language, these
Udemy courses will take you from the absolutely basics to building anything
you want. Limited to only your imagination. These are courses that I have
tried and used for reference many times. As a disclaimer, the courses on the
list that follows are all subjective:

### [1. 100 Days of Code: The Complete Python Pro Bootcamp for 2022](https://www.udemy.com/course/100-days-of-code/)

Angela Yu is one of my favorite Udemy instructors by far. All of her courses
are extremely detailed and filled with enthusiasm to keep you hooked. This
course is no different. As the title suggest it takes about 100 days to
complete the course completely. On average each lesson is about a hour in
length. Taking you from the very basic of the python syntax to games, web
app projects, to Graphical User Interface (GUI) programs, and more.

### [2. 2022 Python for Machine Learning &amp; Data Science Masterclass](https://www.udemy.com/course/python-for-machine-learning-data-science-masterclass/)

This course covers quite a bit more advanced concepts of the Python
language. I would recommend having the basics down before taking this one on
but there is also a python refresher included if needed. Python is one of
the most popular programming languages when it comes to Machine Learning and
Data Science so if you are interested in either, then this is right up your
alley.

### [3. Automate the Boring Stuff with Python Programming](https://www.udemy.com/course/automate/)

If you went through some of the material in the previously mentioned courses
then this course shouldn't be an issue. This course gives you plenty of use
causes for python to make your life easier. From basic web scraping,
controlling your computer mouse to click anywhere, to reading and writing
excel and other files. It is highly recommend if you are looking for
something quick and packed with good to know concepts.


Top 3 Python Udemy Courses


If you are like me then you have probably looked up tutorials on how to
install Nodejs and they were either too complicated or just did not work as
expected. Alas, with this method you should have the latest version of
Nodejs and npm ready to use within 5 minutes! For the most part, you can
simply copy and paste the commands. As with all things, you should keep your
system up to date prior to installing new packages. This method has worked
for Ubuntu version 20.04 but should work on most major Linux distributions.

```sh
sudo apt update && sudo apt upgrade -y
```

There are two common ways to download Nodejs. Via CLI using curl or wget or
navigating to the Nodejs website and downloading it from there. Note that
I'm using the x64 binary version.

```sh
wget https://nodejs.org/dist/v16.17.1/node-v16.17.1-linux-x64.tar.xz
```

```sh
curl https://nodejs.org/dist/v16.17.1/node-v16.17.1-linux-x64.tar.xz
```

If you choose to get it from the Nodejs website, you can click [here](https://nodejs.org/en/download/).
Extract the file with tar or your preferred method then move it a permanent location:

```sh
tar xvf node-v16.17.1-linux-x64.tar.xz
sudo mv node-v16.17.1-linux-x64 /opt/nodejs
```

Now, add it to your PATH. I am using nano text editor for this.

```sh
sudo nano ~/.bashrc
```

Add this line of code to the bottom of the file. Just make sure the location
is the same as where you moved the file. I put mine in the opt directory so
this is what it would look like. Remember to save the file after editing.

```sh
export PATH=/opt/nodejs/bin:$PATH
```

Now restart the terminal or use the following command.

```sh
source ~/.bashrc
```

That's it! Run these commands to make sure it got installed. If you ever
want to upgrade Nodejs to the latest version, simply download, extract and
overwrite the nodejs folder.

```sh
node --version
npm --version
```


Download NodeJS for Ubuntu


A requirements.txt file is mostly used in virtual environments. Virtual
environments provide a way to keep project dependencies isolated from other
installed packages on a system and reduce errors when transferring the
project to another location like another computer.

Many packages are updated regularly and oftentimes an issue can occur when a
package is updated within a project. A project could break entirely during
one of theses routine updates. You could also have the latest version of a package
and when someone tries to run the application With an older version, they will likely
come into some problems. With a requirements.txt file you have more
control over versions of installed packages. Now, whenever anyone else uses
the projects they will have the same dependencies as you.

Assuming you have PIP installed, run the following command to check what
packages you have installed. Your virtual environment should be running
before you enter this command.

```python
pip freeze
```

You may need to run python -m if the above command does not work. If that
doesn't work then you likely do not have pip installed.

```python
python -m pip freeze
```

Here is what it might look like.

<Image src="/images/python1.png" />

You can save this output to a requirements.txt like so

```python
pip freeze > requirements.txt
```

You should now have a requirements.txt file in your current working
directory with a list of installed packages. Now, when transferring your
project you can simply send only your requirements.txt file instead of your
entire virtual environment folder that has all the installed packages. If
you were to download a repository from Github with a requirements.txt file
you can easily install all the packages and their versions.

```python
pip install -r requirements.txt
```

<Image src="/images/python2.png" size="10rem" />

I hope this short guide helped your understanding of what a requirements.txt
file is and when and how it can be useful.


GoganWare

- Browse Posts -

Blink a LED with an Arduino

Resources and Tools for Web Development

Secure Django with Environment Variables

Top 3 Python Udemy Courses

Download NodeJS for Ubuntu

What is a requirements.txt file?