Forem: Kat 🐆🐾

Learning GO with Codeacademy

Kat 🐆🐾 — Sat, 28 Nov 2020 18:22:23 +0000

Introduction

Go was developed at Google with the goal to eliminate the slowness and clumsiness of software development at Google, and thereby to make the process more productive and scalable. In other words, Go is supposed to make development faster and easier for developers.

It has modern features like garbage collection and also takes advantage of multi-core computer capabilities with built-in concurrency support.

Read up on why Go has become popular.

Other learning resources:

Compiling & Running Files

A compiler translates Go code into an executable/binary file.

Compile and run a file called file_name.go:

go build file_name.go
./file_name

Alternatively, using go run does combine both compilation and execution of code, but does not create an executable file:

go run file_name.go

Basic Go Structure: Packages

Let's look at the following code:

package main

import "fmt"

func main() {
  fmt.Println("Hello World")
}

package main
- This is a package declaration.
- Every Go program starts with one.
- It informs the compiler whether to create an executable or library.
- A library doesn't execute code. It is a collection of code that can be used in other programs.
- package main creates an executable file.
import "fmt"
- import imports code from other packages
- Packages are enclosed with double quotes "
func main() {...}
- While we define the main function, we never explicitly tell main to run its block of code.
- The main function is special: a file that has a package main declaration will automatically run the main function

Importing Multiple Packages

To import multiple packages, we can write

import "package1"
import "package2"

import (
  "package1"
  "package2"
)

Providing an alias to a package:

import (
  p1 "package1"
  "package2"
)

By using an alias, we can call functions from package1 by using p1 like this:

p1.SampleFunc()

instead of:

package1.SampleFunc()

Comments

Go encourages the use of comments for describing what functions do. It gets used by Go's documentation tool.

// This is a comment
/*
This is a multiline
comment.
*/

Go Resources

Go has a built-in documentation system. Use the command go doc followed by a package name, e.g.:

go doc fmt

Get more specific information about a function in a package, e.g:

go doc fmt.Println

Note: The capitalization of the function doesn't matter, this will also work: go doc fmt.println.

Fun Application

package main

import "fmt"

func main() {
  const gopher = 
"      `.-::::::-.`\n" +
"  .:-::::::::::::::-:.\n" +
"  `_:::    ::    :::_`\n" +
"   .:( ^   :: ^   ):.\n" +
"   `:::   (..)   :::.\n" +
"   `:::::::UU:::::::`\n" +
"   .::::::::::::::::.\n" +
"   O::::::::::::::::O\n" +
"   -::::::::::::::::-\n" +
"   `::::::::::::::::`\n" +
"    .::::::::::::::.\n" +
"      oO:::::::Oo\n"

  const dog = 
"  __      _\n" +
"o'')}____//\n" +
" `_/      )\n" +
" (_(_/-(_/\n"
  fmt.Println(gopher)
  fmt.Println(dog)
}

Variables and Formatting

Example program showing

string
number (int8)
boolean

package main

import "fmt"

func main() {
  var stationName string
  var nextTrainTime int8
  var isUptownTrain bool

  stationName = "Union Square"
  nextTrainTime = 12
  isUptownTrain = false

  fmt.Println("Current station:", stationName)
  fmt.Println("Next train:", nextTrainTime, "minutes")
  fmt.Println("Is uptown:", isUptownTrain)
}

Literals

Literals are values written into code "as they are", e.g. 109, or "hello world". They are unnamed values.

Constants and Variables

Constants cannot be updated while the program is running.
Variables can update their value

package main

import "fmt"

func main() {
  const earthsGravity = 9.80665

  fmt.Println(earthsGravity)
}

Basic Data Types in Go

int
float
complex

Basic Numeric Types in Go

Numeric types documentation

What is a Variable?

Variables are defined with the var keyword and two pieces of information: the name that we will use to refer to them and the type of data stored in the variable.

var lengthOfSong uint16
var isMusicOver bool
var songRating float32

You can declare and assign a variable in one line, with or without declaring the type specifically:

var firstName = "Kat"
var middleName string = "Xenia"
fmt.Println(firstName + ", " + middleName)

Zero Values

Even before we assign anything to our variables they hold a value. Go's designers attempted to make these "sensible defaults" that we can anticipate based on the variable's types.

var classTime uint32
var averageGrade float32
var teacherName string
var isPassFail bool

fmt.Println(classTime) // Prints 0
fmt.Println(averageGrade) // Prints 0
fmt.Println(teacherName) // Doesn't print anything, default: ""
fmt.Println(isPassFail) // Prints false

