# Python List Comprehension: An Intro and 5 Learning Tips

### Python list comprehension: an introduction and 5 great tips to learn

Python list comprehension empowers you to do something productive with code. This applies even if you’re a total code newbie. At code(love), we’re all about teaching you how to code and embrace the future, but you should never use technology just for its own sake.

Python list comprehension allows you to do something useful with code by filtering out certain values you don’t need in your data and changing lists of data to other lists that fit specifications you design. Python list comprehension can be very useful and it has many real-world applications: it is technology that can add value to your work and your day-to-day.

To start off, let’s talk a bit more about Python lists. A Python list is an organized collection of data. It’s perhaps easiest to think of programming as, among other things, the manipulation of data with certain rules. Lists simply arrange your data so that you can access them in an ordered fashion.

Let’s create a simple list of numbers in Python.

```numbers = [5,34,324,123,54,5,3,12,123,657,43,23]
print (numbers)```
`[5, 34, 324, 123, 54, 5, 3, 12, 123, 657, 43, 23]`

You can see that we have all of the values we put into the variable numbers neatly arranged and accessible at any time. In fact, we can access say, the fifth variable in this list (54) at any time with Python list notation, or we can access the first 5 and last 5 values in the list.

`print(numbers[:5]); print(numbers[-5:]); print(numbers[4])`
```[5, 34, 324, 123, 54]
[12, 123, 657, 43, 23]
54
```

If you want to learn more about how to work with Python lists, here is the official Python documentation and an interactive tutorial from Learn Python to help you play with Python lists.

Python list comprehensions are a way to condense Python for loops into lists so that you apply a formula to each value in the old list to create a new one. In other words, you loop a formula or a set of formulae to create a new list from an old one.

What can Python list comprehensions do for you?

Here’s a simple example where we filter out exactly which values in our numbers list are below 100. We start by applying the [ bracket, then add the formula we want to apply (x < 100) and the values we want to apply it to for (x in numbers -> numbers being the list we just defined). Then we close with a final ] bracket.

```lessthan100 = [x < 100 for x in numbers]
print (lessthan100)```
```[True, True, False, False, True, True, True, True, False, False, True, True]
```
```#added for comparision purposes
[5, 34, 324, 123, 54, 5, 3, 12, 123, 657, 43, 23]```

See how everything above 100 now gives you the value FALSE?

Now we can only display which values are below 100 in our list and filter out the rest with an if filter implemented in the next, which is followed by the if trigger.

```lessthan100values = [x for x in numbers if x < 100]
print(lessthan100values)```
```[5, 34, 54, 5, 3, 12, 43, 23]
```

We can do all sorts of things with a list of numbers with Python list comprehension.

We can add 2 to every value in the numbers list with Python list comprehension.

```plus2 = [x + 2 for x in numbers]
print (plus2)```
```[7, 36, 326, 125, 56, 7, 5, 14, 125, 659, 45, 25]
```

We can multiply every value by 2 in the numbers list with Python list comprehension.

```multiply2 = [x * 2 for x in numbers]
print(multiply2)```
```[10, 68, 648, 246, 108, 10, 6, 24, 246, 1314, 86, 46]
```

And this isn’t just restricted to numbers: we can play with all kinds of data types such as strings of words as well. Let’s say we wanted to create a list of capitalized words in a string for the sentence “I love programming.”

```codelove = "i love programming".split()
codelovecaps = [x.upper() for x in codelove]
print(codelove); print(codelovecaps)```
```['i', 'love', 'programming']
['I', 'LOVE', 'PROGRAMMING']
```

Hopefully by now, you can grasp the power of Python list comprehension and how useful it can be. Here are 5 tips to get you started on learning and playing with data with Python list comprehensions.

### 1) Have the right Python environment set up for quick iteration

When you’re playing with Python data and building a Python list comprehension, it can be hard to see what’s going on with the standard Python interpreter. I recommend checking out iPython Notebook: all of the examples in this post are written in it. This allows you to quickly print out and change list comprehensions on the fly. You can check out more tips on how to get the right Python setup with my list of 11 great resources to learn and work in Python.

### 2) Understand how Python data structures work

In order for you to really work with Python list comprehensions, you should understand how data structures work in Python. In other words, you should know how to play with your data before you do anything with it. The official documentation on the Python website for how you can work with data in Python is here. You can also refer again to our resources on Python.

