As technology increasingly permeates our everyday lives, jobs in the tech industry are growing ever more popular. Many companies and industries are searching for qualified developers to help them stay competitive.

Many people believe that to become a Software Engineer you have to be super smart or you just have to be born with certain talents.

But in my opinion, this is a very common misconception. Being a Software Engineer is not just a matter of talent – it's a matter of choice.

There are several qualities that will help you out immensely if you want to become a Software Engineer. You might not have these traits yet, but I believe they're skills that can be learned.

So let's see how you can develop these skills and carve out your path to becoming a Software Engineer.

You Have to Have Grit

_Photo by [Unsplash](https://unsplash.com/@margobr?utm_source=ghost&utm_medium=referral&utm_campaign=api-credit">Margo Brodowicz / <a href="https://unsplash.com/?utm_source=ghost&utm_medium=referral&utmcampaign=api-credit)

Grit is a strong word, and it is also one of the most important points I'll discuss here.

If you have a goal in your mind, you've gotta commit to it and persevere until the end. The road to becoming a Software Engineer is often a thorny path, but whatever happens, try to see it through to the end.

Sure the journey is hard, but keep in mind that it's not just hard for you – it's also hard for pretty much everyone else.

Because of this, it's important that you have a goal. The goal doesn't have to be long term, like a 5 or 10 year goal. A simple goal that defines what you want to accomplish within one or two years is good enough to start.

When you have a goal, you need to put your mind to it and whatever happens, do your best.

Doing your best doesn't mean having a do or die attitude, though. Everyone has a different learning process and sometimes your progress might not match your goals. But just remember – do your best and keep pushing.

Failing doesn't mean it's the end of everything, it just means you need to try again.

This might sound scary, but in time you will appreciate the journey you've been on. And when you looked back you will say to yourself "That was quite an adventure".

Cultivate Your Curiosity

_Photo by [Unsplash](https://unsplash.com/@catherineheath?utm_source=ghost&utm_medium=referral&utm_campaign=api-credit">Catherine Heath / <a href="https://unsplash.com/?utm_source=ghost&utm_medium=referral&utmcampaign=api-credit)

You might have heard that "Curiosity killed the cat". But as a Software Engineer, you need to train your curiosity. This world is full of unknown and peculiar things you'll want to explore.

There will be times when things doesn't come out as expected. But instead of getting frustrated, we can commit some of our time to finding out why things went wrong.

In the field of technology, there are a lot of things to learn and consider. Every day there are new libraries coming out, it's impossible to play around with all of them.

But you can always start with simple things that you use everyday. Maybe something like how print formatting works in your favorite language. It's a simple concept, and often used, but many of you might not even be aware of how it works.

Be curious like a child, and be in awe of the things you don't yet know. Then, one by one, take those things and explore them.

Understand that You Don't Know Everything – and That's Ok

_Photo by [Unsplash](https://unsplash.com/@earbiscuits?utm_source=ghost&utm_medium=referral&utm_campaign=api-credit">Juan Rumimpunu / <a href="https://unsplash.com/?utm_source=ghost&utm_medium=referral&utmcampaign=api-credit)

There is so much technology around us. And not only are there many things to learn, but much of that tech is also very dynamic. Things keep changing everyday and old technology often becomes obsolete.

Even if you dedicate your whole lifetime to studying all of it, you probably won't even get through half.

The thing is, you need to accept that you don't know all of it. Not because you are not trying hard enough, but it's just that you can't learn it all. There is just too much out there.

But if you want to start, one thing you need to learn is how to ask good questions. There is a quote in my country that says "Embarrassed to ask, astray on the road". So don't let yourself stay lost – just ask whenever you need to ask.

After all, knowledge is there to be shared. So why should you be scared to ask?
Once you've done your due diligence and researched the problem yourself, you can turn to someone else to help you solve the problem.

Become a Life-Long Learner

_Photo by [Unsplash](https://unsplash.com/@aaronburden?utm_source=ghost&utm_medium=referral&utm_campaign=api-credit">Aaron Burden / <a href="https://unsplash.com/?utm_source=ghost&utm_medium=referral&utmcampaign=api-credit)

For some people, learning might have finished when they completed high school or college. But this isn't the case for a Software Engineer. Your entire career is like one big school where you'll learn everything from hard-skills to soft skills.

If you're passionate about learning, you'll find that coding is not all that different. After all, what does a Software Engineer do all day anyway? They solve problems! And from that they learn new things.

Sure, finding the motivation to study isn't always easy. The first step might be to find out which study method suits you best. Some people might prefer reading books or articles (like you are currently doing), others might like watching tutorials or learning by doing.

There are tons of materials out there on the internet – tutorials, books, videos, everything. When you find out which way you learn best, work to develop a study habit and remember that grit will help you push through.

Engineers grow from solving new problems. So keep learning, because once you stop learning, you stop growing.

Final Thoughts

Some of these things might sounds scary or difficult to you – but in reality, most of it is just part of life, and part of growing.

Things might be hard especially at the starting point, but you will get used to it. Treat it as a long and exciting journey, but always try to appreciate the journey and stop worrying about the destination.

And every now and then, don't forget to give yourself a break, because you need to appreciate yourself too.

As always, thanks for reading my article. I hope that it has helped you out. I wish you good luck, whether you are on a route to becoming a Software Engineer or you are one already, trying to improve yourself to become a better Engineer.

The journey doesn't stop when you have became a Software Engineer. The journey is never ending.

Before you can be really good at CSS you need to understand the basics. You have to understand CSS properties and their values.

In this article, we'll focus on the CSS position property. We are going to learn the various values of the CSS position property and how they work. Let's do this!

What is the CSS position property?

The CSS position property defines the position of an element in a document. This property works with the left, right, top, bottom and z-index properties to determine the final position of an element on a page.

There are five values the position property can take. They are:

1. static
2. relative
3. absolute
4. fixed
5. sticky

Let's discuss each one of them.

Static

This is the default value for elements. The element is positioned according to the normal flow of the document. The left, right, top, bottom and z-index properties do not affect an element with position: static.

Let's use an example to show that position: static has no effect on the position of an element. We have three divs placed in a parent container. We'll use this example throughout this article.

<html>
    <body>
        <div class="parent-element">
            <div class="sibling-element">
                I'm the other sibling element.
            </div>

            <div class="main-element">
                All eyes on me. I am the main element.
            </div>

            <div class="sibling-element">
                I'm the other sibling element.
            </div>
        </div>
    </body>
<html>

Let's add position: static to the div with the class main-element and left, top values to it. We also add some styles to the other divs to differentiate them from the element in focus.

.main-element {
    position: static;
    left: 10px;
    bottom: 10px;
    background-color: yellow;
    padding: 10px;
}

.sibling-element {
    padding: 10px;
    background-color: #f2f2f2;
}

This is the result.

Did you notice that it there's no change? This confirms the fact that the left and bottom properties do not affect an element with position: static.

Let's move to the next value.

Relative

Elements with position: relative remain in the normal flow of the document. But, unlike static elements, the left, right, top, bottom and z-index properties affect the position of the element. An offset, based on the values of left, right, top and bottom properties, is applied to the element relative to itself.

Let's replace position: static with position: relative in our example.

.main-element {
    position: relative;
    left: 10px;
    bottom: 10px;
    background-color: yellow;
    padding: 10px;
}

Notice that the left and bottom properties now affect the position of the element. Also notice that the element remains in the normal flow of the document and the offset is applied relative to itself. Take note of this as we move on to other values.

Absolute

Elements with position: absolute are positioned relative to their parent elements. In this case, the element is removed from the normal document flow. The other elements will behave as if that element is not in the document. No space is created for the element in the page layout. The values of left, top, bottom and right determine the final position of the element.

One thing to note is that an element with position: absolute is positioned relative to its closest positioned ancestor. That means that the parent element has to have a position value other than position: static.

If the closest parent element is not positioned, it is positioned relative to the next parent element that is positioned. If there's no positioned ancestor element, it is positioned relative to the <html> element.

Let's get back to our example. In this case, we change the position of the main element to position: absolute. We will also give its parent element a relative position so that it does not get positioned relative to the <html> element.

.main-element {
    position: absolute;
    left: 10px;
    bottom: 10px;
    background-color: yellow;
    padding: 10px;
}

.parent-element {
    position: relative;
    height: 100px;
    padding: 10px;
    background-color: #81adc8;
}

.sibling-element {
    background: #f2f2f2;
    padding: 10px;
    border: 1px solid #81adc8;
}

Here's the result.

Notice that no space was created in the document for the element. The element is now positioned relative to the parent element. Take note of this as we move on to the next value.

Fixed

Fixed position elements are similar to absolutely positioned elements. They are also removed from the normal flow of the document. But unlike absolutely positioned element, they are always positioned relative to the <html> element.

One thing to note is that fixed elements are not affected by scrolling. They always stay in the same position on the screen.

.main-element {
    position: fixed;
    bottom: 10px;
    left: 10px;
    background-color: yellow;
    padding: 10px;
}

html {
    height: 800px;
}

In this case, the element is positioned relative to the <html> element. Try scrolling to see that the element gets fixed on the screen.

Let's move to the final value.

Sticky

position: sticky is a mix of position: relative and position: fixed. It acts like a relatively positioned element until a certain scroll point and then it acts like a fixed element. Have no fear if you don't understand what this means, the example will help you to understand it better.

.main-element {
    position: sticky;
    top: 10px;
    background-color: yellow;
    padding: 10px;
}

.parent-element {
    position: relative;
    height: 800px;
    padding: 50px 10px;
    background-color: #81adc8;
}

Scroll on the result tab to see the result. You see it acts as a relative element until it gets to a certain point on the screen, top: 10px and then it gets there just like a fixed element.

Summary

Whoops! That has been quite a ride. But I really hope this article helped you understand the CSS position property and how it works.

Feel free to play around with the fiddles if you don't fully understand any of them. You can change the values and notice the difference or better still, try to use the position property to work on a personal project.

Remember that getting better at CSS takes constant practice. So keep practicing and you'll get better.

Want to get notified when I publish a new article? Click here.

This article is for people who already have experience in programming and want to learn Python quickly.

I created this resource out of frustration when I couldn't find an online course or any other resource that taught Python to programmers who already knew other programming languages.

In this course, I will be covering all the basics of Python (in-depth lessons will be added later on) so that you can get started with the language very quickly.

Table of contents

• Setting up the environment
• Hello World
• Strings
• Numbers
• Float
• Bool
• List
• Tuple
• Sets
• Dictionary
• if..else
• Loops
• Functions
• Classes
• Modules
• Truthy and Falsy values
• Exception handling

Setting up the environment

To get started, install Python 3. I recommend using VSCode as your editor. It has lots of extensions to configure so that you can setup your environment in just a few minutes.

Hello world

print("Hello world")

If you already know programming basics, you'll probably know how to run this program :P. Save the program with the .py extension. Then run python hello.py or python3 hello.py.

In this whole tutorial, we will follow python3. python2 will be discontinued by 2020. So I think it’s good to go with the latest version.

Variables and data types

Variables can contain letters, numbers, and underscores.

Strings

# This is comment in Python
msg_from_computer = "Hello" # String
another_msg ='Hello in single quote' # This is also a String.

print(msg_from_computer + " World..!")

# Type will return the data type.
print(type(msg_from_computer)) # <type 'str'>. We will see the explanation of this later.

Numbers

2
2 * 3
2 ** 7
(2 + 3) * 4

Floats

2.7

0.1 + 0.2 # 0.3
2 * 0.1 # 0.2

Be careful in Concatenation:

count = 5

print("I need" + count + "chocolates") # This line will throw error. As count is a integer, you have to type cast it.

print("I need" + str(count) + "chocolates") # This will work

Bool

True # First letter is caps

False

bool("some value") # Returns True

bool("") # Returns False

bool(1) # Returns True

List

Lists are basically like arrays. In the Python world, they call them List. And they are ordered.

numbers = ["one", "two", "three"]

numbers[0] # one

numbers[-1] # three. This is awesome. If we pass negative value Python will start from the end.

numbers[-2] # two

len(numbers) # 3. It just returns the length

numbers.append("four") # Append will add the element to the last. ["one", "two", "three", "four"]

numbers.insert(1, "wrong_one") # Insert will insert the particular value to the appropiate position. ["one", "wrong_one", "two", "three", "four"]

# Deleting a value is somewhat weird
del numbers[1] # Will delete the value in the appropiate position. "one", "two", "three", "four"]

# Pop will help you to remove the last element of an array
popped_element = numbers.pop()

print(popped_element) # four
print(numbers) # ["one", "two", "three"]

# Remove elements by value
numbers.remove("two") # ["one", "three"]. This will remove only the first occurence of an array.

# Sorting
alpha = ["z", "c", "a"]
alpha.sort()
print(alpha) # ["a", "c", "z"] Sorting is permanent. now `alpha` is sorted permanently

alpha.sort(reverse=True)
print(alpha) #["z", "c" , "a"] Reverse sorting.

alpha = ["z", "c", "a"]
print(sorted(alpha)) # ["a", "c", "z"] This will just return the sorted array. It wont save the sorted array to the variable itself.

print(alpha) # ["z", "c", "a"] As you can see, it's not sorted

# Reversing an array
nums = [10, 1, 5]
nums.reverse()
print(nums) # [5, 1, 10] It just reverses an array. It means it reads from last. It's not sorting it. It's just changing the chronological order.

# Slicing elements
alpha = ['a', 'b', 'c', 'd', 'e']
alpha[1:3] # ['b', 'c']. The first element is the starting index. And Python stops in the item before the second index.
alpha[2:5] # ['c', 'd', 'e']

alpha[:4] # [ 'a', 'b', 'c', 'd'] In this case, the first index is not present, so Python startes from the beginning.

alpha[:3] # ['a', 'b', 'c']

alpha[3:] # ['d', 'e'] In this case, last index is not present. So it travels till the end of the list.

alpha[:] # ['a', 'b', 'c', 'd', 'e'] There is no starting or ending index. So you know what happens. And this helps you in copying the entire array. I think I don't have to explain that if you copy the array, then any changes in the original array won't affect the copied array.

another_alpha = alpha # This is not copying the array. Any changes in alpha will affect another_alpha too.

Tuples

Tuples are just like lists but they are immutable. This means you can’t add or update them. You can just read elements. And remember, like lists, Tuples are also sequential.

nums = (1, 2, 3)

print(nums) # (1, 2, 3)

print(nums[0]) # 1

print(len(nums)) # 3

empty_tuple = () # empty tuple. Length is zero.

num = (1, ) # Note the trailing comma. When defining a single element in the tuple, consider adding a trailing comma.

num = (1)
print(type(num)) # <type 'int'> It won't return a tuple. Because there is no trailing comma.

# Creating a new tuple from the existing tuple
nums = (1, 2, 3)
char = ('a', )
new_tuple = nums + char
print(new_tuple) # (1, 2, 3, 'a')

Sets

Sets are unordered collections with no duplicate elements.

alpha = {'a', 'b', 'c', 'a'}

print(alpha) # set(['a', 'c', 'b']) As you can see, duplicates are removed in sets. And also the output is not ordered.

# Accessing items in set
# You can't access by index because Sets are unordered. You can access it only by loop. Don't worry about the for loop, we will get that in-depth in the following section.
for ele in alpha:
  print(ele)

# To add element into the set
alpha.add('s')

# add can be used to insert only one element. If you want multiple elements, then update will be handy
alpha.update(['a', 'x', 'z']) # set(['a', 'c', 'b', 'x', 'z']) Remember duplicated are removed.

# Length of the alpha
len(alpha) # 5

# Remove the element from the set
alpha.remove('a')
alpha.discard('a') # It's safer to use discard than remove. Discard will never throw an error even if the element is not present in the set but remove will do.

Dictionaries

Dictionaries are key-value maps in Python. They're unordered.

user = {'id': 1, 'name': 'John wick', 'email': 'john@gmail.com'}

user['id'] # 1
user['name'] # John wick

# Length of the dict
len(user) # 3

# Add new key-value pair
user['age'] = 35

# To get all the keys
keys = user.keys() # ['id', 'name', 'email', 'age']. This will return a list.

# To get all the values
values = user.values() # [1, 'John wick', 'john@gmail.com']

# To delete a key
del user['age']

# Example of nested dict.
user = {
  'id': 1,
  'name': 'John wick',
  'cars': ['audi', 'bmw', 'tesla'],
  'projects': [
    {
      'id': 10,
      'name': 'Project 1'
    },
    {
      'id': 11,
      'name': 'Project 2'
    }
  ]
}

# We will see, how to loop through the dict in for loop section.

if..else

You likely already know how the if..else statement works. But let's see an example here:

a = 5
b = 10

# See for the indentation. Indentations are very important in Python. Python will throw error if indentations are proper.
if a == 5:
  print('Awesome')

# and is equivalent to && 
if a == 5 and b == 10:
  print('A is five and b is ten')

# if else statement. This is same as most of the languages.
if a == 5:
  print('A is five')
elif a == 6:
  print('A is six')
elif a == 7:
  print('A is seven')
else:
  print('A is some number')

# or is equivalent to ||
if a < 6 or a == 10:
  print('A should be less than 6 or should be equal to ten')

# not is equivalent to !
if not a == 10:
  print('A is not equal to 10')

# This is the short-hand notation of if statement.
if a == 5: print('A is five')

# Short-hand for if-else statement.
print('A is five') if a == 5 else print('A is not five')

Loops

Python has two types of loops:

1. For
2. While

while loops

# The following while print till 5. Remember the indentation.
i = 0
while i <= 5:
  print(i)
  i += 1

# Using brake or continue in while loop
i = 0
while i <= 5:
  print(i)
  i += 1
  if i == 2:
    break # You can try using continue here

# Here comes the interesting part. While loop has else part. Else part will execute once the entire loop is completed.
i = 10
while i <= 15:
  print(i)
  i += 1
else:
  print('Completed')

# Output
10
11
12
13
14
15
Completed

# But if you are using break in the loop, then Python will break out of the entire loop and it won't execute else part.
i = 10
while i <= 15:
  print(i)
  i += 1
  if i == 13:
    break
else:
  print('Completed')

# Output
10
11
12

For loops

# For loops like for(i=0; i<5; i++) are not mostly used in Python. Instead, Python insists on iterating over items

arr = ['a', 'b', 'c', 'd', 'e']
for ele in arr: # Prints every element in an array
  print(ele)

word = "python"
for char in word: # Prints every char in the word
  print(char)

# You can use break, continue and else part in for-loop also.

# When talking about for loops, I noticed that most resources have also mentioned about range() function. (We will deal with functions later part of this article.)

# range() function will generates a sequence of numbers.

# range(start, stop, step)
# start - optional, the starting number. Default is 0. This number is included in the sequence
# stop - mandatory, the ending number. This number is excluded in the sequence
# step - optional, increments by. Default is 1.

range(3) # This code generates a sequences from 0 to 2.
range(1, 4) # This code generates a sequence from 1 to 3.
range(1, 8, 2) # This code generates a sequence with 1, 3, 5, 7

for ele in range(3): # Prints from 0 to 2. 
  print(ele)

# In the below example, you can see I have used range to iterate through an array with index.
for index in range(0, len(arr)):
  print(arr[index])

dict = {'name': 'John wick'}

# You can iterate through a dictionary. items() will return both keys and values. You can also use keys() and values() if needed. 
for key, value in dict.items():
  print(key + " is " + value)

# You can also use a built-in function enumerate(). enumurate() will return a tuple with index. It is mostly used to add a counter to the iterable objects in Python.
for index, value in enumerate(arr):
  print(value + " is present in " + str(index))

Functions

def prints_hello_world():
  print('Hello world from Python')

prints_hello_world()

# Return statement
def prints_something(something):
  return something + ' from Python'

print(prints_something('Hello world'))

# If you pass wrong number of arguments like two or three arguments to this function then Python will throw an error.
print(prints_something())

# Default parameter. I think its common in most languages now.
def prints_something(something = 'Hello world'):
  print(something + ' from Python')

# keyword arguments. You can pass explicitly which parameter should be matched. In this way, you don't have to send the arguments in order just explicitly mention the parameter name.
def movie_info(title, director_name, ratings):
  print(title + " - " + director_name + " - " + ratings)

movie_info(ratings='9/10', director_name='David Fincher', title='Fight Club')


# Arbitrary number of arguments
# Sometimes, you dont know how many arguments are passed. In that case, you have ask Python to accept as many arguments as possible.

def languages(*names):
  print(names) # ('Python', 'Ruby', 'JavaScript', 'Go'). This is a tuple.
  return 'You have mentioned '+ str(len(names))+ ' languages'

print(languages('Python', 'Ruby', 'JavaScript', 'Go')) # You have mentioned 4 languages

def languages(fav_language, *names):
  print(names) # ('Ruby', 'JavaScript', 'Go')
  return 'My favorite language is ' + fav_language+ '. And Im planning to learn other '+ str(len(names))+ ' languages too'

print(languages('Python', 'Ruby', 'JavaScript', 'Go')) # My favorite language is Python. And Im planning to learn other 3 languages too


# Arbitrary keyword arguments
# These types of arguments are useful when you don't know what kind of parameters are passed. In the previous case, it's useful when you don't know how many number of parameters are passed but in this case, you don't know what type of information will be passed.

def user_info(**info):
  print(info) # {'id': 1, 'name': 'Srebalaji', 'fav_language': ['Python', 'Ruby']} This is a dictionary

# Arbitrary keyword args will always expect to mention the parameters explicitly
user_info(id=1, name='Srebalaji', fav_language=['Python', 'Ruby'])

# The below code will throw error. There is no keyword arguments.
user_info(1, 'Srebalaji')

def user_info(id, name, **info):
  print(info) # {'fav_language': ['Python', 'Ruby'], 'twitter_handle': '@srebalaji'}

user_info(1, 'Srebalaji', fav_language=['Python', 'Ruby'], twitter_handle='@srebalaji')

Classes

# Python is general purpose and also object oriented language.

# It's a convention that the class name starts with caps. But Python doesn't throw any error if you are not following it.
class Animal():
  # This is the constructor.
  # As you can see in every method of the class I have passed 'self' as the first parameter. The first parameter is always expected to be the current instance of the class and it is mandatory to pass the instance in the first parameter. And you can name that variable whatever you like.
  def __init__(self, name): 
    self.name = name

  def eat(self):
    print(self.name +' eats')

  def sleep(self):
    print(self.name+' sleeps')

# Initiating a class
dog = Animal('harry')
dog.eat()

print(dog.name) # As you can see, 'name' attribute is also avaiable in public. 

# It can even be modified.
dog.name = 'Rosie'
print(dog.name) # 'Rosie'

# Technically there is no way to make private attrbiutes in Python. But there are some techniques Python devs are using it. I will try to list out some.

# Protected attributes.
# These attributes can only be accessed within the class and also by the sub-class.

class Person():
  # You can see that I have used different name for the first parameter.
  def __init__(my_instance, name):
    # 'name' attribute is protected.
    my_instance._name = name

  def reads(my_instance):
    print(my_instance._name + ' reads')

  def writes(my_object):
    print(my_object._name + ' writes')


person1 = Person('Ram')

person1.reads()

# But the worst part is that instance of the class can still access and change it :P

print(person1._name) # 'Ram'

person1._name = 'I can still change.'
print(person1._name) # I can still change

# Protected can useful sometimes. Let's see how private attributes works. That can be a life saver sometimes.

class Person():
  def __init__(self, name):
    # 'name' attribute is private.
    self.__name = name

  def reads(self):
    print(self.__name + ' reads')

  def writes(self):
    print(self.__name + ' writes')

  # This is a private method. This can't be accessed outside the class.
  def __some_helper_method():
      print('Some helper method.')


person1 = Person('Ram')
person1.reads() # Ram reads

print(person1.name) # Will throw an error. 'Person' object has no attribute 'name'

print(person1.__name) # Will throw an error. 'Person' object has no attribute '__name'

# Private attributes can only be accessed within the class. So it's safe. But still there is a catch :P

print(person1._Person__name) # Ram.

# You can even change the value
person1._Person__name = 'Hari'

print(person1._Person__name) # Hari.

# But every dev know that accessing and modifying the private attributes is a bad practice. And Python doesn't really have a clear restriction to avoid it. So you got to trust your peers on this.

# Inheritance

class Animal():
  def __init__(self, name):
    self.name = name

  def eat(self):
    print('Animal eats')

  def sleep(self):
    print('Animal sleeps')

# Dog is a sub class of Animal
class Dog(Animal):
  def __init__(self, name):
    self.name = name

  def eat(self):
    print('Dog eats')


dog1 = Dog('harry')
dog1.eat() # Dog eats
dog1.sleep() # Animal sleeps

Modules

# Modules helps us to organise code in Python. You can split code in different files and in folders and can access them when you wanted.

# Consider the below file. It has two functions.
# calculations.py

def add(a, b):
  return a + b

def substract(a, b):
  return a - b

# consider another file which we consider as a main file.
# main.py
import calculations

calculations.add(5, 10) # 15
calculations.substract(10, 3) # 7

# In the above example, you have imported the file and have accessed the functions in that.

# There are other ways of importing.

# You can change the method name if you want
import calculations as calc
calc.add(5, 10) # 15

# You can import specific functions you need.
# You can access the function directly. You don't want to mention the module.
from calculations import add
add(5, 10) # 15

# You can also import multiple functions
from calculations import add, multiple, divide

# You can import all the functions
from calculations import *
add(10, 15)
multiple(4, 5)
divide(10, 3)

# These will work for classes and variables too.

Truthy and Falsy values

# According to Python docs, any object can be tested truthy or falsy.

# Below are the Truthy values
True
2 # Any numeric values other than 0
[1] # non-empty list
{'a': 1} # non-empty dict
'a' # non-empty string
{'a'} # non-empty Set

# Below are the Falsy values
False
None
0 
0.0
[] # empty list
{} # empty dict
() # empty tuple
"" # empty string
range(0) # empty set

# You can evaluate any object to bool using
bool(any_object) # returns True or False

Exception handling

# The code which can raise exceptions can be wrapped in 'try' statement. 'except' will handle that exception.
try:
  some_error_raised
except:
  print('Exception handled')

# Every exception in Python will inherit from 'exception' class. 

# In the below example, you can see that the 'NameError' is the exception class derived from the main 'Exception' class.
try:
  some_error_raised
except Exception as e:
  print('Exception raised')
  print(e.__class__) # <class 'NameError'>

# 'else' block will execute if the code in the 'try' block has raised no exception. This will be useful in many situations.

try:
  some_error_raised
except:
  print('Exception handled')
else:
  print('No error raised. You can resume your operation here') # this code will execute if no error is raised in the 'try' block

# final block
# Code in 'finally' block will execute no matter whether the exception is raised or not.
try:
  some_error_raised
except Exception as e:
  print('Exception raised')
else:
  print('This will execute if no error is raised in try')
finally:
  print('This code will run whether the code has error or not.')


# Raise your own exception. You can also create your own exception class inherited from Exception class.
try:
  raise ZeroDivisionError # Python built-in exception class
except Exception as e:
  print(e.__class__) # <class 'ZeroDivisionError'>

# Catch a specific exception.
try:
  raise ZeroDivisionError # Python built-in exception class
except TypeError as e:
  print('Only type error exception is captured')
except ZeroDivisionError as e:
  print('Only zero division exception is captured')
except Exception as e:
  print('Other execeptions')

Thank you for reading :)

Originally posted in this Github repo: Python crash course

What being a Senior Developer is not

Before we start, let's get this out of the way. Contradictory to what you'll see on 95%+ of the job postings online, a Senior Developer is not strictly correlated to only the number of years on your resume.

It's true, more often than not, that many years on the job typically bring with them a lot of experience. And with some companies you can get by with just that. But it's not the only quality that rightfully proves that someone is at a Senior level.

This is a common problem in the software world and can lead to high expectations with low delivery. It can also lead to conflict within the team when your new 15 year 10x Senior Developer refuses to work with others.

So what can we do to prepare ourselves for that role?

What makes a Senior Developer?

Looking back through my career at the developers on my team that I've admired and respected the most, it's really come down to four qualities:

• Experience
• Leadership
• Mentorship
• Technical Ability

It's not good enough to look at any one of these as the sole representation of how someone will perform on a team. Each developer is unique and may be stronger with one quality than another. But it's important to see how those qualities come together to determine how someone will help your team grow.

Let's break these each down a little bit.

Experience

Experience is typically thought of as years on the job, and while it's not completely inaccurate, it doesn't tell the whole story.

Just as every developer is unique, so is their experience. While one developer might have spent five years in an intensive position where they worked to solve hard technical challenges every day. And another might have been kicking their feet up at a local shop where their only responsibility was to update the website every week.

And that's not necessarily a bad thing! We each have our own journey and need to balance our lives to fit it. But it's not realistic to say those 5 years were the same.

Then what does experience really mean?

Recognizing patterns from previous work

Every developer has a story (whether they remember it or not) of a random error they stumbled into through their development experience. This could be something dealing with Javascript, webpack, or even your operating system, and it just doesn't make any sense!

But whether through a peer or by searching on Google, you figure it out. And three months later when you're working on another project and run into the same thing, you don't even have to Google it, or you already know what to Google. You already know what the issue is and can get past it quickly and move on.

This is the kind of experience that makes a difference. Being able to recognize patterns whether because of an error or because it was super successful is what helps each of us grow. These are the experiences that help a team grow when others are stuck and you can get them out of a bind.

Recognizing what you don't know

It's also important to understand what you don't know. I think part of what contributes to my own personal struggle with imposter syndrome is that the more I learn the more I realize I don't know.

But this shouldn't be looked upon as a bad or scary thing. This should be inspirational. That means that your craft that you've been working on has that much more cool stuff to explore!

It's important to realize how this impacts your work and the rest of the team. For example, it doesn't help anybody if you act like you know everything and commit to huge amounts of work. When you commit to that work and actually don't understand it, it could knock your sprint off track which can frustrate the entire team (and the client).

Whether it's when you're planning or during development, don't be afraid to ask for help. Come up for air and throw your hands up! Just because you're the only Senior Developer, doesn't mean you can't learn something from a Junior team member.

Try to take a good look at where you've been, what you understand, and where you could benefit to dig in more.

Leadership

As a senior member of a team, I would expect a developer to have a natural tendency to lead. While this doesn't mean you have to be an actual Tech Lead on a project or make any of the final decisions, this does mean that you should have a basic level of being able to help push the project forward

Understanding the bigger picture

If you've worked on projects with team members, you should know that each project or feature typically comes with a bunch of stories to work through to get it done. Each story should be a focused piece that helps accomplish a larger goal.

Where this becomes challenging is if no one on the team understands how each of these stories help to accomplish that bigger goal. As a Senior Developer, you should be able to see how each piece fits into the puzzle and why the story is written with the specific acceptance criteria. And if you don't know, you'll know how to get the answers and make sure it's communicated to the team.

If you're unsure of the direction, try to take a step back. Try to see where it fits in. Help to lead the project team to that ultimate goal.

Helping direct less experienced team members

This comes naturally in the ability to help guide those on our team who are more junior or less experienced. It's common for developers to lose focus on the big picture. But as we just discussed, a Senior Developer should be able to continuously have a good idea of the overall project and where the different stories fit into the bigger epic.

Help guide others on your team to get them on the right path. While it would be beneficial for everyone to understand how everything fits in to the bigger picture, sometimes it makes more sense to help an individual focus on how their specific task fits in.

Try to recognize this struggle when working with others whether by encouraging them to ask more questions or helping to guide them if they're not quite on the right path as you're reviewing their code.

Mentorship

It's often more convenient to be heads down on your work and not have to worry about what anybody else is doing, but is that really benefiting anyone?

Helping to build up other team members

You might be the so-called 10x developer, but doing everything yourself and not helping others can only slow down the overall team. Often you'll be stuck picking up the pieces that you could have easily caught if you spent an extra second pairing up with someone else on your team.

It's also bad for morale. No one wants to feel alone on a project and even more so as a junior. Software is a big scary world, a little guidance can go a long way to helping others to become more productive and subsequently encouraging a happier, less stressful environment.

It's easy to forget that we were all a junior team member at one time. While you might take things for granted, the concepts might be really challenging for others to grasp.

Keep in mind that we're all in this together. Celebrate the wins whether big or small. If somebody's struggling, reach out to help.

Knowledge sharing

Sharing knowledge is something many teams struggle with. While we're all usually hopeful that there's a way to accomplish it, most of the time it just goes unsolved. So what can we do?

Take it upon yourself to share what you know. Did you just rework the core business logic? Offer 30 minutes to walk everyone through the code. Pair up and screen share with your code reviewer if they're having a hard time understanding it.

This is something we can encourage everyone to do. You'll naturally learn more by presenting your work by reinforcing what you just worked on. This is helpful whether you're a Senior or it's your first time opening up a code editor.

Technical Ability

I intentionally wanted to leave this until the end. This is because, while it's important, there are more aspects to your journey to becoming a Senior Developer than just being really, really good at something.

Ability to get moving quickly

As a Senior Developer, I would expect another Senior Developer to become productive in something quicker than a Junior Developer. If they're an expert with Javascript, I would expect them to understand the core principles and patterns of the language.

But back to the idea of recognizing what you don't know, it's not reasonable to expect all Senior Developers to know everything. I wouldn't consider an expert in Ruby any less of a Senior Developer because they don't know Javascript, but I would expect them to understand how to apply what they know when building in and learning another language.

Promoting software patterns

More often than not, the code pattern you just came up with isn't new. And that's okay! The goal of building great software isn't necessarily to be unique with every solution.

And because of that, we can learn from past work by seeing what's succeeded and what's maybe not gone over so well to find patterns that work for you and your team.

Patterns like MVC (Model View Controller) didn't become popular without reason. Developers learned from the past and have learned from their peers who have solved big software challenges. With that knowledge, they can apply the solutions to their own work. It's not about reinventing the wheel, it's about solving challenges and making a good product.

We all have our own unique journeys ahead

No matter what anyone tells you, we all have our own unique code journeys. This is meant to encourage you and inspire you to become a better overall developer and understand how your work impacts the rest of the team.

While you certainly might succeed without taking these things into consideration, you could be missing out on core traits that could make people not want to work with you from a human being perspective.

Whatever your journey, keep these things in mind as you grow into becoming a better developer!

What do you think makes a good Senior Developer?

Do you think I'm spot on or way off? Share with me on Twitter!

Communities are usually built on shared struggles of individuals learning in a particular region, and the goals of each community differ per the individual's collective needs.

Over the years, these developer communities have grown across the world with different goals and missions but still with the general aim of providing a platform for developers to learn, interact, share ideas, support each other and grow.

"If you want to go quickly, go alone. If you want to go far, go together." – African Proverb

To better help those looking out for communities to join, I have put together a list of 20 best communities in no particular order ranging from Engineering, Design, Data Science, Machine Learning, Developer Relations, Technical Writing, and more.

If you know any more communities you have found helpful, please share them in the comments section for the benefit of all :).

1. Women Who Code

Women Who Code is an international nonprofit organization that provides a global community for women in tech with events, coding resources, jobs, mentorship, and more. They aim to inspire, support, and help women develop technical skills and excel in their careers.

Join now to get exclusive access to their community, events, scholarships, free event tickets, job boards, and more.

2. Hashnode

Hashnode is an online community where developers share knowledge and grow their careers. Developers from around the world participate in consequential discussions on Hashnode. You can write stories, ask open-ended questions as well as technical questions, ask questions anonymously, and start polls. You can also ask popular tech teams and developer influencers questions or learn from stories of awesome women in tech.

Hashnode's Devblog platform enables you to create your personal blog on your custom domain in a few simple steps with everything you need to grow as a blogger. (No Paywall, Free domain, SSL, Automatic backup of posts, Markdown, AMP Support and more). Own your canonical, make your contents independent and build your domain authority.

3. Freecodecamp

freeCodeCamp is a nonprofit organization that helps people learn to code for free through thousands of videos, articles, interactive coding lessons and thousands of freeCodeCamp study groups around the world.

You learn by completing coding challenges and building projects alongside verified certifications.

4. StackOverflow

Stack Overflow is a question and answer site for programmers with tons of questions and answers on a wide range of topics in computer programming.

You can learn from already asked and answered questions, share your programming knowledge by answering asked questions or share your issues/bugs here.

5. HackerNews

Hacker News is a social news website focusing on computer science and entrepreneurship, where you can submit a link to technical content.

This is a great place to promote your contents to a wide range of viewers and find amazing contents from other technical geeks.

6. Hackernoon

Hackernoon is a tech media site that delivers stories and opinions written by real tech professionals and read by Technologists, Software Developers, Bitcoiners, Blockchain Enthusiasts.

You can write technical articles here and learn from a wide range of available unfettered technical contents.

7. SitePoint Community

SitePoint community is a community for web designers and developers to discuss everything web development from HTML, CSS, JavaScript, PHP, Photoshop, SEO, and more.

Similar to StackOverflow, you can ask and answer all web development questions here.

8. Kaggle

Kaggle is an online community of data scientists and machine learning practitioners with a vast repository of community published data and code with over 19,000 public datasets and 200,000 open notebooks. Kaggle also offers courses on Machine Learning, Pandas, Python, Deep Learning, Data Visualization, SQL alongside competitions, and discussions to help you grow.

9. Indie Hackers

An Indie hacker is "a person building an online project that can generate revenue." Indie Hackers is a global community of developers who are sharing their projects, strategies, and revenue statistics behind their companies and side projects.

You get to learn from the founders behind hundreds of successful online businesses and connect with others who are starting and growing their own companies through their global meetups, discussions, articles, and more.

10. Code Newbie

Code Newbie is the most supportive community of programmers and people learning to code. It started as a weekly Twitter chat made to provide much-needed support to people learning to code. It has since grown into a supportive, international community of people learning to code.

11. Digital Ocean Community

This is an inclusive place where developers can find or lend support and contribute to the community of DevOps and cloud computing enthusiasts. The community provides comprehensive guides, tutorials, trends for developers, Q/A sessions, and much more.

12. Product Hunt

Product Hunt is an exciting community of featured amazing products launched every day. It's a place for product-loving enthusiasts to share and find out about the latest mobile applications, websites, hardware projects, and tech creations.

13. Reddit

Reddit is global community of thousands sub communities, endless conversations, and authentic networking with tons of never-ending streams for developers like r/reactjs, r/vuejs, r/JAMstack_dev, r/Python and more.

14. DevCareers

DevCareer is a nonprofit organization that is focused on supporting upcoming developers with mentorship and resources to enable them to become world-class developers. They provide laptops, co-working space, resources, mentorship, and job placements for software developers in Africa who pass through the program.

15. The Interaction Design Foundation Community

The Interaction Design Foundation Community provides an exciting opportunity for designers to create and hone their portfolio while getting ready for a new User Experience job. They offer courses from UX experts, local UX Design Meet-ups in cities across the world, UX discussions, collaboration, and much more.

16. Daily UI

Daily UI is a free series of daily UI design challenges, design inspiration, and surprise rewards to make you become a better designer in 100 days. Their amazing daily reminders will motivate you to keep learning.

17. Dev.to

DEV is a community of software developers helping one another out. DEV provides a place for developers to collaborate and network while learning and sharing their knowledge.

18. DevRel Collective

DevRel Collective is a community of developer relations enthusiasts that exists to facilitate sharing information, resources, and encouragement among the DevRel community.

If you are actively involved in developer communities, advocacy, or event management, you should join this community.

19. Facebook Developer Circles

Developer Circles from Facebook is a program designed to create locally organized communities for developers. These communities educate and provide a forum for discussion and knowledge sharing around topics that are top-of-mind for developers in a particular market.

Find a local Developer Circle nearest to you here.

20. Google Developers Groups

GDG brings software developers with similar interests together to meet through meetups and hands-on workshops. The community welcomes everyone and anyone interested in tech from beginners to experienced professionals.``

Find a GDG chapter nearest to you here

Conclusion

"There is no power for change greater than a community discovering what it cares about." – Margaret J. Wheatley

The bond in developer communities has grown from just "technical groups" to "family groups" where everyone is passionate about sharing knowledge, giving back, and helping everyone reach higher heights.

Isn't this just amazing? Cheers to the new age where sharing knowledge and togetherness become the order of the day. ??

Around this time last year I started learning the basics of code in my spare time, and sure enough found myself working as a professional developer just 7 months later – with no CS degree, no bootcamp, and no clue.

So if you’re reading this you’re probably thinking: how on earth did that happen?

Well, my thoughts exactly.

In this article I’ll share what I did in those initial 7 months leading up to my first ever dev job. I’ll also include lots of resources I found helpful along the way, and bits of advice that I wish I had taken on sooner.

If you’re a fellow coding beginner aiming to make a similar career change into web development, my hope is that this article offers you some guidance…

(If you haven’t started coding yet but want to find ways to begin, you might find my previous article a little more helpful, which includes lots of insights on how to take that first step towards learning to code.)

So, lesson number 1:

? Share your interest early.

When I seriously started thinking about programming, the first thing I did was talk about it.

I asked my friends and family if anyone knew any developers who’d be willing to chat about their jobs, and ended up meeting so many smart and creative people who gave genuine, practical and (most importantly) varying insights.

The key here is to try and meet as many different kinds of developers as possible. If you can, speak to people with all sorts of interests and specialties at various stages in their careers. This kind of access can unveil the variety involved in programming, and you can use it to demystify the idea of coding as this big, scary thing.

Another good habit to pick up early is to constantly:

? Ask.

I asked developers some of the most basic things like:

• What the hell is GitHub?
• Do you really not need a computer science degree?
• Why is everyone always talking about React?
• What kind of tech jobs do you think there’ll be in 10 years time?

? And go to meetups.

If you’re lucky enough to live in a place like London where there are plenty of meetups happening – go!

This is great practice early on not only because you might get to have human beings guide you through coding problems, but because it lets you meet with organisers, coaches, bootcamp students, etc. etc.

By going to meetups you can also build up your network in the industry and hear about potential job opportunities suited to your skill level.

Some of my favourite beginner-friendly and inclusive meetups include:

• Codebar. This is an amazing weekly meetup with over 20 chapters worldwide, where you can work with coaches and really get stuck into your code (they also run virtual meetups for those who can’t make it to events).
• Ada’s List. This organisation runs friendly monthly meetups in London alongside a virtual community online, offering women a great way to meet other women in tech (and not just coders).
• 24 Pull Requests. This annual event (also in London) is a lovely place to contribute to open source projects, and includes an introduction to Github – very handy for beginners.
• Node Girls. This group organises meetups a couple of times a year in multiple locations, and is a great place for newbies to learn Javascript and Node.js.

?‍♀️ Next: Play the field.

For ages, I thought the first thing I had to know about code was what language I wanted to learn. But not only is it ok not to know where to start, I actually think it’s a huge advantage.

There are so many languages and topics out there, and while this can definitely be overwhelming as a beginner, you can also make the most of your naivete and just try it all out without getting too preoccupied with all the surrounding jargon (for instance, you don’t need to know the entire history of CSS to just play around with it) – which leads me to my favourite bit of advice from those initial 7 months...

? Be bad.

When I first started I was so scared of how bad I was going to be. And one of my biggest revelations since then was: nobody cares.

Of course you’re going to be bad at it! You’ll be terrible. But, having a beginner status gives you license to suck at everything, so use it while the stakes are low. Enjoy being terrible – it’s fun, and freeing.

?‍? Do the tutorials.

When you’re trying to level up from total beginner, tutorials are great because their format eliminates the problem of having to figure out what you want to learn and how you want to learn it (while you’re actually just trying to learn it).

Some of my favourites include:

• Any of the Codebar tutorials (great for learning different languages from scratch)
• Rachel Andrew’s video tutorials (awesome for learning CSS grid)
• NodeGirls workshop tutorials (nicely paced walkthroughs that introduce you to Javascript & Node.js)

When it comes to tutorials though, try and understand how you learn best and don’t get bogged down in one method or approach just because it’s the most popular or it was suggested to you.

You might not know much about coding at this stage, but what you do know is how you learn best. So trust your own judgement here.

Here are some different learning methods that have worked well for me:

• freeCodeCamp curriculum. Byte sized exercises for different languages, great for when you need a break from heavy tutorials and want to play around with something a little lighter.
• CSS Diner & Flexbox Froggy. Two fun games that are great for helping you get to grips with CSS selectors and practicing flexbox layouts.
• Codepen. A coding playground where you can look at people’s projects alongside their code, letting you to connect the dots between the two.
• Grasshopper. A sweet, beginner-friendly mobile app that introduces you to Javascript fundamentals.
• Eloquent Javascript. This digital book pairs really well with freeCodeCamp exercises, giving a thorough and foundational understanding of Javascript.

? Be a copycat.

Soon enough, you’ll feel like it’s time to build something a bit more substantial. And a really fun way to do this without feeling overwhelmed is by trying to replicate cool stuff you’ve already seen (you can browse some cool looking website here). And as you do this:

? Know why.

If you’re building your first ever website, before you even get to writing any code remember to ask yourself why. Are you doing it to:

• Just fill up your portfolio?
• Learn a particular language?
• Try out different hacks you’ve heard about?

As a beginner, your main reason for building something is probably to learn by doing so your website or app is just a means to an end. It’s the byproduct, not the goal. Remember that.

Knowing this distinction is crucial to learning effectively, especially if you’re teaching yourself because as you’ll quickly learn: everyone’s got their own way of doing things. For instance if you’re building a website as a way to learn flexbox, then don’t let someone talk you into using Bootstrap.

If someone tells you there’s a quicker way to achieve a goal they may be right, but they might not have clarity on what the real aim is.

? So articulate it.

First to yourself, then to others, and then make your own decision about how you want to go about it. This part might seem super obvious, but in the midst of soaking up all that information, it’s all too easy to forget.

? Then chill.

The great thing about self-directed learning is that you decide the whats and the hows right? Well, another great thing is that your deadlines are made up by you, and if you don’t meet them, nobody cares. So give yourself a break!

⚡️ Stay inspired.

This learning process is twofold: on one hand you need to spend time figuring out the technical minutiae in your code, and on the other you need to look around every now and again and see what other people are doing.

Blending these two approaches gives a great holistic perspective on your learning, and helps mitigate the stress of getting caught up in all the details. Here are some tips I found useful in my first 7 months:

? Go to conferences.

• You Got This. This is a UK-based event specifically for developers in the early stages of their careers. I went to it without ever having worked as a developer, felt totally comfortable there and left ready to get stuck into some code.
• New Adventures. This Nottingham-based conference provides a less technical, more meta approach to tech and where it fits into the world these days. With varied speakers and far-reaching topics, it’s super inspiring.

? Read up.

• freeCodeCamp (of course)
• Codebar (they run a great series of interviews with self-taught developers)
• A List Apart (publishes a huge range of topics from design to coding to career progression)
• Smashing Magazine (features articles, books, events, jobs – you name it)

? Follow people.

• Mandy Michael – has a lot of seriously cool stuff on Copeden.
• Rachel Andrew – gives loads of inspiring and practical talks, many of which you can find online.
• Jen Simmons – has a rich Youtube channel full of insights on design and developing.
• Saron Yitbarek – founder & CEO of CodeNewbie – total boss.

And that’s essentially it. Looking back over the last year, I’ve come to realise that these core lessons were what sustained me as I went from being a copywriter who had never looked at a single line of code, to working as a full time developer.

So if you’re thinking about switching careers but are worried about committing to such a big change, try breaking it down into these smaller goals and challenges.

If it can work for a woman who had absolutely no clue what she was doing at the time, it can surely work for you. So please: use these lessons learned, tailor them to your own learning style, and get after it.

If you want to get in touch or keep up to date on future articles, talks and events, you can follow me on twitter here: https://twitter.com/niamhmccoo

So I wrote this article to walk you through my thought process. This is how I plan and develop my own projects.

A quick note before we start: this article is not a "silver bullet" guide on how to create ANY project. This is just how I personally approach my projects. It may work for you, it may not.

There is no "right" way to create any app. Remember: there are many roads that will get you to the end of your journey. (Unless, you're taking a shiny ring to Mordor, in which case there is only 1 road, unfortunately).

I'm going to use React.js to code the example app. I've included a Code Sandbox with the finished app at the end of this article.

So you'll also need to have basic familiarity with setting up a React project. Don't worry though, the principles in this article still apply regardless of the language you use to code the app.

OK let's get started. Today we're going to design a... TODO-LIST!

Only joking. We're going to make a simple calculator.

"What does it do?"

This is the first question I ask myself before starting any side project. I want my calculator to be able to:

• Add, subtract, divide and multiply numbers
• Show the result of the calculation
• Reset the display

This should be plenty for now. Planning out the features in this way gives you an idea of your app will do, and starts putting you "in the zone" as it were.

This approach also gives you a solid goal to work towards. Once you have implemented all the features, you're finished, and you can start thinking about your next side project - Huzzah!

Otherwise, you risk ending up trying to add too many features, and seeing calculators in your sleep. Of course, you can keep adding features if you want. But make sure to have an end goal to work towards.

In the real world - depending on your role - there may be a client or product owner who defines the "what does it do" part for you. Your job as a the developer will be break up these requirements into more detailed tasks, which we'll get into later.

"What does it look like?"

Now that I have an idea of the features, I will start to think about what it's going to look like.

If you're struggling to come up with designs, there are a number of ways you can do this:

• look at examples of similar apps
• browse CSS frameworks for elements you can use
• or use your imagination. (Not every side project you do has to look "incredible.")

I am feeling particularly artsy today so I am going to make a quick wireframe with how I want my calculator to look:

Ah! Marvelous! I should become an artist.

So I have my features, and I have my sketch that Van Gogh himself would be proud of.

In the real world, when you're working as part of a team, a designer may come up with something like this for you. Or, even better, you might be given a working prototype, which you can play with.

"How do I position and style the elements?"

I'm starting to get a good feel for what my app should do, and what it looks like. Now it's time to get a bit more technical.

At this point I'm thinking, "OK, I've got some buttons, and a big ole' display. How will I position everything?"

I like to think that implementing a design is a bit like building a house. Lay the foundation (the layout), build the outer structure (buttons, inputs), and add the finishing touches later (colours, icons, styles).

When talking about layout, the first things that come to my mind are CSS Grid, Flexbox, or a framework (such as Bootstrap). I'm going to use Flexbox, since it is responsive, makes it super easy to arrange items within a row, and well, because I feel like it. This saves me having to install extra dependencies we don't need.

"How does it behave?"

Now it's time to think about how the app will behave. This is basically breaking down our features into more detail to help design the code.

When I ask myself this, I am thinking about things like:

• What does the app look like when it loads?
• What happens when a user clicks a button? Does the style change?
• How does the UI react to various user actions?

Another way to answer this question is to play with an existing example.

A small task for you: try to open up the calculator on your computer, and start doing some stuff. Adding, multiplying, whatever.

When you perform an action, see if you can capture in as much detail as possible, what happens.

Here's what I found:

• When the app loads, the display is set to "0" and all the buttons are in an "inactive" state
• When the user clicks a number, the display will update with the new value. The clicked button will change style to indicate to the user that the click was successful.
• When the user clicks an operator, the selected operator will indicate in some way that it has been selected.
• If an operator button has been clicked, and the user then clicks a number button, the display will firstly reset to zero before displaying the next numbers the user clicks.
• When the equals button is clicked, a calculation is performed using the initial number, the selected operator, and the next number that was entered.
• When the user clicks the clear button, the display will reset to zero, and the app will reset.

In the real world, we won't always have the luxury of an example or a prototype to play with. But as your experience grows, it becomes easier to do this based on a wireframe or mockup. This is why I like to suggest to beginners to replicate existing apps, as that gives you an example to practice this critical thinking and analysis with.

But why do we have to go into such nitty-gritty detail? Good question. And the answer is because computers are incredibly smart, but also incredibly dumb. (Don't believe me? Try removing a random curly brace from your code and watch all hell break loose.)

The instructions we give to computers have to be extremely specific. For example, looking back at our behaviours above, clicking a number will act differently depending on if an operator was clicked or not.

We as humans know how a calculator works, but a computer doesn't until we tell it how.

"What will my code look like?"

Just like I spent some time designing the UI, I like to do the same with the code. There's many benefits to this:

• Makes me think in detail about what components I need
• Makes me think about the workflows
• It means writing the code will be easier/faster, since I have a plan
• Catches issues and problem areas early

I mentioned earlier that for this project I'll aim to keep things simple, so I'll stick to this approach. In the beginning, I'll keep everything in one component. However I'll start to refactor and split into components when:

• That the code grows to the point where it's hard to manage or reason about
• There is a lot of duplicated code
• A single element on the page requires it's own functions and state

Have you ever got towards the end of a project and thought "sh*t! I forgot something now I have to redesign all this stuff?" By planning in advance, you'll avoid this trap. With that in mind, here's the stuff I think I'll need. Don't spend all day thinking about it, find a balance between planning and just getting started. Let's break our UI mockup into it's individual parts and think of what code will be needed.

The Display

My display shows the user the current number, so I'm going to need some sort of state value for this. Nothing happens when I click it, so I don't need anything there.

The number buttons

Since the number buttons affect the number shown in the display, I'm going to need a function that gets called by an onClick event to manage this. No need to store the selected number in state right now.

The operator buttons

The operator button is an interesting one - as different things happen (remember our, "how does it behave?" notes above?). Since I'll need to know the currently selected operator, I'll store that as a state value as well.

The equals buttons

The equal button should take the display value, the operator, the previously entered value and calculate the result. Easy!

Not quite, we've hit our first problem! Let's look back to our behaviours

If an operator button has been clicked, and the user then clicks a number button, the display will firstly reset before display the numbers the user clicked

The first number the user enters into the display gets reset when they click an operator and starts entering the next number - which means our app has no idea what the first number was when the user clicks equals (I told you computers were dumb)! Let's have a think about this:

When the operator button is clicked, this is the point where the display resets, and updates with the next number the user enters. Logically then, it makes sense to store the previous display value when an operator is clicked. For this to work, I'll need a function and a state value that stores the display value when an operator is clicked.

The clear button

This is an easy one - reset our state values to zero, allowing the user to start again. I'll need a simple onClick function attached to the button to handle this.

"What do I need to test? And what can go wrong?"

Depending on who you talk to, there can be different ways to approach testing. Some like to do TDD (which is writing the tests first) and others write them at the end. I do both depending on the project. But the main thing is you write them at some point.

When I think about my tests, I look at the requirements. The first requirement (or feature) is:

• Add, subtract, divide and multiply numbers

So I'll need to test that the app can do these things. I won't go into detail about how to write tests, but a good test suite should cover:

• The requirements and common use cases
• The edge cases (e.g user enters 99999999999999999999 + 9999999999999999999999)
• The error cases and where things can break (e.g user tries to divide by zero)

"How many tests should I write?", is probably your next question. Unfortunately there is no hard and fast number for this. There are endless amount of inputs you can have. If you follow the points above, you'll have a solid test suite for any project.

Thinking about your tests early will help you think about where errors can occur in your code, and allow you cater for it earlier in your designs.

Let's look at the code

This isn't a coding tutorial as such, so I'm not going to go into the nitty gritty of each step in this article. See the code sandbox at the end to see a working example, including the code/walkthrough for each step outlined below. Feel free to fork the code and play, destroy and experiment to your hearts content!

When writing code, we'll stick to the plan:

• Focus on getting the UI layout and elements in place first, using our wireframe as reference
• Implement the logic (JS, event handlers etc)
• Final touchups
• Remember to do the simplest thing to get everything working - no need to worry about refactoring and performance at the start!

Step 1 - Layout and Basic UI elements

(In the Code Sandbox linked below, click Step 1 button to see the working example, see app-step-1.js to view the code!)

Remember, we are going to start with the layout, and get the "scaffolding" of our app together. This will include adding the HTML and using Flexbox, to position our display and buttons. They won't do anything yet, but they will look nice. Sort of.

Step 2 - Adding the logic

(In the Code Sandbox linked below, click Step 2 button to see the working example, see app-step-2.js to view the code!)

We've done our planning for this part, so let's refer back to that. In our "What does my code look like" notes, we have to create a bunch of different state objects and functions to handle the events.

For this I take one item from our "What will my code look like?" list at a time, and reference back to the "How does it behave?" notes to piece everything together. I implement the functionality, and test that it's working (usually automated but manually will do). Example:

The first element in the list is the display. So I will add the state variables and logic for that. Test that it's working, and move onto the number buttons, and repeat. This is where writing your tests early is helpful - you can run the suite every so often to make sure nothing has broken.

Step 3 - Adding the bells and whistles

(In the Code Sandbox linked below, click Step 3 button to see the working example, see app-step-3.js to view the code!)

Awesome we're nearly done! Now that the logic is working, we will now go and add some of the finer touches (rounded buttons, borders, bigger display etc) to the app, and we're done! Our very basic calculator now does stuff!

Step 4 - Over to you!

I've purposely left some things out that you can go ahead and try if you feel like it. Use the approaches we learned so far - thinking about the behaviors, what function/state objects you'll need etc.

• Our calculator doesn't quite match the wireframe - can you add some color to the buttons? What about changing the colour of a selected button when it's clicked?
• No tests! Oh dear! See if you can add some
• Some duplicate code exists - can you find a way to render the buttons so we don't need to hard code 16 button elements?
• Error handling - there is none! This is bad. What happens if you try to divide by zero? Or if you have a number that is wider than the display?
• When the user starts to input numbers, any preceding zero's are added to the display, for example 000003 this isn't good UX, can you fix it?

Thanks for reading! Want more articles like this?

Hopefully this has given you an insight into one approach into coding apps. If you'd like to be updated when I release more articles like this, feel free to join the mailing list over at chrisblakely.dev! Or reach me over at Twitter if you fancy a chat :)

CodeSandbox - Finished Example

Maybe you're someone who doesn't have a computer science degree or maybe you don't come from a "technical" background. Maybe you're self-taught or you did a coding bootcamp. Or maybe you've been a software engineer for a few years and you've having trouble landing interviews.

Either way, you're finding it hard to land your first or next job. Here are practical things you can do to make it happen:

? Get Real Experience

"Entry-level Front End Developer. Minimum 1-year of experience with React". This is a catch-22. How are you supposed to get your first job if all of them require previous experience? Here's what you can do:

• ☐ Reach out to 3 companies asking if you can do an internship
• ☐ Look for contract positions on Upwork, Craigslist or in a local tech community
• ☐ Reach out to a local business and offer to redo their website
• ☐ Contribute to an open source project

✅ Goal: to get something on your resume. This will help you get through the first gate as a new developer.

?️ Network

Network, network, network. Meet people. People lead to connections. Connections open the door for jobs. The more people you know and the more people you help, the more likely you are to find that next job. Do these things:

• ☐ DM 3 people on Twitter who do what you want to do. Learn from them.
• ☐ Go to 3 local meetups and talk to people
• ☐ Speak at 1 meetup. Give a lightening talk. Get your name out there. Mingle with meetup organizers

✅ Goal: to make connections and establish yourself in the industry. If you help others, good things will happen. Being known in the industry means opportunities will come to you, rather than you seeking them out.

✍️ Share What You Learn

It's very easy to silo yourself and learn in a "cave" but share with the world what you're doing! It might inspire others, you might teach someone something new, and it's a good way for potential employers to see what you're doing

• ☐ Start your own blog and write a weekly post
• ☐ Write 1 blog post about something you built. Get it published on a well-known blog.
• ☐ Tweet about what you learn via #100DaysOfCode

✅ Goal: to share publicly what you're doing as a developer to further your knowledge and skills. Plus the way you explain something might click for someone in ways other articles weren't able to do.

? Build Projects

If your portfolio and GitHub do not have projects in them, you are not going to get an interview. The projects you showcase speak to your technical ability. This is especially important if you don't have a CS degree.

• ☐ Build 1 project that solves an everyday problem for you
• ☐ Pin 4 projects to your GitHub profile page
• ☐ Write friendly READMEs with information about each project

✅ Goal: to have substantial websites/apps that demonstrate what you can do. These will help you stand out among applicants and be good talking points during your interview.

If you do all of these things and you still can't get an interview, let me know. I will do my best to help you figure out what more you can do. However, I'm fairly confident this will put you on the right path ?

###

Photo by Andrew Neel on Unsplash

This post was first published on DEV.

? Shameless Plug: if you'd like to see more content like this, subscribe to my newsletter: https://buttondown.email/jsjoeio

A week ago, I started an Open Source project. I had never done a pull request or merged anything on GitHub. Suddenly I was an Open Source maintainer.

In my search for an easily approachable Open Source project, I ended up creating my own.

I had always wanted to contribute to Open Source. Every time I was looking for a project, I gave up. I was overwhelmed by the source code of a project, or it looked too complicated. I didn’t know whom to reach out to for information and help. I was doubting my skills, and convinced myself that my contributions wouldn’t be useful.

It was ironic. I wanted to contribute to Open Source, to gain experience. But I felt that I needed more experience before I could start. It was an endless spiral, and I realized I needed to do something about it.

Breaking through the barrier

I wanted an Open Source project for beginners. I dreamed of a project where I could feel confident. Where other contributors were also learning to code, or contributed to help beginners. I figured out that there were probably other people like me looking for the same opportunity.

Then, it finally hit me. I could start an open source project myself. I spent 14 hours on it that day, and in the early morning I had a project on Github. Then I tweeted out for others to join me.

If you have been curious about open source for a while, but haven’t gotten started, I encourage you to do the same. I have captured my process in this post. If you create the type of project you would feel good about contributing to, it will be much easier to get started. As an added bonus, you will help other people who have been hesitant to contribute for the same reasons as you. Try it out — you will learn a lot.

Side note: I said above I started my project in 14 hours. To be completely fair, I started on step 3 (see below) that day. I already had my idea, and I had written my baseline code a couple of weeks before. If you have some small project you have already started, you can use that. But if not, no worries, you do not need to do it in one day.

So without further ado, here are my five steps to create your own Open Source project.

Step 1 - Get an idea

This might sound very hard, but it doesn’t have to be. After all, you only need the beginning of an idea. Your future contributors and potential users will be full of ideas to build on top of yours.

A lot of technologies like Google and YouTube started out very simple, and so should your project. Remind yourself that this is a learning experience. Your idea doesn’t have to feel like a genius invention. If you’re still stuck, maybe this silly site can help you.

Step 2 - Create a baseline

It is easier to start collaborating if there is some minimal code to start from. It is up to you to decide how much code your project should include to begin with. But it will be easier for your contributors to begin if there are at least a few lines of code that they can modify or add to.

Don’t worry if your baseline seems too simple. This is exactly what you want. Other beginners will be able to contribute, because the project is simple and the code is easy to read.

Step 3 - Set up your repository

The repository is where it all happens. It is also where we beginners lack a bit of experience, compared to seasoned developers. Use your experience as an Open Source “newbie” to create a simple and encouraging project that other beginners can join.

You know exactly what was hard for you. Make sure that your project makes it easier. Create the type of project you wish you could have joined yourself.

When I was looking to join an Open Source project, I really wanted to ask the maintainers how I could contribute. I made sure that there was plenty of ways for people looking at my repository to reach out to me. I provided information on how to open an issue and introduce yourself. If someone does that, we can figure out together how they can start contributing.

There are people out there who have the same struggles as you. If you build your version of a welcoming open source project, they will have an easier time joining you. Together, you can learn and develop your project.

There are many guides on how to start a GitHub repository, for example here. Learning by doing is what works best for me.

I followed free interactive guides on GitHub learning lab. If you are new to Github or want to brush up, you can start with an “Introduction to Github” as I did.

Then move on to “Moving your project to Github”. This guide will walk you through setting up an Open Source repository step by step. Feel free to skip any step that you don’t think is relevant to your project, or that you want to save for later. When you finish, you can change the name of your repository, make it public, and voila! You have an open source project.

Remember that open source doesn’t just mean a collaborative project. It also means having an open source license. The GitHub guide will help you in adding that to your repository, too.

If you build a welcoming Open Source project, people will join you. Hold each other’s hand as you learn together.

Step 4 - Invite people to collaborate with you

This was the step that scared me the most. I didn’t have any friends who were coding that I could invite to join my project. I had less than 20 followers on Twitter, so I wasn’t even sure my tweets would have much reach. But I tweeted out an invitation to join, and added some hashtags that I hoped would reach other beginners.

And then, Nothing Happened!

For more than 24 hours, no one liked my tweet. The only retweet was from a twitter bot. Worst of all, nobody was active on the repository. I was disappointed. My expectations weren’t high, but I had hoped that at least one or two people would check it out.

But the following morning, there had been some twitter activity. Two people had been working on the repository. The project had its first pull request. I was so excited. Now, less than a week later, there are 8 active collaborators on the project, none of whom I have ever met.

Step 5 - Crush the Open Source game

This step is learning by doing. You will be facing many challenges as you start working on the project with your contributors. My first big challenge was a merge conflict. Google was a great help at that moment, and I was lucky that I could ask for help at my weekly meetup.

Remember that you have built a space for learning. Your contributors understand that you don’t know how to do everything from the get-go. Treat every new challenge as a learning opportunity. Don’t fear asking your contributors for help or advice. The beauty of Open Source is combining the forces of the entire team. You can all share your individual expertise.

Now go do it

The moral of the story is that anyone can start an open source project — that means you, too. It doesn’t matter that you don’t have a huge, complicated idea for a giant project. It doesn’t matter that you haven’t been using GitHub for long, or ever. It doesn’t even matter that you don’t have any friends who code with whom you can collaborate. You can do it, and I really hope you will. You will learn so much, and you will help make open source more approachable for other beginners.

If you have any questions, or you want to talk, feel free to reach me on twitter @lineal and join my Prog-o-meter open source project.