Inferring Type

There is a way to declare a variable without explicitly stating its type using the short declaration := operator. We might use the := operator if we know what value we want our variable to store when creating it.

The following defines a bool, float, int, and string without specifying the type:

nuclearMeltdownOccurring := true
radiumInGroundWater := 4.521
daysSinceLastWorkplaceCatastrophe := 0
externalMessage := "Everything is normal. Keep calm and carry on."

Floats created this way are of type float64. Integers created this way are either int32 or int64.

An alternative syntax to declare a variable and infer its type is:

var nuclearMeltdownOccurring = true
var radiumInGroundWater = 4.521
var daysSinceLastWorkplaceCatastrophe = 0
var externalMessage = "Everything is normal. Keep calm and carry on."

Default int Type

There is one more common way to define an int in Go. Computers actually have a default length for the data in the Read-Only Memory (ROM). Some newer computers may have more processing power and can store/handle bigger chunks of data. These computers might be using a 64-bit architecture, but other computers still run on 320bit architecture and work just fine.

By providing the type int or uint, Go will check to see if the computer architecture is running on is 32-bit or 64-bit. Then it will either provide a 32-bit int (or uint) or a 64-bit one depending on the computer itself.

It is recommended to use int unless there's a reason to specify the size of the int (like knowing that value will be larger than the default type, or needing to optimize the amount of space used).

The following two variables are integers of either 32 or 64 bits:

var timesWeWereFooled int
var foolishGamesPlayed uint

When a variable is declared and assigned a value using the := operator, it will be the same type as if it were declared as an int:

consolationPrizes := 2

Multiple Variable Declaration

There are more than one way to declare multiple variables on a single line.

var part1, part2 string
part1 = "To be..."
part2 = "Not to be..."

quote, fact := "Bears, Beets, Battlestar Galactica", true
fmt.Println(quote) // Prints: Bears, Beets, Battlestar Galactica
fmt.Println(fact) // Prints: true

The fmt Package

fmt is one of Go's core packages. It helps format data, which is why it's sometimes referred to as the format package.

There are a few methods in the fmt package:

Printing data to the terminal
- Println()
- Print()
- Printf()
Formatting (without printing to the terminal)
- Sprint()
- Sprintln()
- Sprintf()
Getting user input
- Scan()

The Print Method

fmt.Println() allows us to print to the terminal. It has some default styling built-in that makes viewing data easier. fmt.Println() prints its arguments with an included space in between each argument and adds a line break at the end.

Example:

fmt.Println("Println", "formats", "really well")
fmt.Println("Right?")

Println formats really well
Right?

In the case that default formatting is not wanted, fmt.Print() is more appropriate. It does not add default spacing, nor a line break.

The Printf Method

Using fmt.Println() and fmt.Print(), we have the ability to concatenate strings, i.e. combine different strings into a single string:

guess := "C"
fmt.Println("Is", guess, "your final answer?")
// Prints: Is C your final answer?

With fmt.Printf(), we can interpolate strings, or leave placeholders in a string and use values to fill in the placeholders.

selection1 := "soup"
selection2 := "salad"
fmt.Printf("Do I want %v or %v?", selection1, selection2)
// Prints: Do I want soup or salad?

The %v in the string is the placeholder and known as a verb in Go.

Different Verbs

In addition to %v, Go has a variety of useful verbs.

Example: %T prints out the type of a variable

specialNum := 42
fmt.Printf("This value's type is %T.", specialNum)
// Prints: This value's type is int.

quote := "To do or not to do"
fmt.Printf("This value's type is %T.", quote)
// Prints: This value's type is string.

Example: %d interpolates a number into a strgin

votingAge := 18
fmt.Printf("You must be %d years old to vote.", votingAge)
// Prints: You must be 18 years old to vote.

Example: %f interpolates a float into a string, with the option to limit the precision:

gpa := 3.8
fmt.Printf("You're averaging: %f.", gpa)
// Prints: You're averaging 3.800000.

fmt.Printf("You're averaging: %.2f.", gpa)
// Prints: You're averaging 3.80.

Sprint and Sprintln

fmt.Sprint() and fmt.Sprintln() format strings instead of printing them out.

The following example shows how fmt.Sprint() returns a value that can be stored in a variable and used later.

grade := "100"
compliment := "Great job!"
teacherSays := fmt.Sprint("You scored a ", grade, " on the test! ", compliment)