### 3) Have real-world data to play with

I cannot stress enough that while a Python list comprehension is useful even with pretend examples, you’ll never really understand how to work with them and get things done until you have a real-world problem that requires list comprehensions to solve.

Many of you came to this post with something you thought list comprehensions could solve: that doesn’t apply to you. If you’re one of those people who are looking to get ahead and learn without a pressing problem, do look at public datasets filled with interesting data. There’s even a subreddit filled with them!

Real-world data with code(love)

### 4) Understand how to use conditionals in list comprehensions

One of the most powerful applications of Python list comprehensions is the ability to be able to selectively apply different treatments to different values in a list of values. We saw some of that power in some of our first examples.

If you can use conditionals properly, you can filter out values from a list of data and selectively apply formulas of any kind to different values.

The logic for this real-life example comes to us from this blog post and Springboard’s Data Science Career Track.

Imagine you wanted to find every even power of 2 from 1 to 20.

In mathematical notation, this would look like the following:

A = {x² : x in {0 … 20}}

B = {x | x in A and x even}

```square20 = [x ** 2 for x in range(21)]
print(square20)```
`[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196, 225, 256, 289, 324, 361, 400]`
```evensquare20 = [x for x in square20 if x % 2 == 0]
print (evensquare20)```
```[0, 4, 16, 36, 64, 100, 144, 196, 256, 324, 400]
```

In this example, we first find every square power of the range of numbers from 1 to 20 with a list comprehension.

Then we can filter which ones are even by adding in a conditional that only returns TRUE for values that when divided by 2 return a remainder of 0 (even numbers, in other words).

We can then combine the two into one list comprehension.

```square20combined = [x ** 2 for x in range(21) if x % 2 == 0]
print(square20combined)```
`[0, 4, 16, 36, 64, 100, 144, 196, 256, 324, 400]`

Sometimes, it’s better not to do this if you want things to be more readable for your future self and any audience you’d like to share your code with, but it can be more efficient.

### 5) Understand how to nest list comprehensions in list comprehensions and manipulate lists with different chained expressions

The power of list comprehensions doesn’t stop at one level. You can nest list comprehensions within list comprehensions to make sure you chain multiple treatments and formulae to data easily.

At this point, it’s important to understand just what list comprehensions do again. Because they’re condensed for loops for lists, you can think about how combining outer and inner for loops together. If you’re not familiar with Python for loops, please read the following tutorial.

This real-life example is inspired from the following Python blog.

```list = [(x,y) for x in range(1,10) for y in range(0,x)]
print(list)```
```[(1, 0), (2, 0), (2, 1), (3, 0), (3, 1), (3, 2), (4, 0), (4, 1), (4, 2), (4, 3), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (7, 0), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (8, 0), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (9, 0), (9, 1), (9, 2), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8)]
```

If we were to represent this as a series of Python for loops instead, it might be easier to grasp the logic of a Python list comprehension. As we move from the outer loop to the inner loop, what happens is that for each x value from 1 to 9 (for x in range(1,10)), we print out a range of values from 0 to x.

```for x in range(1,10):
for y in range(0,x):
print(x,y)```
```1 0
2 0
2 1
3 0
3 1
3 2
4 0
4 1
4 2
4 3
5 0
5 1
5 2
5 3
5 4
6 0
6 1
6 2
6 3
6 4
6 5
7 0
7 1
7 2
7 3
7 4
7 5
7 6
8 0
8 1
8 2
8 3
8 4
8 5
8 6
8 7
9 0
9 1
9 2
9 3
9 4
9 5
9 6
9 7
9 8```

The chain of for loops we just went over has the exact same logic as our initial list comprehension. You’ll notice though that in a for loop, you will print seperate values while in a list comprehension it will produce a new list, which allows us to use Python list notation to play with the data.

With this in mind, you can make your code more efficient and easily manipulable with a Python list comprehension.

Learning Guides

# How to learn Ruby

In an online chat session between Yukihiro Matsumoto and Keiju Ishitsuka in early 1993, a discussion ensued about the name of a programming language that Matsumoto was going to write. He wanted to satisfy his desire to have an object-oriented scripting language, something that would craft virtual objects composed of data, and help them interact with one another. The alternatives at the time, Python and Perl didn’t appeal to him, Python being too object-oriented and Perl having “the smell of a toy language”. Between “Coral” and “Ruby”, Matsumoto decided to go with the latter because it was the birthstone of one of his colleagues.