fmt.Print(teacherSays)
// Prints: You scored a 100 on the test! Great job!

fmt.Sprint() doesn't include spaces or newline:

quote = fmt.Sprintln("Look ma,", "no spaces!")
fmt.Print(quote) // Prints Look ma, no spaces!

The Sprintf Method

fmt.Sprintf() uses verbs just like fmt.Printf():

  template := "I wish I had a %v."
  pet := "puppy"

  var wish string

  // Add your code below:
  wish = fmt.Sprintf(template, pet)

  fmt.Println(wish)

Scan(): Getting User Input

fmt.Println("How are you doing?") 

var response string 
fmt.Scan(&response)

fmt.Printf("I'm %v.", response)

fmt.Scan()

reads in a string up until a whitespace
expects addresses for arguments

Conditionals

The if statement does not necessarily need parentheses:

alarmRinging := true
if alarmRinging {
  fmt.Println("Turn off the alarm!!") 
}

isHungry := false
if (isHungry) {
  fmt.Println("Eat the cookie") 
} else {
  fmt.Println("Step away from the cookie...")
}

Comparison & Logical Operators

To use a comparison operator, we have two values (or operands) with a comparison operator in between the two values.

if day == "Saturday" || day == "Sunday" {
  fmt.Println("Enjoy the weekend!")
} else {
  fmt.Println("Do some work.")
}

else if Statement

position := 2

if position == 1 {
  fmt.Println("You won the gold!")
} else if position == 2 {
  fmt.Println("You got the silver medal.")
} else if position == 3 {
  fmt.Println("Great job on bronze.")
} else {
  fmt.Println("Sorry, better luck next time?")
}

switch Statement

clothingChoice := "sweater"

switch clothingChoice {
case "shirt":
  fmt.Println("We have shirts in S and M only.")
case "polos":
  fmt.Println("We have polos in M, L, and XL.")
case "sweater":
  fmt.Println("We have sweaters in S, M, L, and XL.")
case "jackets":
  fmt.Println("We have jackets in all sizes.")
default:
  fmt.Println("Sorry, we don't carry that")
}
// Prints: We have sweaters in S, M, L, and XL.

Scoped Short Declaration Statement

We can provide a short variable declaration before we provide a condition in either if or switch statements.

x := 8
y := 9
if product := x * y; product > 60 {
  fmt.Println(product, "  is greater than 60")
}

Notice that the variable declaration is separated from the condition using a semi-colon ;.

switch season := "summer" ; season {
case "summer"
  fmt.Println("Go out and enjoy the sun!")
}

The variable that is declared using the short variable declaration is scoped to the statement blocks. This means that the variable is only accessible within the blocks of those statements and not anywhere else.

This code will throw an error:

x := 8
y := 9
if product := x * y; product > 60 {
  fmt.Println(product, "  is greater than 60")
}
fmt.Println(product)

Randomizing

Go has a math/rand library that has methods to generate random numbers.

import (
  "math/rand"
  "fmt"
)

func main() {
  fmt.Println(rand.Intn(100))
}

The rand.Intn() method takes an argument, which is the maximum value that the method will return. It will return a random integer from 0 to 100.

Seeding

Go seeds (chooses) a number as a starting point for generating random numbers. By default, the seed value is 1. We can provide a new seed value using the method rand.Seed() and passing in an integer.

The seed number should always be a unique number, which can be achieved using time.

package main

import (
  "fmt"
  "math/rand"
  "time"
)

func main() {
  rand.Seed(time.Now().UnixNano())
  fmt.Println(rand.Intn(100))
}

time.Now().UnixNano() results in the difference in time (in nanoseconds) since January 1st, 1970 UTC. Check out the UnixNano documentation for more details.

Functions

func doubleNum(num int) int {
  return num * 2
}

The call site is the place where a function is called. Values that are returned from functions are set from within the function to the call site. A function can be given a return type.

func getLengthOfCentralPark() int32 {
  var lengthInBlocks int32
  lengthInBlocks = 51
  return lengthInBlocks
}

Function parameters are variables that are used within the function. When calling a function, we give arguments, which are the values that we want those parameter variables to take.

func multiplier(x int32, y int32) int32 {
  return x * y
}

Since both parameters in the function above are the same, we could write it as:

func multiplier(x, y int32) int32 {
  return x * y
}

Scope

Scope keeps the namespace, the available variables and keywords, cleaner. Variables or functions can only be referred to in their respective namespace.

Multiple Return Values

func GPA(midtermGrade float32, finalGrade float32) (string, float32) {
  averageGrade := (midtermGrade + finalGrade) / 2
  var gradeLetter string
  if averageGrade > 90 {
    gradeLetter = "A"
  } else if averageGrade > 80 {
    gradeLetter = "B"
  } else if averageGrade > 70 {
    gradeLetter = "C"
  } else if averageGrade > 60 {
    gradeLetter = "D"
  } else {
    gradeLetter = "F"
  }

  return gradeLetter, averageGrade 
}

func main() {
  var myMidterm, myFinal float32
  myMidterm = 89.4
  myFinal = 74.9
  var myAverage float32
  var myGrade string
  myGrade, myAverage = GPA(myMidterm, myFinal)
  fmt.Println(myAverage, myGrade) // Prints 82.12 B
}

Deferring Resolution

We can delay a function call to the end of the current scope by using the defer keyword. defer tells Go to run a function, but at the end of the current function. This is useful for logging, file writing, and other utilities.

func calculateTaxes(revenue, deductions, credits float64) float64 {
  defer fmt.Println("Taxes Calculated!")
  taxRate := .06143
  fmt.Println("Calculating Taxes")

  if deductions == 0 || credits == 0 {
    return revenue * taxRate
  }


  taxValue := (revenue - (deductions * credits)) * taxRate
  if taxValue >= 0 {
    return taxValue
  } else {
    return 0
  }
}

In the example above, the first print statement is being deferred. Normally, we would consider adding the print statement at the end of the function. But given that there are multiple return statements, instead of adding the same print statement before each return, defer can be used to print it regardless of when the function ends.

Addresses and Pointers

Go is a pass-by-value language, but it is possible to change values from different scopes using:

Addresses
Pointers
Dereferencing ### Addresses To find a variable's address we use the & operator followed by the variable name:

x := "My very first address"
fmt.Println(&x) // Prints 0x414020

Pointers

Pointers are used to store addresses.

var pointerForInt *int

The * operator signifies that this variable will store an address and the int portion means that the address contains an integer value.

var pointerForInt *int

minutes := 525600

pointerForInt = &minutes

fmt.Println(pointerForInt) // Prints 0xc000018038

Declare a pointer implicitly:

minutes := 55

pointerForInt := &minutes

Dereferencing

Dereferencing or indirecting refers to accessing the value at a given address.

lyrics := "Moments so dear" 
pointerForStr := &lyrics

*pointerForStr = "Journeys to plan" 

fmt.Println(lyrics) // Prints: Journeys to plan

Changing Values in Different Scopes

By passing the value of a pointer, we can dereference the address and change the value in the function. The function call needs to pass in the address of the variable.

func addHundred (numPtr *int) {
  *numPtr += 100
}

func main() {
  x := 1
  addHundred(&x)
  fmt.Println(x) // Prints 101
}

DS & Algos for Interviewing in Python

Kat 🐆🐾 — Wed, 09 Sep 2020 13:18:47 +0000

I am preparing to interview at FANG companies, and am reviewing the material I've learned at the Data Structures & Algorithms Nanodegree at Udacity.

Here's an overview of the topics that are covered in the Nanodegree:

Introduction
1. Python Refresher
2. How to Solve Problems
3. Efficiency
4. -- Solve some problems --
Data Structures
1. Arrays & Linked Lists
2. Stacks & Queues
3. Recursion
4. Trees
5. Maps and Hashing
6. -- Solve some problems --
Basic Algorithms
1. Basic Algorithms
2. Sorting Algorithms
3. Faster Divide & Conquer Algorithms
4. -- Solve some problems --
Advanced Algorithms
1. Greedy Algorithms
2. Graph Algorithms
3. Dynamic Programming
4. A*
5. -- Implement A* --

This blog series is the place where I'm planning to collect and save materials for future reference.

ELI5: Database Normalization?

Kat 🐆🐾 — Sat, 07 Dec 2019 13:43:46 +0000

Dear fellow devs 👋🏻,

🤓 I just started learning about databases, took the mode SQL tutorial and am taking a course on Fullstack Web Development.

👩🏻‍🎓 At some point, I will take a deep dive into database design, but for now, can you help me get a general idea of database normalization?

🤔What does it mean when a table is in first, second, or third normal form (1NF, 2NF, 3NF)?

Thanks,
Kat 🐱🐾

Learn in Public: Data Structures & Algorithms in Python

Kat 🐆🐾 — Wed, 20 Nov 2019 02:21:05 +0000