You have probably heard about Ruby, and you might be wondering—what is all the fuss?

For starters, it’s written in a very easy-to-use, intuitive manner.

For beginners who have tried teaching themselves a programming language, there are many obvious barriers like the syntax and semantics of a language. Ruby strives to eliminate some of those barriers, for example, by naming functions in a very “natural-language” like format, the is_a? function does exactly what it promises, returning a Boolean (TRUE or FALSE) telling you whether a given object is of a certain type. The question mark at the end of the function is a Ruby idiosyncrasy that hints that the function always returns a Boolean. It may seem odd in the beginning, but as the amount of Ruby you read increases, the more natural this process will become.

Ruby is widely deployed ranging from applications in simulations, 3D modeling, business, robotics to web applications and security. For example, Basecamp – a project management application is programmed entirely in Ruby. Google SketchUp, a 3D modeling tool uses Ruby as its macro scripting API—programmers can add in scripts of their own to the SketchUp program, helping them do things such as automating routine modelling processes, similar to how macros work in Excel.

So how might you go about to learn Ruby, now that you are convinced that it is valued by the software community?

Learn ruby with code(love)

Though the usual suspects like Codecademy and Learn Ruby the Hard Way are good resources to learn Ruby, there are a bunch of other resources including Try Ruby, Ruby Koans, Ruby Warriors and many more. The one that really stands out as a gem (incidentally also the name of self-contained libraries in Ruby) is RubyMonk.

RubyMonk follows a narrative style of teaching Ruby along with some programming basics. The premise is based on you having a “master” who gives you much needed encouragement if you go wrong and also gives you triumphant messages when you succeed at some of the exercises. RubyMonk draws from movies, and video games to keep you plugging away to learn Ruby.

What really makes it stand apart from other resources is the way the entire learning environment is structured. Each page in the chapter has some introduction, a new concept, an exercise to try out, some more concepts with exercises and wrapping it up by using all the elements learned in that chapter in a slightly challenging exercise. There are several levels – Ruby Primer, Ruby Primer: Ascent, Metaprogramming Ruby and Metaprogramming Ruby: Ascent.

Each of the levels deliver content indicative of their name and each chapter is sprinkled with practical exercises.The design of the exercises and their placement is what makes the learning experience on this website fun and engaging. The exercises are just a little beyond the skill level you acquired in the lesson and require a little bit of thinking and are perfect for people who are just beginning to learn programming. They help easily transfer the theory you learned into practice.

Once, you’re done going through all of their material, you can be fairly confident that even if you can’t change the world with Ruby, you’ll at least have enough knowledge to create fun programs and venture into some complex ones with little additional effort.

Yet another reason to learn: Ruby serves as a wonderful background to migrate to the popular Ruby on Rails web framework, which makes the learning curve for making web applications much easier.

Ruby on Rails was constructed with the explicit goal of making it as easy as possible to build an interactive web platform, and maintain it. It speaks to the Ruby philosophy of simple, intuitive building.

After you learn Ruby, you will be able to build your ideas rapidly, and efficiently. You will have learned a valuable skill that will help make building natural.

Learning Lists

# Ten curated resources for you to learn code and entrepreneurship.

Imagine a world where you could access information as easily as you could breathe.

You can stop imagining: this is the world we live in.

With Google, almost everything can be a finger tap away. With the right keywords, you can access the right information.

The challenge now isn’t a lack of information—it’s how to access that information in a curated fashion.

In that sense, Github, the hub for open source software has become a good way to organize information. By modifying the README files typically used to document how software is used into a list or a resource itself, the open source movement is applying yet another twist to how it can leverage existing resources in new ways to solve old problems.

It is innovation in action. The best part of it is that you can contribute even if you’re non-technical by getting an account, and making pull requests that change the text: you update the text how you will, and then you can push the changes to moderators who will look over your proposed changes, or reject them.

Here’s a guide on how to go about doing that:

https://help.github.com/articles/creating-a-pull-request

Now to take a look at the resources that have been assembled for you to learn code and entrepreneurship.

### Entrepreneurship