I am currently working on becoming more proficient in Data Structures and Algorithms - both for the sake of interviewing and to become a better engineer.

In the following weeks and months, I'll share with you what I've learned along my journey. The content will include:

The theory and application of Data Structures & Algorithms.
My interviewing experience, tips, and tricks.
Fun problems you can solve using what we've learned.

❗️Please share any additional resources that you'd recommend, and topics that I forgot to add in the comments below!

Learning Method

I love learning, but I am not an efficient student. I am great at "consuming" material, like taking courses and going through tutorials. But if you ask me to explain what I've learned, I wouldn't be able to do so. I would say "it just slips my mind", but truth be told I never do the work to commit the material into my long term memory.

This time it is going to be different, and I am going to utilize the following two strategies to improve my retention of what I've learned:

Use scientific methods for efficient learning.
Following the idea of learning in public, I am going to summarize and share what I'm learning along the way. Learning by teaching makes sure you truly understand the material.

List of Resources

For now, let's start with a summary of resources and a list of topics we'll cover in the following weeks and months.

This is not an exhaustive list of all the resources that are available on the WWW, but rather a list of courses I find intriguing, and the books I own.

Legend to indicate where I'm at:
❗️: Currently working on
✅: Done
💤: Done, but needs a refresher

This is a living list, meaning I'll be coming back and updating it as I work through the material.

Data Structure & Algorithm Courses

Coursera
- Algorithms Specialization, Stanford
- Data Structures & Algorithms Specialization, University of California San Diego
- Algorithms, Part I, Princeton University 💤
- Algorithms, Part II, Princeton University
Udacity
- Data Structures & Algorithms Nanodegree ✅

Books

Websites

CodeSignal ❗️
Pramp, these are actual mock interviews with real people. You get to experience both sides: Being the interviewee as well as interviewing your peers.

Content

Analyzing Algorithms
- Asymptotic Notation
- Amortized Analysis
- Probabilistic Analysis & Randomized Algorithms
Data Structures
- Arrays & Linked Lists ❗️
- Stacks & Queues
- Hash Tables
- Trees
- Binary Search Trees
- Red-Black Trees
- B-Trees
- Binomial Trees & Binomial Heaps
- Fibonacci Heaps
- Data Structures for Disjoint Sets
Recursion
Sorting & Order Algorithms
- Heapsort
- Quicksort
- Sorting in Linear Time
Graph Algorithms
- Breadth-first search (BFS)
- Depth-first search (DFS)
- Topological Sort
- Minimum Spanning Trees
- Single-Source Shortest Paths
- All-Pairs Shortest Paths
- Maximum Flow
Dynamic Programming
Greedy Algorithms
Linear Programming
Sorting Networks
Matrix Operations
Polynomials & the FFT
Number-Theoretic Algorithms
String Matching
Computational Geometry
NP-Completeness
Approximation Algorithms
Maps & Hashing
Tries
Heaps
Divide & Conquer
A*

Upgrade your learning + an example study plan for data structures and algorithms

Kat 🐆🐾 — Mon, 18 Nov 2019 20:34:40 +0000

Being an engineer means embracing lifelong learning. That's why taking a closer look at your learning methods and taking steps to improve them can help you become a better engineer.

The following is a summary of techniques that can help you master the material you're studying in a shorter amount of time - taken from the course Learning How To Learn on Coursera. I do highly recommend the (free!) course to get a better understanding of the concepts and how they fit together.

Scroll down to get an example of how to apply those techniques to studying data structures and algorithms.

The path from novice to expert

🙇🏻‍♀️🎮🙇🏻‍♀️🏃🏻‍♀️🙇🏻‍♀️ Understanding material: Alternate between focused & diffuse mode

Switch between focusing on the material you're learning (focused mode) and taking breaks where you focus on something else or where your mind gets to wander around (diffuse mode, e.g. going on a walk/run, cooking, playing, relaxing, taking a nap, etc.)

❗️Alternating between focused mode & diffuse mode thinking is crucial for understanding difficult material.
❗️You can use the Pomodoro technique to help you alternate between focusing on the material, and taking regular breaks.

💾 Remembering material: Commit material into your Long Term Memory (LTM)

Once you understand the material, you have to commit it to your LTM to achieve true mastery.

Procrastination

Committing material from your Short Term Memory (STM) into your Long Term Memory (LTM) takes time, which is why tackling procrastination is of the highest priority. Overcome procrastination by focusing on process vs. product (e.g. by using the Pomodoro technique).

Methods to commit material into your LTM

❌ Just wanting to learn the material and spending a lot of time with it doesn't guarantee that you'll learn it.

❗️Avoid the illusion of competence by using the following techniques:

Time
- Be aware that saving something in your LTM will take time. Be patient with yourself.
Deliberate practice
- Deliberately choose to practice what you find most difficult to grasp until it clicks and sticks.
Spaced repetition
- You need to repeat the material spaced over days and weeks for it to get safely stored in your LTM.
Recalling
- Avoid the illusion of competence by continuously testing yourself on the material you're learning.
- Close your book and try to remember what you just learned.
- Practice recalling in various locations to be able to access the material no matter where you are.
- Try to recall the material one more time right before going to bed.
Sleep
- Does not only make you more beautiful but also flushes out toxins from your brain and strengthens the neural pathways you create when you learn something new.
Tap into your visual memory system & senses
- Your visual memory system is extremely powerful and can be used to save knowledge in your LTM in a shorter amount of time.
- Make a metaphor/visual image for the concept you're learning.
- Use the memory palace technique to place the image into an imagined space/house/village.
- Try to use your senses to memorize it if possible (vision, smell, touch, hearing, smelling).

🔗🎨 Increase your knowledge base & apply it creatively

Create chunks:
- Start small with mini-chunks, little by little.
- Connect the mini-chunks into more complex, bigger chunks through practice & repetition, and by using big-picture thinking.
Interleaving
- Use interleaving to learn when you should use a certain technique/concept and to enhance creative thinking.

Example Study Plan: Datastructures and Algorithms

❗️At all times:

Alternate between focused mode & diffuse mode.
If you struggle with procrastination, use the Pomodoro technique.
Make sure you sleep & eat well, and get regular exercise.

1. Step: Get an understanding of data structures and algorithms by going through a course, reading books, and taking notes. Vary the sources you're learning from to enhance your understanding. Here is a list of courses:

Data Structures and Algorithms Specialization, University of California San Diego
Algorithms, Part 1, Princeton University
Algorithms, Part 2, Princeton University
Algorithms Specialization, Stanford University
Data Structures & Algorithms, Udacity

2. Step: Write index cards from your notes with important facts. For example:

"List all searching algorithms"
"What's the Dijkstra algorithm"
"What is the time & space complexity of binary search"

3. Step: Recall & deliberate practice.

Use your notes & index cards to test yourself repeatedly, spaced over time, until you remember all the facts.
- Recall the material one last time before going to bed.
- Recall material at various places, e.g. when commuting, at a cafe, in a different room, etc.
Deliberately practice material that you find difficult to grasp by doing exercises. My preferred way to practice is using the following resources:
- CodeSignal
- Cracking the Coding Interview

4. Step: As you build a library of small chunks of knowledge, take a step back and try to understand the big picture of everything you've learned so far, and how things are connected.

👩🏻‍🏫 Repeat Steps 1 - 4 until you are a master in data structures and algorithms.

Summary

Using scientifically proven learning techniques can be tedious and time-costly if you're not used to them. But as you keep practicing and applying these methods to everything you're trying to learn, you'll save a significant amount of time in the long run and will be able to achieve true mastery in your chosen field of study.

How I overcame my fear of writing

Kat 🐆🐾 — Mon, 18 Nov 2019 01:18:31 +0000

I am new to blogging. To get into the habit of writing, I set a goal to write daily for 30 days - but had to overcome several issues first that kept me from getting started.

Are you ...

new to blogging and don't know where to begin?
scared to put yourself out there?
worried that you have nothing worthwhile to contribute?
not sure how to structure your blog posts?
getting stuck on markdown details?
wondering how to add emojis to your dev.to posts?

I'm with you! This is what I've learned, maybe it will resonate with you. If not, please share your own experiences & thoughts in the comments below to help your fellow devs!

My obstacles & how I hacked them

😱 Fear of authenticity & vulnerability

Being authentic and vulnerable is hard, and online shaming is real (thankfully not allowed on dev.to). Sharing your thoughts, experiences, and knowledge online with the entire world means you have to be courageous, vulnerable, and open to criticism.

My discovery of Brené Brown and Gabor Maté helped me understand why I struggle with vulnerability and authenticity, and that it's worth to overcome those fears to live wholeheartedly, to tell your story, and connect with people. To get an intro, check out these videos on vulnerability and authenticity.

“Courage starts with showing up and letting ourselves be seen.” - Brené Brown

😟 "I have nothing new to contribute"