https://gist.github.com/ndarville/4295324: A list of digital business models, along with a comparision to a company or startup known to be using that strategy.

### Code

https://github.com/bayandin/awesome-awesomeness: An overarching framework of most of the coding resources on Github, including a bunch of resources on technical topics.

https://github.com/gloparco/Master-List-of-HTML5-JS-CSS-Resources: A special list for HTML/CSS/JS resources.

https://github.com/sorrycc/awesome-javascript: A comprehensive overview of all things Javascript.

https://github.com/vinta/awesome-python: A list of the Python frameworks you can use.

https://github.com/akullpp/awesome-java: A similar list as awesome-python, this time for Java frameworks.

https://github.com/vhf/free-programming-books: An awesome curated list of free programming books.

https://github.com/bolshchikov/js-must-watch: A list of the videos you have to watch to really get Javascript.

https://github.com/dypsilon/frontend-dev-bookmarks: A list of resources a front-end developer has bookmarked over many years.

What are some awesome resources you’ve seen on Github? If I’m missing any, let me know in the comments below 🙂

Open News

# A curated list of great Python frameworks.

Coding community with code(love)

One of the wonderful things with modern programming languages—the sense of community associated with them.

Volunteers from around the world work without thought of reward in order to build a foundation for others to build on. The open source and open data movements allow for there to be an infusion of decentralized innovation.

Good old Python is one language that has been used for an array of different tasks, from manipulating data, to creating entire web platforms. Popular templates such as Django allow it to build household names such as Pinterest. Recently Python has become the most popular introductory language taught at American universities.

It represents a canvas which individual volunteers have painted in. You can plug and play different modules for all sets of tasks with the Python framework. For example, you can use Scrapy for web crawling, or SciPy for scientific calculations.

Each one of these modules comes with healthy communities supporting their maintenance and continued development, as well as ample documentation to allow everybody to really understand the tools they’re using.

The list is right here.

Open News

# CodeHS Teaches Code in Schools

CodeHS recently caught my eye. The site offers a curriculum and trained tutors that can help students learn code rapidly, adapting a program for teachers in schools across North America so that it’s easy for them to teach code to their students.

It’s a concept that introduces code to a whole lot more people, something that’s really cool to see in action.

As they put it, “the goal of CodeHS is to spread the knowledge of computer science by offering well-crafted instructional materials supported continuously by the quality, personal attention of our enthusiastic tutors. We believe that everyone has the ability to learn computer science, and we want to help them do so.”

They have a free interactive code lesson users can access at  http://codehs.com/signup_start once they’ve signed up for a free account.

As they describe it,”[CodeHS and our] free module teach Programming with Karel. Karel is a dog that only knows how to move, turn left, and place tennis balls in his world. We use Karel to show you what it means to program, and allow you to focus on problem solving without getting bogged down with syntax. By the end of the first module, students will have a good foundation on the fundamentals of programming and concepts such as loops, conditionals, and comments.”

Class in a box with CodeHS and code(love)

It looks nifty, and it’s something that lives up to the promise of a “class in a box”, making it easy for even struggling schools to get more code in front of their students. Here’s to hoping for more initiatives like this!

Open Stories

# Why learning code is so important—and how I learned.

Learning code is critical to understanding how the digital economy of the future will work. Much as we learn writing to instil in us the ability to relate to the perspectives of others, coding serves as a portal to understanding the logic that dictates the flow of information back and forth between different agents: the underpinning of the 21st century.

Learn code with code(love)

I began to learn code by working with a technical team at my previous startup ThoughtBasin. I’d say the process began with a natural curiosity towards peering at their screens, and then talks with them about the logic of code, and then applying that into practice with gamified platforms for learning code such as CodeAcademy

The one piece of advice to all of those on the fence looking in I’d give is to start now.  There’s no reason to delay.

### Sign up for my newsletter for entrepreneurship and code resources if this inspired you to learn.

Longform Reflections

# How to found a startup when you don’t know a line of code

As a non-technical founder, I did the worst thing possible. I created a founding team composed of other non-technical founders.

I didn’t know it at the time, but it was the death knell for my startup. It wasn’t because we got into arguments or we essentially had overlapping roles: no, it was simply the fact that none of us knew what we were doing.