This kept me from writing my own content for many years - even though I always wanted to! There are plenty of reasons to start blogging. Making a list of your "why" will not only help you overcome self-doubt when you need it most but also give your blog a common thread.

Here is a list of my reasons to start writing:

I love writing - I have journals and handwritten notes everywhere. Maybe going online will help me declutter my home? 😜
I choose to learn in public.
Writing helps me to structure and remember what I'm learning.
I can use my blog posts as a library of my knowledge that I can refer to later on.
I've been inspired by numerous blog posts written by "ordinary" people, and I am very grateful to have found those. Even though it's not the main reason for me to write, the likelihood of someone getting inspired by what I write is L >= 0, which is good enough for me 😉
It helps me practice vulnerability & authenticity.
Getting the social media dopamine boost when people like my content is fun and the least damaging when applied to blogging 🤪

🤔 I don't know where to begin

Just write about what you're currently learning, working on, thinking about, dreaming of, creating, contributing to, or wondering about. Simple as that 🙃

🗂 How should I structure my blog posts?

A simple structure like this will do:

I found this article helpful.

I enjoy visual blog posts and like to create my own images, GIFs, and visualizations to explore and express my creativity. I do currently use the following tools:

iPad Pro + Apple Pencil + Tayasui Sketches
Giphy account to create & upload my GIFs
Imgur account to upload my images

🙈 I keep putting it off

I tend to procrastinate when I'm supposed to do something that feels uncomfortable (like writing!). After taking the infamous "Learning How To Learn" course on Coursera, I've learned that the icky feeling I get when I'm supposed to do something I find difficult is actual pain. Procrastination simply helps to avoid feeling this pain!

Understanding that helped me be more compassionate and patient with myself. It was also helpful to hear that the pain subsides shortly after you get started on your task and that the pomodoro technique 🍅 is a powerful tool to overcome this problem. I like to use this app on my mac.

ℹ How to format & spell check your blog post

Markdown Cheat Sheet
How to add emojis to dev.to posts
Grammarly if English is not your strongest suit or native language.

Summary

Writing is not easy but well worth the effort and time. If you struggle with getting started, you might want to take some time to identify your personal obstacles and find strategies on how to overcome them.

Share your personal experience with blogging in the comments below!

How do you pimp your blog post?

Kat 🐆🐾 — Sun, 30 Dec 2018 23:12:43 +0000

I just wrote my first blog post here at dev.to but found it difficult to pimp it with emojis and highlights.

How do you add emojis? What other tips do you have to make articles visually pleasing and interesting?

#100DaysOfCoding changed my life...

Kat 🐆🐾 — Sun, 30 Dec 2018 22:20:08 +0000

... and I'm only on Day [003/100]!

The first time I heard of the #100DaysOfCoding challenge was in 2014. I read an article about Jennifer Dewald and how she taught herself how to code by making a website every day for 180 days in a row. I was incredibly impressed by her accomplishment and doing a challenge like this was on my ToDo list ever since.

But I wasn't ready... until now. I needed to read another inspiring blog post written by Rachel before I decided that it is time to commit to the challenge.

Why am I doing it?

I have always admired software developers who would come home after a day at the office, and sit down to work on their side projects. It is obvious that they love coding, are confident in their abilities, and they consider coding as a pastime. These attributes are also what makes them excellent at their job.

That was never me. I am motivated and excited, I love coding, but when I'm supposed to sit down I doubt myself and end up watching Netflix instead. The reason is that I want to avoid dealing with and overcoming my self-destructive thoughts:

Fears and self-doubt: "I'm not able to do this project. I will fail and once I fail I'll never make it. Better not to start at all to keep my options open!"
Laziness: "This is hard work, isn't it? I am tired and deserve to relax."
Perfectionism: "If I do this challenge, it has to be perfect. If I don't make impressive progress every day, it does not count. You know you'll fail, so don't even try."

I know this is a wall I built myself, and I can break it down and make the sky my limit!

(Sidenote: I noticed how these thoughts are similar to those that made me fail at losing weight. Fears would hold me back from even getting started, laziness would keep me in the couch and away from the gym, and perfectionism would lead to black and white thinking which in turn made my weight bounce like a yo-yo until I gave up in exhaustion. Spoiler alert: I cracked this behavior in 2018 and lost successfully 16 pounds and am maintaining my weight with ease 💪)

My goals

Improve my fluency in Python and C++.
Practice data structures and algorithms.
Break down the barriers in my head and grow my self-confidence.
Make it easy to sit down and code, and build the habit to prefer coding over Netflix.
Implement projects and contribute to open source.
Get those badges in Codesignal and green up my Github contribution calendar! 💪

My rules

Code for at least one hour per day.
Take it easy during the week: work on small coding challenges in Codesignal.
Work on bigger projects and open source contributions on the weekend.
Summarize what I have learned in a blog post, once a week, written on weekends.
I can earn a "joker" by coding extra hours. Those will come in handy when I want to go on weekend trips or camping, and I know I won't be able to code on those days.
Take it slow. Small steps on a daily basis will bring me further than trying too much, too soon, and potentially burning out and giving up. I will get naturally better and faster, and before I know it I'll make big strides on a daily basis.

What I've learned so far

It has been only three days into the challenge, but I have already learned a lot!

Every time I finish a new coding task in Codesignal, I look at other peoples solutions and compare their code to mine. That way, I learn different ways of thinking, and more often than not neater ways to implement the solutions.

So far I've learned about:

Differences between Python 2 and Python 3, for example:
- While / is an integer-point division in Python 2, it is a floating-point division in Python 3. In order to get an integer division in Python 3 you have to use //.
You can reverse a list using extended slices, e.g. myList[::-1]
Lambdas are anonymous functions. The syntax to use them is lambda argument: manipulate(argument), e.g. add = lambda x, y: x+y
List comprehensions and Dict comprehensions
The map function

Furthermore, I do already feel more confident in my abilities, and the wall of self-doubt is coming down fast. The time I need to convince myself to sit down and code get progressively smaller, and once I'm at it, I don't want to stop!

The #100DaysOfCoding challenge is also the kick-off for me daring to write blog posts (see here, it's my first one!), me giving the world a glimpse to my life through social media (follow me on Instagram and Twitter), and me committing to other #100DaysOfX challenges such as:

#100DaysOfRunning (Aiming for the NYC marathon 2019! Are you on Strava? Become my friend: Strava)
#100DaysOfUnsubscribing (Gotta clean out my inbox from spam, it's out of control)
#100DaysOfMeditation (I need to improve emotion regulation and concentration. My monkey mind is out of control as well 😛)
#100DaysOfStretching (I'm great at being active but real bad at rehab and stretching, but that's about to change!)

I would call that life-changing 🤟

Forem: Kat 🐆🐾

Learning GO with Codeacademy

Introduction

Compiling & Running Files

Basic Go Structure: Packages

Importing Multiple Packages

Comments

Go Resources

Fun Application

Variables and Formatting

Literals

Constants and Variables

Basic Data Types in Go

Basic Numeric Types in Go

What is a Variable?

Zero Values

Inferring Type

Default int Type

Multiple Variable Declaration

The fmt Package

The Print Method

The Printf Method

Different Verbs

Sprint and Sprintln

The Sprintf Method

Scan(): Getting User Input

Conditionals

Comparison & Logical Operators

else if Statement

switch Statement

Scoped Short Declaration Statement

Randomizing

Seeding

Functions

Scope

Multiple Return Values

Deferring Resolution

Addresses and Pointers

Pointers

Dereferencing

Changing Values in Different Scopes

DS & Algos for Interviewing in Python

ELI5: Database Normalization?

Learn in Public: Data Structures & Algorithms in Python

Learning Method

List of Resources

Data Structure & Algorithm Courses

Books

Websites

Content

Upgrade your learning + an example study plan for data structures and algorithms

The path from novice to expert

🙇🏻‍♀️🎮🙇🏻‍♀️🏃🏻‍♀️🙇🏻‍♀️ Understanding material: Alternate between focused & diffuse mode

💾 Remembering material: Commit material into your Long Term Memory (LTM)

Procrastination

Methods to commit material into your LTM

🔗🎨 Increase your knowledge base & apply it creatively

Example Study Plan: Datastructures and Algorithms

Summary

How I overcame my fear of writing

My obstacles & how I hacked them

😱 Fear of authenticity & vulnerability

😟 "I have nothing new to contribute"

🤔 I don't know where to begin

🗂 How should I structure my blog posts?

🙈 I keep putting it off

ℹ How to format & spell check your blog post

Summary

How do you pimp your blog post?

How do you add emojis? What other tips do you have to make articles visually pleasing and interesting?

#100DaysOfCoding changed my life...

... and I'm only on Day [003/100]!

Why am I doing it?

My goals

My rules

What I've learned so far

Which challenge are you going to commit to?