It’s a problem that resonates often with people who are struggling to get into the startup scene as I once was. I’ve seen so many startups drift because their founders had no clue of what to do. All of these drifters tend to search relentlessly for the programmer of their dreams, as if in one fell swoop their inability to understand technology will be okay because, from the first grunt they hire, a team of grunts will be able to replicate out and do all of the work for them—forever until some imagined IPO for their technology startup.

It’s a problem. 90% of all small businesses fail in the first two years, and I’d wager the high failure rate with technology startups is based on the fact that so many who start these companies don’t properly appreciate their role in building out their idea.

Having lived through the experience myself, I’ve managed to snag some insights that can  change the situation for the better.

#### 1– There is no programmer who will save you from ignorance.

The wunderkind who will take on your idea and do everything for you? You’re never going to be able to attract that type if you have no idea what you’re talking about. Engineers are highly attuned to the sort of “let’s change the fields for the registration process, it should only take ten seconds!” talk that implies you know little about technology.

Even if you do somehow find somebody who is good enough to understand your idea figments and is able to translate them into crisp, actionable code, your work process will be affected because you won’t really know how to communicate efficiently with them and vice versa. You’ll never get exactly what you wanted if you don’t understand the rudiments of what your engineer is working with.

You don’t have to become an expert overnight, but there’s no excuse for not trying to cover the basics. Here’s a list of 31 free resources to get you started, and a newsletter focused on learning code. Start now, it’ll help!

No, he’s not coming to save you.

#### 2-You don’t even need a programmer to start testing your idea.

Surprise surprise! People get hung up on this notion that they need a bells-and-whistle online platform with all of the amenities for them to test their idea. That’s totally false. Lean and agile development have smashed that notion, and entrepreneurs have been testing their ideas out shoestring even before all that. Netflix started as a mailing service for DVDs that shipped your content physically—they only started to get on the Internet because they knew it was coming, but by then, they had already garnered a huge amount of subscriptions, so they knew their original hypothesis was correct: people would be willing to pay to access content on-demand and avoid dealing with video shops.

They didn’t need a web platform to do that. Figure out what your idea is actually testing, and test it yourself. Do you think people need an easier way to order dog food? Find forums where dog owners congregate, and ask them.

You don’t even have to mail them goods by mail. You can use a service like Unbounce: create a great landing page, and then collect emails to show that people care about what you’re selling.

A mailing list of thousands of people will help you spread your idea that much faster, and convince the star programmers you want to work with that you are their man. It will be the first sign of social proof and traction that your idea works. You’ll be the business man that can convince people to buy into an idea online, an invaluable trait engineers will be looking for.

An Unbounce-made landing page with code(love)

#### 3-Get involved with the startup scene. Read, connect, and collaborate.

While you work on how to get a digital following, you should also increase your value as a startup founder by devouring as much as you can about startups and technology. Read through The Next Web and similar outlets, follow tech influencers such as Tim O’Reilly, read through Startup CommunitiesLean Startup and Lean Analytics and other books on startups, just swallow it all up, and immerse yourself in this world. Go to the next meetup, meet the people in your startup community, and start building out a network.

The startup community works on the principle of “pay it forward”, so don’t be shy asking for help, and coffees from established influencers: more likely than not, they’ll say yes, in the hopes that you’ll do the same when you are faced with someone seeking advice. This is how a community grows strong: through collaboration. Embrace it.

Startup community with code(love)

————————————————————————————–

Founding a startup is already difficult. You can make it easier for yourself by learning what I have struggled through failure to appreciate. We all have the capacity to build something meaningful, with or without technical knowledge: now it’s up to you to step up, and prove you can build, while embracing the new knowledge and people who will form an integral part of your new venture.

Learning Lists

# Five Brilliant Resources to Learn Code by Doing

I’ve always been a kinetic learner. It’s something that comes naturally to me: I learn by doing, and making enough errors so that I can pick myself up and learn how to overcome in the future. It’s an attitude that lends itself to entrepreneurship.

For everybody here, here are five ways to learn code interactively—learning by doing rather than staring blankly at an endless array of pages.

## 1-Codingbat

Codingbat gives you a simple array of interactive problems so that you can apply your basic coding logic into action. It also offers a login feature so you can record your achievements. Codingbat offers nice warm-up problems that even beginners can get comfortable with to learn code, and they’re a great way to start executing code rather than just reading about it.

## 2-LearnPython.org

A godsend for me. LearnPython.org features lessons in several languages (don’t be deceived by the name, Java, Javascript, PHP, and C are included as well) where you can read what you are supposed to do, and then work to put it into motion with interactive code modules placed within the text. You can learn code by playing around with different case studies.

## 3-Python.org

The official site of the Python community not only features tons of useful documentation on the Python language and an introduction to the community, but also an interactive shell you can activate by clicking on the yellow button on the screen. Featuring PythonAnywhere, it allows you to play around with Python as you’re reading about it.

KhanAcademy is always a fun place to learn about a variety of subjects through gamification, but its coding module deserves special plaudits. It’s especially useful for children who want to have more visual feedback when they learn code, rather than the simple feel-good rush of not having any errors pop up in the module.

What is a list of coding resources without it? I learnt the foundations of my web knowledge there, and you can learn code there too. Book yourself some time at CodeAcademy: it will be time well-spent.

Learning coding shouldn’t have to be about poring over page after page of a book. One of the coolest things about building things in the digital sphere is that there is an instant feedback loop: you can literally see what you are building. These resources will ensure that you’ll be able to experience that loop while you’re learning to code.

PS: If you’re looking for curated resources on how to get into digital basics and become a UX designer, look no further than Springboard’s UX bootcamp.

[follow_me]

Learning Lists

# Five Brilliant Resources for Learning How to Code, Design, and Think

When I first founded my tech startup, I did it without any technology knowledge. I’ve now firmly realized that this was a mistake—but perhaps in many ways a benefit, as I have been forced to learn the importance of coding, and design, and how it can frame one’s mind into thinking a certain rational way that will help not only with coding websites, but with how to consider and reflect on a whole host of problems, and communicate solutions to them effectively.

Here are five great resources I used along the way to help my journey along from being a total code novice to being able to understand and communicate web technology.

1-      Bentobox.IO (full repository of links to different coding schools)

http://www.bentobox.io/

Bentobox is a comprehensive walkthrough on how to learn how to code multiple languages, and the fundamentals of the web. A great starting point to see where you should start if you don’t know anything at all about coding.

2-      Hacker News (reddit-like technology subsection focused on startup enterpreneurs)

https://news.ycombinator.com/

The virtual forum of the world-famous Y Combinator, I find it is a great resource for discussing with tech-minded individuals, and for seeing what’s going on in the technology space from people working on it every day. I guarantee that you’ll feel more at ease with technology and new ideas if you browse through it daily.

3-      Hack Design (emails sent to your inbox full of design goodness)

https://hackdesign.org/

When you think design, you might think of pretty pictures fitting together in beautiful ways, but it is so much more than that. Design is really placing yourself in the shoes of someone else and ensuring they have a great experience, instead of the experience you think they should have. Design is me saying this should help you, instead of me saying this helped me. For all of that good stuff, and pretty things falling together in pretty ways, check out Hack Design’s emails.

4-      CodeAcademy (gamified version of learning how to code)

Get a handle on how to think like a coder, and how to build some projects, all while having fun! You’ll have a blast running through CodeAcademy, and it definitely will help you understand the common logic that unites most coding languages, and to get a handle on how to go about building your first projects.

5-      JQuery’s user interface documentation (simple instructions and copy+paste on how to build in cool things into your web projects)

http://jqueryui.com/

Are you past the point where you can scurry around HTML and CSS with no pain? Wondering how to go about doing the really cool things web developers do—those datepickers, and autofill fields? Did you ace the JQuery track of CodeAcademy?

Before you go off wandering too much into Javascript land, check out the JQuery user interface. JQuery is a simplified library of code that allows you to take certain common features of a website and replicate them without knowing too much about Javascript. It takes many lines of codes in Javascript, and turns it into one word you can play around with. Playing around with it will allow you to firmly get the principles behind front-end code, and will allow you to build cool projects quickly.

——————————————————————————-

Nothing beats trying to build your projects out and marshaling whatever resources you can to get that done, once you’ve finished all this. People often have a misguided notion of how hard this can be coming from a non-technical background. I graduated in business, and I can firmly tell you that I fundamentally believe that everybody can understand the basics behind the web—and that they should attempt to do so. Good luck on your journey!

PS: If you want a more-career oriented tech bootcamp that can get you into a UX design career, look no further than Springboard’s UX bootcamp.