Tag Archives: learning

Getting Started With Meteor Tutorial (In the Cloud)

In this Meteor tutorial, I am going to show you how to quickly get started with the JavaScript Framework, Meteor, to develop a Meteor application completely from the cloud.

I’ve been pretty excited about Meteor since I first saw a demo of it, but it can be a little daunting to get started, so I thought I’d create a simple tutorial that can get you running in about 30 minutes or less.

I’ve included a YouTube video along with this blog post to help you get up-to-speed quickly.

What is Meteor?

Before we get started we should talk about exactly what Meteor is.

Meteor, or Meteor JS, is really more of a JavaScript platform than a framework. It’s built on top of Node.js and is based on the idea of creating a high-quality, reactive, web application very quickly.

Meteor is purely JavaScript. That means that the entire application is built using JavaScript. Part of it runs on Node.js on the server, and part of it runs on JavaScript in your browser.

Meteor basically provides all the plumbing for you to build a Single Page Application or SPA, without you having to wire everything up and worry about syncing data and updating templates.

What is a cloud IDE?

When I first heard of a cloud IDE, I didn’t really understand what it was–rather, I didn’t grasp how valuable a cloud IDE was. A cloud IDE will let you develop and run an application completely in the cloud with your browser.

This means that you can log into your IDE from any web browser and start developing your application.

For Meteor, this is really neat because you don’t have to install and run Meteor locally. You can utilize a Cloud IDE to run and develop a Meteor application completely on a Linux box in the cloud. You don’t even have to know much about Linux.

digital ocean   Cloud9   Google Chrome 2014 10 12 14 41 17 Getting Started With Meteor Tutorial (In the Cloud)

Now, I found that most of the Cloud IDEs out there were a bit sluggish when trying to run a Meteor application on them. I had almost given up, until I discovered that I could hook up the Cloud9 IDE with my own more powerful Linux virtual machine that is hosted at Digital Ocean.

This setup was so fast and impressive that it is completely worth setting up, so in this tutorial, that is where were are going to start.

Getting set up

The first thing you’ll need to do to get set up is to create a Digital Ocean account. Digital Ocean provides extremely cheap Linux virtual machines in the cloud. In fact, this website is hosted on a Digital Ocean machine that I pay $20 a month for (and it gets over 100k hits a month.)

Like I said before, you can just use the Cloud9 IDE by itself for running your Meteor app, but if you instead utilize a $10 / month Digital Ocean box, you’ll find everything to run about 3-to-4 times as fast–no joke.

The other alternative is to download and install Meteor on your own Linux box or Mac, but I like how easy it is to develop in the cloud–especially since you can do real-time collaboration with another developer.

If you want to use your own machine and don’t want to use a cloud IDE, just skip down to the section where we install Meteor and you can follow the same instructions, just on your own machine.

(By the way, the above link is an affiliate link–just wanted to let you know–so thanks if you sign up through it.)

Creating a Cloud9 account

Next, you’ll need to create a Cloud9 account. You can just sign up for the free account for now, but if you want more private workspaces, you’ll need to sign up for a paid account. I find the prices to be pretty reasonable though.

(By the way, the link for Cloud9 is not an affiliate link. They don’t have an affiliate program, but I still recommend them, because they are awesome–especially when hooked up to a Digital Ocean box.)

Connecting Cloud9 with Digital Ocean

The next step is to create a new Digital Ocean box that we are going to use SSH to connect to from the Cloud9 IDE. Don’t worry though, this is easier than it sounds.

Rather than repeating all the steps here, you can watch this excellent video that a Cloud9 developer put together that shows you exactly how to do it:

Installing Meteor

Now that we are all set up, we need to get Meteor installed. Fortunately, this is pretty easy. In fact, you can do it with a single command.

Just execute the following command at a terminal window:

curl https://install.meteor.com | /bin/sh

This command will pull down and execute a shell script which will install Meteor in your environment.

Yes, it really is that simple.

If you want to test out your Meteor install, execute the following command to create an example application that you can play around with:

meteor create –example leaderboard

This will create an example Meteor application called “Leaderboard.” Now, execute the following commands to switch to the Leaderboard project’s directory and start the application:

cd leaderboard

meteor

If all is well, you should see Meteor start a MongoDB instance as well as itself. You can connect to your Leaderboard app by going to the IP address of your machine and port 3000.

If you are using a Digital Ocean box, just use the same IP address you used when you set up the SSH connection to Cloud 9.

Go ahead and play around with the Leaderboard example app and take a look at the code. To really see the power of Meteor, you’ll want to open up two browser windows, each pointing at the app and see what happens when you make a change in one.

The Meteor tutorial app we are going to create

Ok, now we are ready to move on to creating our own Meteor application.

The application we are going to create is going to be a very simple TODO list application that we’ll call “Spartan TODO.”

The application will have a very simple UI and have the following basic features:

  • Show a list of items to be done
  • Add a new item to the list
  • Click an item to toggle it to and from a “done” state
  • Double click an item to delete a done item (I’ll leave this one for an exercise for you to do on your own.)

A pretty simple application, but it will take us through a pretty good cross-section of what Meteor can do. So, let’s get started.

Creating the project

The first thing we need to do is to create a new Meteor project.

In order to do that we just need to go back a directory from the Leaderboard project and create our TODO list app project. In order to do that execute the following commands:

cd ..

meteor create spartan-todo

This will create a default “Hello World” project for us in Meteor that we can modify to create our own project. Let’s go ahead and start it up with:

cd spartan-todo

meteor

Ok, so here is something pretty cool about Meteor: The whole time we are developing our application we can just leave it running. We can make changes to our application and–without having to recompile or restart the application–those changes will be applied live. We don’t even have to refresh the web browser. This is pretty cool.

Point your browser to the address of your machine and port 3000 to see the application.

Go ahead and try changing some text in the HTML to see it update live.

What’s in the Meteor tutorial project?

Before we move on, let’s take a quick moment to talk about what is in the Meteor project we created.

If you look in the spartan-todo directory, you should see 3 files:

  • spartan-todo.css – the style sheet file for our entire application
  • spartan-todo.html – the main HTML file that will be displayed
  • spartan-todo.js – the JavaScript code that will execute on both the client and the server

Meteor is pretty flexible in how you structure your project. The default app template is a very simple project structure, which we’ll stick with for this Meteor tutorial.

With this structure, you can expect the HTML file to be rendered using Meteor’s templating language, Spacebars (very similar to Handlebars.js) You can define any templates you want your application to use inside this HTML file, or you could create additional HTML files that this main HTML file references. The name of the file doesn’t matter, Meteor will just look for all the HTML files in your project and will actually create a single HTML document to be transferred to the client. But, for the purposes of this Meteor tutorial, you can ignore that. We are just going to use one HTML file.

Another important thing to point out is that by default all the JavaScript files are run on both the client and the server. So, again, it doesn’t matter what your JavaScript files are named, all the code will be executed. You can see in the spartan-todo-.js file that there is some code that says:

if(Meteor.isClient)

and

if(Meteor.isServer)

We can use those functions to have code only run in the client or the server, if we need.

There is also a folder convention we can use that controls whether code runs on the client or server or both, but for now we’ll ignore that and keep everything in these three files.

You can find the exact details on how this works in the Structuring your application section in the official Meteor documentation.

Creating the user interface

Now that we have a running Meteor tutorial application, the first thing we are going to do is create a hard-coded version of the UI that we’ll be using in our application.

I always find it is best to start by just hard-coding all the HTML for a screen in an application, before going and adding real functionality. It makes things less confusing and you don’t waste time trying to change layouts and code at the same time.

Open up your spartan-todo.html file and replace its contents with the following code:

This will create our basic user interface for our application. If you switch to your browser, it should auto-update and you should see something that looks like this:

hardcoded ui Getting Started With Meteor Tutorial (In the Cloud)  

Using templates

The next step will be to go from having a completely hard-coded HTML page to an HTML page that uses hard-coded Spacebars templates. In Meteor, we can define templates in our HTML files in order to break up and abstract away parts of our application as well as allow for our HTML to be generated based on data from our application. For now, we are going to keep things pretty simple. We are just going to break apart our HTML into a couple of templates. Replace the contents of your spartan-todo.html file with the following code:

When you go back to your browser, you shouldn’t see anything different, but now we are utilizing templates–just not very well.

Populating data with templates

The next step is to make it so the templates are actually being populated with data from our application. We are going to start off by hard-coding the data, in the application, but making it so the templates use that data to render the HTML.

Again, I like doing this baby-step approach–especially when starting out.

What we really want to do is make it so that the <li> elements we have in the HTML are not hard-coded, but are generated by some data that defines the items in our list.

We can do that in Meteor by utilizing the #each syntax in the Spacebars template.

Replace the content of your spartan-todo.html file with the following code:

What we’ve done here is replace the hard-coded list items with some templatized code that tells Meteor to loop through some collection of things called items and for each thing in that collection to write out a list item and a field from that item called “description.”

So, in order to get this template to work, we need to provide the template with a collection named “items” and the items in that collection need to have a field named “description” that has the description of the TODO list item we want.

In Meteor, the simplest way to do this is to utilize what are called template helpers. We can create a template helper in our JavaScript file that will define the data that will be returned when the template looks for “items.”

Replace your spartan-todo.js file with the following code:

This code defines a helper for the template named “list” called “items”. That “items” helper contains a function that returns a hard-coded list of items in the form of a JavaScript array. Each of the items has a description field.

When Meteor renders the template, it will utilize the helper method to fill in the data the template needs.

After you’ve made this change and saved the file, your browser should automatically reload the changes, and you should see the new TODO list items we created.

Now, the data is still hard-coded, but it is coming from the actual application itself.

Populating data with collection

We still are hard-coding data and we have no way to add new items to our TODO list, but before we can fix that problem, we need to move the data down just one more layer and introduce an important concept in Meteor called “collections.”

Remember how I said Meteor uses a MongoDB as a document database for your application? Well, that is where we ideally would like to store our TODO list items.

In order to do that, we need to define a collection in our Meteor app, which we can use to populate our MongoDB and query it later to get TODO list items back out of it.

In Meteor, by default any collections we define on the server are also available on the client. What this means is that in your browser, you can actually interact with the application’s MongoDB instance as if you were writing server code.

Meteor does this by creating a MongoDB proxy on the client side that forwards data down to the server. This MongoDB proxy is also kept in sync with the server instance by default. So, that means any data that exists on the server, can be accessed directly from the browser. (This is the default behavior, which you’ll want to eventually turn off in your application and specify manually which data to sync, but for the purposes of this Meteor tutorial, we’ll take advantage of this.)

Replace the contents of your spartan-todo.js with the following code:

There are two things we did here. First, take a look at line 1. Here we declared a new Meteor collection called items. Since this code is outside of the client and server blocks, it will be run on both the client and the server. We don’t have to write the same code twice. This code will define a MongoDB collection we can use in our application. With a document database, like MongoDB, we don’t have to declare what fields are on the collection or anything else.

Next, take a look at lines 13 through 22. What we are doing here is populating some default data if the MongoDB collection is empty. This will just give us some seed-data to work with. We could leave this code out, but if we did we wouldn’t be able to tell if everything was working.

Finally, take a look at line 6. Here, we have updated our helper function for items to cal Find() on the Items collection to get its data instead of using the hard-coded values we had before. If you switch over to your browser, you should see the TODO list with the default items we added to the collection. Now that our application is being driven by real data in a database, we can add some actual real functionality to our Meteor application.

 

Adding items

The first real bit of functionality we are going to implement will be to add new items to our list. In order to do this, we just need to add new items to our Items collection and Meteor will take care of the rest for us.

We’ll need to utilize template events to execute some code when someone clicks the add button to add a new item to our list. In Meteor, we can define events on a template, just like we can define helpers. You can really think of these as event handlers, since we’ll be writing code to handle different events that occur inside the template.

What we want to do is to define an event on the controls template that will be triggered when the form is submitting. This could happen when someone clicks add, or when they hit enter on the keyboard. In our event handling code, we’ll want to cancel the default action of submitting the form to the server, since we’ll handle everything in our client code.

Then, we’ll want to get the description of the item from our text input and insert a new item into our Items collection. Meteor will know that there is a change in our collection and will respond by rerendering the affected part of the DOM in the browser. Meteor templates are by default “reactive” in this way and constantly watch for changes that would affect the HTML they rendered.

Replace the contents of your spartan-todo.js file with the following code:

Take a look at lines 10 through 17.

What we are doing here is adding an event handler for the “submit form” event. Whenever the form is submitted on the page, this code will be executed.

In this code, we are first canceling the default action, which is to post the form to the server.

Them, we use some JQuery to grab the value of the newItem text input and store it in a variable.

Finally, we insert a new object into the Items collection with the proper description.

After you save this code, you can go ahead and try it out. Add a few items to the list. You can also try opening a second browser and watching how the data is synced between both clients.

Marking items done

The last step we want to do in this Meteor tutorial is to make it so that we can mark items as done by clicking on them and unmark them by clicking a second time.

Again, we will need to use events to do this.

The basic idea will be to create an event handler that will respond to a list item being clicked in the list template that will toggle a “done” field on the item to indicate whether or not the item should be marked as done.

We’ll use a CSS class that will apply a line-through to the list items marked as done.

Let’s start with the CSS class. Just add the following line to your spartan-todo.css file:

.done {
text-decoration: line-through;
}

Next, replace the contents of your spartan-todo.js file with:

Let’s start by looking at lines 25 through 30.

What we’ve done here is created a new event handler for the list template that will trigger when a list item is clicked. This event handler will simply update the item in the Items collection by setting a “done” field on it to the opposite of what it was. This will result in the done field being set to true the first time it is clicked and from then on toggle between the two values.

How do specify which item we want to update?

Every object in our collection automatically gets a special field named “_id.” We can use this field to uniquely identify each item. But, how do we get a reference to the item?

You may have noticed the “this” keyword being used in this code. Whenever we are executing event handling code in a template, the this variable always points to the data that triggered the event. We automatically get the correct context, so when we refer to “this._id,” we get the ID of the object that represents the list item that was clicked on.

Notice also the special syntax we have to use to update an item and set a new field value in MongoDB. It might seem a little bit strange, but that is how it is done in MongoDB.

Next, take a look at lines 8 through 13.

Here we are defining a helper function called “doneClass” that will either return the string “done” or an empty string, depending on whether or not the item being evaluated when this helper is invoked in the template.

We can use this code to make it so the list template can assign our “done” class only to items that are marked as done.

In order to do this, simply replace line 15 in your spartan-todo.html file with the following code:

<li class=”{{doneClass}}”>{{description}}</li>

Save everything and open your browser and you’ll find that you can now click on items to mark them as done and click on them again to mark them as undone.

The template calls our helper function “doneClass” to determine what text to insert into our class statement on each li element.

Deleting items

Ok, now it’s your job to implement deleting items in our Meteor application.

I’ll give you a bit of a hint. You can utilize the “dblclick li” event to make it so that whenever someone double clicks a list item it is deleted. See if you can figure out how to implement that functionality in the Meteor app.

Meteor tutorial wrap up

So, there you have it: a very simple TODO list application in Meteor. I’ve actually created a screencast you can watch to follow along, if you’d like. You can find it below:

If you happen to be in the Copenhagen area or are planning on attending the At the Frontend conference on Nov 4th 2014, I’ll be there doing a “Getting Started With Meteor” session where I’ll be creating this TODO list application and going over a little more about Meteor.

If you found this tutorial helpful, please share it with anyone who you think might be interested.

Also, join over 5,000 other developers who are part of the Simple Programmer community by signing up here. You’ll get weekly emails with career tips, tutorials and other practical advice for software developers and special discounts on Simple Programmer products.

Some additional resources

Also, if you are looking to dive a little deeper into Meteor, I’d recommend starting out with this excellent book that you can get for just 99 cents, “Your First Meteor Application: A Complete Beginner’s Guide to the Meteor JavaScript Framework.”

And, I have created a Pluralsight course called “Meteor.js Fundamentals for Single Page Applications” that covers Meteor much more in-depth.

Step By Step Path to Becoming a Great Software Developer

I get quite a few emails that basically say “how do I become a good / great software developer?”

These kinds of emails generally tick me off, because I feel like when you ask this kind of question, you are looking for some magical potion you can take that will suddenly make you into a super developer.

I suspect that very few people who email me asking this question really want to know how to become a great software developer, but are instead looking for a quick fix or an easy answer.

On the other hand, I think there are some genuinely sincere developers that just don’t even know how to formulate the right questions they need to ask to get to their desired future. I think those developers–especially the ones starting out–are looking for a step-by-step guide to becoming a great developer.

super hero Step By Step Path to Becoming a Great Software Developer

I thought I would make an attempt, from my experience and the best of my knowledge, to offer up that step-by-step guide.

Now, of course, I realize that there is no magical formula and that there are multiple paths to success, but I think what follows is a reasonable outline of steps someone starting out could take to reach a pretty high level of proficiency and be generally regarded as a good–perhaps even great–developer.

Step 1: Pick one language, learn the basics

Before we can run, we have to learn to walk. You walk by learning how to program in a single programming language. You don’t learn to walk by trying to learn 50 million things all at once and spreading yourself way too thin.

Too many beginning programmers try and jump into everything all at once and don’t have the patience to learn a single programming language before moving forward. They think that they have to know all the hot new technologies in order to get a programming job. While it is true that you need to know more than just the basics of a single programming language, you have to start here, so you might as well focus.

Pick a single programming language that you think you would be likely to base your career around. The programming language itself doesn’t matter all that much, since you should be thinking for the long term here. What I mean is you shouldn’t try and learn an “easy” programming language to start. Just learn whatever language you are interested in and could see yourself programming in for the next few years. You want to pick something that will have some lasting value.

Once you’ve picked the programming language you are going to try and learn, try and find some books or tutorials that isolate that programming language. What I mean by this is that you don’t want to find learning materials that will teach you too much all at once. You want to find beginner materials that focus on just the language, not a full technology stack.

As you read through the material or go through the tutorial you have picked out, make sure you actually write code. Do exercises if you can. Try out what you learned. Try to put things together and use every concept you learn about. Yes, this is a pain. Yes, it is easier to read a book cover-to-cover, but if you really want to learn you need to do.

When you are writing code, try to make sure you understand what every line of code you write does. The same goes for any code you read. If you are exposed to code, slow down and make sure you understand it. Whatever you don’t understand, look up. Take the time to do this and you will not feel lost and confused all the time.

Finally, expect to go through a book or tutorial three times before it clicks. You will not get “programming” on the first try–no one ever does. You need repeated exposure before you start to finally get it and can understand what is going on. Until then you will feel pretty lost, that is ok, it is part of the process. Just accept it and forge ahead.

Step 2: Build something small

Now that you have a basic understanding of a single programming language, it’s time to put that understanding to work and find out where your gaps are. The best way to do this is to try and build something.

Don’t get too ambitious at this point–but also don’t be too timid. Pick an idea for an application that is simple enough that you can do it with some effort, but nothing that will take months to complete. Try to confine it to just the programming language as much as possible. Don’t try to do something full stack (meaning, using all the technologies from user interfaces all the way to databases)–although you’ll probably need to utilize some kind of existing framework or APIs.

For your first real project you might want to consider copying something simple that already exists. Look for a simple application, like a To-Do list app and straight out try to copy it. Don’t let your design skills stand in the way of learning to code.

scribbles Step By Step Path to Becoming a Great Software Developer

I’d recommend creating a mobile application of some kind, since most mobile applications are small and pretty simple. Plus, learning mobile development skills is very useful as more and more companies are starting to need mobile applications. Today, you can build a mobile application in just about any language. There are many solutions that let you build an app for the different mobile OSes using a wide variety of programming languages.

You could also build a small web application, but just try to not get too deep into a complex web development stack. I generally recommend starting with a mobile app, because web development has a higher cost to entry. To develop a web application you’ll need to at least know some HTML, probably some back-end framework and JavaScript.

Regardless of what you choose to build, you are probably going to have to learn a little bit about some framework–this is good, just don’t get too bogged down into the details. For example, you can write a pretty simple Android application without having to really know a lot about all of the Android APIs and how Android works, just by following some simple tutorials. Just don’t waste too much time trying to learn everything about a framework. Learn what you need to know to get your project done. You can learn the details later.

Oh, and this is supposed to be difficult. That is how you learn. You struggle to figure out how to do something, then you find the answer. Don’t skip this step. You’ll never reach a point as a software developer where you don’t have to learn things on the spot and figure things out as you go along. This is good training for your future.

Step 3: Learn a framework

Now it’s time to actually focus on a framework. By now you should have a decent grasp of at least one programming language and have some experience working with a framework for mobile or web applications.

Pick a single framework to learn that will allow you to be productive in some environment. What kind of framework you choose to learn will be based on what kind of developer you want to become. If you want to be a web developer, you’ll want to learn a web development framework for whatever programming language you are programming in. If you want to become a mobile developer, you’ll need to learn a mobile os and the framework that goes with it.

Try to go deep with your knowledge of the framework. This will take time, but invest the time to learn whatever framework you are using well. Don’t try to learn multiple frameworks right now–it will only split your focus. Think about learning the skills you need for a very specific job that you will get that will use that framework and the programming language you are learning. You can always expand your skills later.

Step 4: Learn a database technology

Most software developers will need to know some database technology as most series applications have a back-end database. So, make sure you do not neglect investing in this area.

You will probably see the biggest benefit if you learn SQL–even if you plan on working with NoSQL database like MongoDB or Raven, learning SQL will give you a better base to work from. There are many more jobs out there that require knowledge of SQL than NoSQL.

Don’t worry so much about the flavor of SQL. The different SQL technologies are similar enough that you shouldn’t have a problem switching between them if you know the basics of one SQL technology. Just make sure you learn the basics about tables, queries, and other common database operations.

I’d recommend getting a good book on the SQL technology of your choice and creating a few small sample projects, so you can practice what you are learning–always practice what you are learning.

You have sufficient knowledge of SQL when you can:

  • Create tables
  • Perform basics queries
  • Join tables together to get data
  • Understand the basics of how indexes work
  • Insert, update and delete data

In addition, you will want to learn some kind of object relational mapping technology (ORM). Which one you learn will depend on what technology stack you are working with. Look for ORM technologies that fit the framework you have learned. There might be a few options, so you best bet is to try to pick the most popular one.

Step 5: Get a job supporting an existing system

Ok, now you have enough skills and knowledge to get a basic job as a software developer. If you could show me that you understand the basics of a programming language, can work with a framework, understand databases and have built your own application, I would certainly want to hire you–as would many employers.

maintainance Step By Step Path to Becoming a Great Software Developer

The key here is not too aim to high and to be very specific. Don’t try and get your dream job right now–you aren’t qualified. Instead, try and get a job maintaining an existing code base that is built using the programming language and framework you have been learning.

You might not be able to find an exact match, but the more specific you can be the better. Try to apply for jobs that are exactly matched to the technologies you have been learning.

Even without much experience, if you match the skill-set exactly and you are willing to be a maintenance programmer, you should be able to find a job.

Yes, this kind of job might be a bit boring. It’s not nearly as exciting as creating something new, but the purpose of this job is not to have fun or to make money, it is to learn and gain experience.

Working on an existing application, with a team of developers, will help you to expand your skills and see how large software systems are structured. You might be fixing bugs and adding small features, but you’ll be learning and putting your skills into action.

Pour your heart into this job. Learn everything you can. Do the best work possible. Don’t think about money, raises and playing political games–all that comes later–for now, just focus on getting as much meaningful productive work done as possible and expanding your skills.

Step 6: Learn structural best practices

Now it’s time to start becoming better at writing code. Don’t worry too much about design at this point. You need to learn how to write good clean code that is easy to understand and maintain. In order to do this, you’ll need to read a lot and see many examples of good code.

Beef up your library with the following books:

Language specific structural books like:

At this point you really want to focus your learning on the structural process of writing good code and working with existing systems. You should strive to be able to easily implement an algorithm in your programming language of choice and to do it in a way that is easy to read and understand.

Step 7: Learn a second language

At this point you will likely grow the most by learning a second programming language really well. You will no doubt, at this point, have been exposed to more than one programming language, but now you will want to focus on a new language–ideally one that is significantly different than the one you know.

This might seem like an odd thing to do, but let me explain why this is so important. When you know only one programming language very well, it is difficult to understand what concepts in software development are unique to your programming language and which ones transcend a particular language or technology. If you spend time in a new language and programming environment, you’ll begin to see things in a new way. You’ll start to learn practicality rather than convention.

As a new programmer, you are very likely to do things in a particular way without knowing why you are doing them that way. Once you have a second language and technology stack under your belt, you’ll start to see more of the why. Trust me, you’ll grow if you do this. Especially if you pick a language you hate.

Make sure you build something with this new language. Doesn’t have to be anything large, but something of enough complexity to force you to scratch your head and perhaps bang it against the wall–gently.

Step 8: Build something substantial

Alright, now comes the true test to prove your software development abilities. Can you actually build something substantial on your own?

If you are going to move on and have the confidence to get a job building, and perhaps even designing something for an employer, you need to know you can do it. There is no better way to know it than to do it.

Pick a project that will use the full stack of your skills. Make sure you incorporate database, framework and everything else you need to build a complete application. This project should be something that will take you more than a week and require some serious thinking and design. Try to make it something you can charge money for so that you take it seriously and have some incentive to keep working on it.

Just make sure you don’t drag it out. You still don’t want to get too ambitious here. Pick a project that will challenge you, but not one that will never be completed. This is a major turning point in your career. If you have the follow-through to finish this project, you’ll go far, if you don’t… well, I can’t make any promises.

Step 9: Get a job creating a new system

Ok, now it’s time to go job hunting again. By this point, you should have pretty much maxed out the benefit you can get from your current job–especially if it still involves only doing maintenance.

new Step By Step Path to Becoming a Great Software Developer

It’s time to look for a job that will challenge you–but not too much. You still have a lot to learn, so you don’t want to get in too far over your head. Ideally, you want to find a job where you’ll get the opportunity to work on a team building something new.

You might not be the architect of the application, but being involved in the creation of an application will help you expand your skills and challenge you in different ways than just maintaining an existing code base.

You should already have some confidence with creating a new system, since you’ll have just finished creating a substantial system yourself, so you can walk into interviews without being too nervous and with the belief you can do the job. This confidence will make it much more likely that you’ll get whatever job you apply for.

Make sure you make your job search focused again. Highlight a specific set of skills that you have acquired. Don’t try to impress everyone with a long list of irrelevant skills. Focus on the most important skills and look for jobs that exactly match them–or at least match them as closely as possible.

Step 10: Learn design best practices

Now it’s time to go from junior developer to senior developer. Junior developers maintain systems, senior developers build and design them. (This is a generalization, obviously. Some senior developers maintain systems.)

You should be ready to build systems by now, but now you need to learn how to design them.

You should focus your studies on design best practices and some advanced topics like:

  • Design patterns
  • Inversion of Control (IOC)
  • Test Driven Development (TDD)
  • Behavior Driven Development (BDD)
  • Software development methodologies like: Agile, SCRUM, etc
  • Message buses and integration patterns

This list could go on for quite some time–you’ll never be done learning and improving your skills in these areas. Just make sure you start with the most important things first–which will be highly dependent on what interests you and where you would like to take your career.

Your goal here is to be able to not just build a system that someone else has designed, but to form your own opinions about how software should be designed and what kinds of architectures make sense for what kinds of problems.

Step 11: Keep going

At this point you’ve made it–well, you’ll never really “make it,” but you should be a pretty good software developer–maybe even “great.” Just don’t let it go to your head, you’ll always have something to learn.

How long did it take you to get here? I have no idea. It was probably at least a few years, but it might have been 10 or more–it just depends on how dedicated you were and what opportunities presented themselves to you.

A good shortcut is to try and always surround yourself with developers better than you are.

What to do along the way

There are a few things that you should be doing along the way as you are following this 10 step process. It would be difficult to list them in every step, so I’ll list them all briefly here:

Teach – The whole time you are learning things, you should be teaching them as well. It doesn’t matter if you are a beginner or expert, you have something valuable to teach and besides, teaching is one of the best ways to learn. Document your process and journey, help others along the way.

Market yourself – I think this is so important that I built an entire course around the idea. Learn how to market yourself and continually do it throughout your career. Figure out how to create a personal brand for yourself and build a reputation for yourself in the industry and you’ll never be at want for a job. You’ll get decide your own future if you learn to market yourself. It takes some work, but it is well worth it. You are reading this post from my effort to do it.

Read – Never stop learning. Never stop reading. Always be working your way through a book. Always be improving yourself. Your learning journey is never done. You can’t ever know it all. If you constantly learn during your career, you’ll constantly surpass your peers.

Do – Every stop along the way, don’t just learn, but do. Put everything you are learning into action. Set aside time to practice your skills and to write code and build things. You can read all the books on golfing that you want, but you’ll never be Tiger Woods if you don’t swing a golf club.

Want more?

Sign up here to become a Simple Programmer. It’s free and over 4,500 other developers have shown their support for making the complex simple.

 

 

 

Don’t Overwhelm Yourself Trying to Learn Too Much

It’s a great idea to educate yourself.

I fully subscribe to the idea of lifetime learning–and you should too.

But, in the software development field, sometimes there are so many new technologies, so many things to learn, that we can start to feel overwhelmed and like all we ever do is learn.

overwhelmed Dont Overwhelm Yourself Trying to Learn Too Much

You can start to feel like you are always playing catch-up, but never actually getting ahead–not even keeping up. The treadmill is going just a few paces faster than you can run, and you are slowly losing ground, threatening to drop off the end at any time.

Trying to learn too much

The problem is trying to learn too much. There are 100 different technologies you have to work with or want to work with at your job. You might feel that in order to be competent, in order to be the best you can be, you need to learn and master all of them. The problem though, is that you feel like you haven’t even mastered one of them.

It can be a pretty disparaging feeling. To counter that feeling–which sometimes demonstrates itself as impostor syndrome–you grab books, video courses, and all kinds of resources on all the technologies you feel that you need to master.

You spend your nights and weekends reading books, going through online training, and reading blog posts.

But. is it really effective, or does it just stress you out more?

Do you even remember half of what you read?

Will you actually ever use it, or are you storing it away for a someday-I-might-need-this-bucket?

bucket Dont Overwhelm Yourself Trying to Learn Too Much

My point isn’t that you shouldn’t be learning, it’s just that perhaps you are placing too much pressure on yourself and trying to learn too much.

I’m only saying this, because I’ve been there. I’ve done that. I know how it feels.

I also know that this forced pace of learning isn’t very effective. I don’t remember much of the majority of books I read about technologies I didn’t end up using or barely ended up working with.

I know that the technologies I learned the best were the technologies that I actually put into practice. In fact, some of my most useful, and retained learning, came from learning I did on the spot, right when I was working on a problem I couldn’t solve and had to go find an answer.

Just-in-time learning

It may seem strange that someone like me who makes a decent portion of their living creating learning materials for software developers would tell you to not try and learn too much.

It probably would make much more sense for me to preach that you should absorb all the information that you can; that you should be continuously watching my Pluralsight courses while you eat, sleep and commute to work.

But, the truth is, I don’t think that is the most effective way to learn. I don’t think you’ll get much out of one of my courses, or anyone else’s, if you just repeatedly watch them.

Instead, I think the best way to improve your skills and to learn what you need to do is to do the learning as close to the time you need the information as possible–just-in-time learning.

Now, this doesn’t mean that you should just start working with a technology before you know anything about it. You’ll waste a lot of time flopping around trying to get started if you just dive right in without any prior knowledge. But, I’ve found you only need to learn three things before you can dive in and start working with a technology:

  1. How to get started
  2. What you can do with the technology–how big it is.
  3. The basics–the most common things you’ll do 90% of the time.

It is no coincidence that I structure most of my online courses in that way. I try to tell you how to get started, show you what is possible and then give you the very basics. I try to avoid going into details about every little aspect of a technology, because you are better off learning that information when you need it. As long as you know what you can do, you can always find out how later.

Often the hardest part of learning a new technology is learning what is possible.

I’ve found that the faster you start actually using a technology and trying to solve real problems with it the better. Once you’ve covered the three bases I’ve mentioned above, your time is much better spent actually working with the technology rather than learning about it further.

It’s difficult to break away and jump in though. Our instincts tell us that we need to keep reading, keep watching videos and continue to learn, before we get started.

You might feel compelled to master a technology before you start using it, but you have to learn to resist the urge. You have to be willing to fail and learn your way by making mistakes and hitting roadblocks. Real learning takes place when you use information for a purpose, not by trying to acquire it ahead of time.

If you know what can be done in a technology and you know enough of the basics, it won’t be difficult to figure out what search term you’ll need to come up with in order to answer any questions you have along the way. This just-in-time learning will be more effective in the long run and save you many wasted hours consuming information that you won’t fully digest.

You can’t know everything

Even if you had all the time in the world to learn, and even if you apply just-in-time learning techniques, you still won’t ever learn a fraction of what there is to learn in the software development field. New technologies are popping up every day and the depth of existing ones increases at an alarming rate.

It is important to face the reality that you just can’t know it all. Not only can you not know it all, but what you can know is just a tiny fraction of what there is to know.

This is one of the main reasons why I talk about specializing so much. You are much better off picking a single technology that you can focus on learning in-depth than spreading yourself too thin trying to be a master at everything.

That doesn’t mean you shouldn’t expand your skills in many different directions; you should definitely try to have a broad base. Just don’t expect to be an expert in more than one or two main areas of focus. Try to focus your learning on two main areas:

  1. A single specialty that you will master
  2. General software development skills that will apply to more than one technology. (For example, a book like Code Complete falls in this category.)

Don’t try and spread yourself too thin. Rely on your ability to learn things as you need them. If you have a solid base, with time and experience, you’ll find that you can learn whatever you need to know when you need to know it. Trust yourself.

Sometimes it can seem like there are super-programmers out there who seem to know everything and can do everything, but it is only an illusion. Those super-programmers are usually programmers that have one or two areas of expertise and a large amount of general knowledge that they apply to a variety of different domains.

Like this post? Get more like it and other exclusive content when you sign up here.

 

You Never Really Learn Something Until You Teach It

As software developers we spend a large amount of time learning. There is always a new framework or technology to learn. It can seem impossible to keep up with everything when there is something new every day. So, it should be no surprise to you that learning quickly and gaining a deeper understanding of what you learn is very important.

And that is exactly why–if you are not doing so already–you need to incorporate teaching into your learning.

Why teaching is such an effective learning tool

When we learn something, most of us learn it in bits and pieces. Typically, if you read a book, you’ll find the material in that book organized in a sensible way. The same goes for others mediums like video or online courses. But, unfortunately, the material doesn’t go into your head in the same way.

teaching You Never Really Learn Something Until You Teach It

What happens instead is that you absorb information in jumbled bits and pieces. You learn something, but don’t completely “get it” until you learn something else later on. The earlier topic becomes more clear, but the way that data is structured in your mind is not very well organized–regardless of how organized the source of that information was.

Even now, as I write this blog post, I am struggling with taking the jumbled mess of information I have in my head about how teaching helps you learn and figuring out how to present it in an organized way. I know what I want to say, but I don’t yet know how to say it. Only the process of putting my thoughts on paper will force me to reorganize them; to sort them out and make sense of them.

When you try to teach something to someone else, you have to go through this process in your own mind. You have to take that mess of data, sort it out, repackage it and organize it in a way that someone else can understand. This process forces you to reorganize the way that data is stored in your own head.

Also, as part of this process, you’ll inevitably find gaps in your own understanding of whatever subject you are trying to teach. When we learn something we have a tendency to gloss over many things we think we understand. You might be able to solve a math problem in a mechanical way, and the steps you use to solve the math problem might be sufficient for what you are trying to do, but just knowing how to solve a problem doesn’t mean you understand how to solve a problem. Knowledge is temporary. It is easily lost. Understanding is much more permanent. It is rare that we forget something we understand thoroughly.

When we are trying to explain something to someone else, we are forced to ask ourselves the most important question in leaning… in gaining true understanding… “why.” When we have to answer the question “why,” superficial understanding won’t do. We have to know something deeply in order to not just say how, but why.

That means we have to explore a subject deeply ourselves. Sometimes this involves just sitting and thinking about it clearly before you try to explain it to someone else. Sometimes just the act of writing, speaking or drawing something causes you to make connections you didn’t make before, instantly deepening your knowledge. (Ever had one of those moments when you explained something to someone else and you suddenly realized that before you tried to explain it you didn’t really understand it yourself, but now you magically do?) And, sometimes, you have to go back to the drawing board and do more research to fill in those gaps in your own knowledge you just uncovered when you tried to explain it to someone else.

Becoming a teacher

So, you perhaps you agree with me so far, but you’ve got one problem–you’re not a teacher. Well, I have good news for you. We are all teachers. Teaching doesn’t have to be some formal thing where you have books and a classroom. Teaching is simply repackaging information in a way that someone else can understand. The most effective teaching takes place when you can explain something to someone in terms of something else they already understand.

 

(Want a great book on the subject that might make your brain hurt? Surfaces and Essences: Analogy as the Fuel and Fire of Thinking. An excellent book by Douglas Hofstadter, author of Godel, Escher, Bach: An Eternal Golden Braid. Both books are extremely difficult reads, but very rewarding.)

becoming a teacher You Never Really Learn Something Until You Teach It

As human beings, we do this all the time. Whenever we communicate with someone else and tell them about something we learned or explain how to do something, we are teaching. Of course, the more you do it, the better you get at it, and adding a little more formalization to your practice doesn’t hurt, but at heart, you–yes, you–are a teacher.

One of the best ways to start teaching–that may even benefit your career–is to start a blog. Many developers I talk to assume that they have to already be experts at something in order to blog about it. The truth is, you only have to be one step ahead of someone for them to learn from you. So, don’t be afraid to blog about what you are learning as you are learning it. There will always be someone out there who could benefit from your knowledge–even if you consider yourself a beginner.

And don’t worry about blogging for someone else–at least not at first. Just blog for yourself. The act of taking your thoughts and putting them into words will gain you the benefits of increasing your own understanding and reorganizing thoughts in your mind.

I won’t pretend the process isn’t painful. When you first start writing, it doesn’t usually come easily. But, don’t worry too much about quality. Worry about communicating your ideas. With time, you’ll eventually get better and you’ll find the process of converting the ideas in your head to words becomes easier and easier.

Of course, creating a blog isn’t the only way to start teaching. You can simply have a conversation with a friend, a coworker, or even your spouse about what you are learning. Just make sure you express what you are learning externally in one form or another if you really want to gain a deep understanding of the subject.

You can also record videos or screencasts, speak on a subject or even give a presentation at work. Whatever you do, make sure that teaching is part of your learning process.

For more posts like this and some content I only deliver via email, sign up here.

 

 

Why You Aren’t Paid as Much as You Are Worth (and how to get paid more)

Software developers usually make pretty decent salaries, but did you know that companies that hire software developers usually make much more money off of a single software developer than they pay that software developer?

I guess, if you think about it, it is common sense. Why hire programmers if those programmers don’t make more money for your company than the salary you are paying them?

But sometimes this disparity between what a software developer actually makes and the value that software developer brings to the table is large—sometimes it’s really large.

In fact, if you are being paid an hourly rate as a contractor, you are probably making about half of what the client is being billed for, if even that.

bowl Why You Arent Paid as Much as You Are Worth (and how to get paid more)

Being a commodity

One of the big problems many software developers face is that they can be easily treated as a commodity.

This problem is becoming more and more prevalent as basic programming skills become easier to come by and more and more people are becoming programmers all over the world.

If you go onto oDesk or ELance today, you can find software developers willing to write code for less than $10 an hour; you can find really good software developers writing code for $25 an hour.

If you are letting yourself be treated like a commodity and the price of that commodity is dropping, you are in big trouble.

Forget about job security at a single job. You’ve got to worry about your entire career and all the investment you put into your skills.

If you want a long and prosperous future doing what you love to do, you’ve got to be able to justify why someone should hire you and keep paying you at your current rate instead of hiring someone at $10 an hour to do the same work.

What makes something a commodity?

In order to solve this problem, you’ve got to examine what exactly it is that makes something a commodity.

But, before we go any further, let’s take a moment to make sure we are on the same page about what a commodity is.

I like this definition from the Wikipedia entry on Commodity:

“The exact definition of the term commodity is specifically applied to goods . It is used to describe a class of goods for which there is demand, but which is supplied without qualitative differentiation across a market.”

commodities Why You Arent Paid as Much as You Are Worth (and how to get paid more)

The key thing here is “without qualitative differentiation across a market.”

This means that if the service or product you provide isn’t much different than what everyone else is selling, it can be considered a commodity. And, as such, the price will be determined by the market, not by the actual value you provide.

So, even though you may be providing your employer with $500,000 worth of value per year by writing code, your employer can turn around and pay you whatever the market says a software developer with your years of experience and skill level is worth.

That is unless…

You find a way to be something more than a commodity

That is the key to being paid what you are actually worth instead of what the commodity market for software developers says you are worth.

But, it isn’t easy to stand out. It isn’t easy to be perceived as something more than a commodity if you don’t know how to do it.

I want to show you an example of how some people break out of commodity markets and differentiate themselves to make more money.

Have you ever heard of a voice-over?

voice actor Why You Arent Paid as Much as You Are Worth (and how to get paid more)

A voice over is when you have someone who has good oratory skills or a particular accent, or sounds create a recording for something like an advertisement or a cartoon character’s voice in a cartoon.

There is quite a big market for people who do voice overs. Just about every radio ad, podcast advertisement, and animated film or show needs voice over talent to create voice overs.

But, did you know it is a commodity market?

That’s right; I can actually go onto Fiverr.com and pick from a multitude of skilled voice over actors to do a voice over for me for $5. Not only can I do it—I have done it. I’ve hired two different voice over actors to do voice overs for my podcast for just $5.

But, believe it or not, some voice over actors get paid millions of dollars each year to do basically the same work.

So, what separates the voice over actors who get paid millions from the ones who get paid five bucks?

I’ll give you a hint—and it’s not talent—it’s marketing.

Those voice over actors that are making the big bucks have figured out how to market themselves to land the right gigs, which increases the value of their name and gets them more and higher paying gigs.

If you don’t believe me, go on Fiverr.com yourself and check out the talent level of some of the top people on there that are doing voice overs for just five dollars—you will be impressed.

No one tells software developers how to market themselves

In the entertainment industry self-promotion and marketing is the name of the game.

There are whole companies that do nothing but market talent. I mean, actors have agents, so do musicians, and yes, even people who do voice overs have agents… at least the successful ones do.

But, when it comes to software development, you are not very likely to find the same kind of resources of knowledge about self-promotion and advertising that envelope the entertainment world.

Have you ever heard of a software developer having an agent?

Well, even though it sounds silly, you’ve got to be your own agent if you want to rise above the crowd and stand out. If you want a chance at making the big bucks and setting your own price, you’ve got to figure out how to market yourself.

There are plenty of software developers that are already doing it. You’ve heard them on popular podcasts and read articles written by them in trade magazines or heard them speak at conferences.

But, no one ever talks about how they achieve their success… at least not until now.

Over the past few years, I’ve been talking to developers who have broken away from the herd. I’ve studied their careers and asked them about how they’ve achieved their success. I’ve been able to duplicate their results to a large degree myself, and since no one else is doing it, I want to share that information with you now.

Check out this package I am putting together called “How To Market Yourself As A Software Developer.” I’m going to be launching this this package, on March 27th.

Sign up here to get a $100 discount directly in your email on launch day.

combo image 52 Why You Arent Paid as Much as You Are Worth (and how to get paid more)

Well, I hope this article has been helpful to you and helped you realized that you’ve got to make a fundamental shift in your thinking if you want to be able to really advance your career and not be treated like a commodity.

How To Get a Jump Start In Your Programming Career

Getting started in the field of software development is difficult.

No doubt, if you are just starting out as a programmer, you have already experienced how difficult it can be to get a job without having much or any experience.

If you’ve been a software developer for any amount of time, you’ve probably experienced how difficult it can be to rise up the ranks in this highly competitive industry.

I’ve talked to many developers just starting out who are frustrated because they don’t know where they should be devoting their energies to best advance their careers and secure their futures.

There are so many options.  So many technologies you could learn.  So many paths you could take.  Which is the right one?

Thinking the right way from the start

I’ll give some concrete advice in a little bit, but before any of that advice is useful, it is important to make sure you are thinking about your career in the right way.

thinking thumb How To Get a Jump Start In Your Programming Career

It is really important to think about your career as a business.  A business you own which employs you.  Thinking this way will help you make the right objective decisions about what you should be doing with your time and how and when you should invest money in your career.

Too many software developers think about their career in terms of their current job or the job they seek to obtain—that kind of thinking is short sighted.

Have you ever noticed how it is easier to advise someone else on a decision than to make that same decision for yourself?  The reason is because when you advise someone else, you are able to be objective and not let fear and other emotions influence your advice.

By thinking of yourself as a business, you’ll be able to create that same kind of separation and objectiveness which will lead you to better decisions.

Actually start a business

In fact, why not go the extra step and start a business right from the start?

It is difficult to get experience without having experience.  Most software development jobs require you to already have experience.

So, how do new software developers or developers with limited experience actually get experience?

Often, you get a lucky break and perhaps you come into an organization in a QA position or other role and eventually work your way up to developer.

That is the long way.

Here is the short way.

Just start your own business from the get go and employ yourself.  It isn’t hard to start a business.  You don’t even have to file any paperwork to start out.  You can just do business as yourself in most places.

But what about work?  I need to actually make some money.

Ah, but the point of this starting out business is not to actually make money, but to gain you experience.  You can keep your current job and you can run this business on the side.  You just need some projects to work on so that you can put some real experience on your resume.

It is pretty unlikely that a prospective employer is going to ask how much money your business made last year, (even if they do, you don’t have to tell them.)  So, don’t worry about making money.  If you are able to get some paid jobs, great, but there is no reason you can’t do jobs for clients for free in order to gain experience.

Create a website for a friend or family member’s business.  Talk to local businesses and ask them if they’d like you to develop an application for them for free or very low cost.  It doesn’t matter where you get the business from, the point is to get something on your resume that is real work you did—then it isn’t lying.  You don’t want to lie on your resume.

Develop some mobile applications

Here is another great thing that your business can do that will not only get you some experience to put on your resume, but will also possibly generate you some extra income and give you something to show at a job interview.

I often recommend that developers just starting out build mobile applications, because mobile applications can be built by a single person and are a great way not only to learn how to build an application from end to end, but to create solid proof of your ability to write code.

One of the biggest fears that companies have when hiring developers is whether or not that developer can actually produce anything.  You can completely alleviate that fear if you can show the source code for an application you created yourself, and if you have it in a mobile app store and people are actually using it, even better.

mobile app thumb How To Get a Jump Start In Your Programming Career

If you are looking to find out where to get started with mobile application development, I have two Pluralsight courses on the subject: Introduction to Android and Beginning iOS 7 Development.  You can check those out or find a good book on the subject.

Here are a couple I’d recommend:

Besides gaining experience to put on a resume, building your own mobile application will help give you confidence in your ability to create real working code and it will help you to develop well rounded skills in software development.

Sure, it may be a bit difficult to get started and there is a decent amount to learn about mobile development, but it is a good investment regardless, because mobile devices aren’t going away anytime soon and the demand for developers that can develop for mobile platforms is only likely to increase over time.

Plan your career

I talk about the idea of marketing yourself as a software developer quite often, because it is something I truly believe can help software developers to get better jobs and earn higher incomes.

Much of this advice comes down to actually planning out your career rather than just looking for the next job.

You want to set yourself up early on in a position where you are building a brand and reputation for yourself that will benefit you later in your career.

A great way to do this is to create your own blog.  Don’t wait to do this until later on.  I wish I would have started this blog 5 years or more earlier in my career.  Every developer with a successful blog that I have talked to has said the same thing.

Don’t just create the blog, use it.  Strive to write an article each week.  Even if you don’t have anything interesting to say, do it.  After a few years, you’ll be a better writer, have a nice history of your thoughts and be all the better off for it.

I’m not going to go into all the details of marketing yourself in this post, but if you are interested, I do have a course that covers everything you need to know about marketing yourself as a software developer.

The key point here is to plan your career and think for the long term.  Create a blog, establish a brand, do other things that will benefit you years down the road, but start doing them now.

Find the right friends (mentors)

Having the right friends to ask advice from or to council you can save you a large amount of time and help put you on the right path.friends thumb1 How To Get a Jump Start In Your Programming Career

I’d advise you to make friends with experienced software developers and utilize the wisdom they can impart on you.

It can be difficult to make friends if you come off as needy.  It is unlikely that if you ask someone to be your mentor, they will accept.  Being someone’s mentor doesn’t really offer much to the person doing the mentoring.

The key is to have something to offer in return so that you are providing value as well.

Here are a few ideas to make some friends in the industry:

  • Offer to buy lunch.  This is a good opportunity to have a conversation with someone who you otherwise might not be able to.  Who doesn’t like a free lunch?
  • Start commenting on software developer’s blogs that you admire.  You’ll eventually gain their attention if you provide useful, insightful comments.
  • Find something to trade.  Do you have some knowledge in some other area that someone might be interested in?  Can you trade your knowledge of fitness or diet in exchange for information about software development?  The best relationships offer value to both parties.
  • Go to user groups.  There are many user groups all over the world that you can become a part of.  If you are a regular, you will meet other regulars and build good friendships.

Read the right books

One of the best ways to really get ahead of the curve is to read the right books.  Reading the right software development books can help you to understand concepts that take years to discover on your own and give you the benefits of the collective experience of many successful software developers.

Here is my personal list of books that I’d recommend all software developers start out with.

Code Complete – A classic book about the structure of code.  This will make you a much better programmer and help you write clear code.

Clean Code – A great book by Bob Martin that really distills down some key concepts about writing good code.  A must read book.

Design Patterns – Read through this book several times and learn these patterns.  It may take some time to grasp them all, but they will show up again and again in your career.

Programming Pearls – Work through the problems in this book.  They are hard, but the effort is worth it.

Agile Software Development, Principles, Patterns, and Practices – Another Bob Martin book, but also a must read.

Good luck.  I hope you found this advice useful.  Starting out is hard, but if you are smart about it and deliberate, you can boost yourself several years ahead of others in your same position.

If you found this post useful, don’t forget to sign up here to get more content like this delivered to your inbox.

How To Be A Better Software Developer This Year

It is easy to get stuck in mediocrity if you are not consciously trying to improve year after year.

We have to constantly be striving to improve our skills and talents, otherwise those abilities can go to waste and degenerate.

Likewise, just striving to “improve” is not good enough either.  We have to have a definite plan for improvement.

In this post, I’ve compiled a list of things you can do this year to improve your skills and make this your best year yet.

#1, Find your biggest weakness

I always try to look for low hanging fruit that I can grab easily when trying to improve anything.  Usually, there is some weakness that could easily be corrected which would provide a huge benefit to you, but you’ve just never got around to fixing it.

low hanging fruit thumb How To Be A Better Software Developer This Year

For example, when I first moved into my new house, my refrigerator was not holding the temperature correctly.  The fridge would drop down to a very cold temperature and freeze food pretty often.

This was pretty frustrating, but I tried to ignore the problem, because I was too busy.  I kept having to throw out frozen lettuce or other vegetables until one day I decided I had enough and set it on my mind that I would either fix the fridge myself or have it repaired.

It only took me a few hours total worth of work to figure out that a little flap that sent cold air from the freezer to the fridge was broken, and to fix that issue by ordering the right part.  The results were immediate and very gratifying.  By taking that little bit of time out of my week, I saved myself quite a bit of frustration in the future—not to mention saved myself money in both electricity costs and wasted food.

So, why did it take me so long to fix that fridge?

I was always too busy, and the problem never seemed urgent enough to warrant my attention.  (Plus, I didn’t know jack about fridges.)

When I take an inventory of my professional life, I find that I have many “broken fridges” all around my office.  Weaknesses or problems that I could very easily fix, but I’ve just been to busy to get around to it.

Perhaps you have the same problem?  Have you been struggling through using your IDE, because you didn’t take the afternoon to properly learn the keyboard shortcuts that would save you quite a bit of time?

Are you stumbling through some JavaScript library, because you didn’t spend the few hours worth of time it would take to really understand how it works and how to use it properly?

Perhaps you just haven’t taken the time to organize your computer or workflow, because it hasn’t been enough of a pain to be worth your time—even though you know that you are wasting a huge amount of time by being so unorganized?

Now is a good time to look for that low hanging fruit; the easy to fix weakness you can correct this year, which will pay back big dividends.

If you take the time to look around, I’m sure you’ll find a few.

#2 Learn something new

Because our field changes so rapidly, it is very important to be learning the next thing before you need to rely on the skills to use it.

It isn’t always possible to predict what the next thing will be, but getting into the practice of learning new things will expand your capacity to learn things quickly and give you a much wider perspective of the field in general.

One of the biggest expansions of my abilities as a software developer came when I took a consulting gig leading a team of Java developers after having spent years programming in C# and .NET.  I was very reluctant to take the position, because I felt that I would be progressing backwards instead of forwards, but I couldn’t have been more wrong.

I already knew some Java, but I hadn’t really studied the language and I didn’t know much about the environment and tools Java developers use.

This experience forced me to grow and really expanded my abilities, not just in Java, but in C# as well, because it forced me to look at things from a different perspective.

It is really easy to get stuck in a rut and stick with what we already know, but sometimes you can get a huge benefit by getting a bit out of your comfort zone and learning something completely new.

Try learning a new programming language this year or an entire new programming environment.  Try your hand at mobile development, if you’ve never done it before, or learn something else that will challenge you and expand your horizons.

#3 Make new friends

Every year I talk to hundreds of software developers through email or at conferences and code camps, but my software developer life wasn’t always so social.

I didn’t really see the point in reaching out and being part of the community; after all, I was a software developer, my job is to write code, isn’t it?

friends thumb How To Be A Better Software Developer This Year

But, all of us have very limited worlds, myself included. We need the experiences and influences of others to expand our viewpoints and see things that we don’t have the capabilities to see on our own.

Think about it this way.  How far would you have gotten in learning any pursuit if you were completely self-taught and couldn’t rely on any books, conversations, or search engines to expand your knowledge?  Probably not very far at all.

It is important to reach out and talk to other software developers—and not just your coworkers—so that you get a mixing of ideas and viewpoints which will force you to grow.

Doing this may be as simple as starting your own blog to share your experiences and interact with others who comment on or read your posts.

You can also join a user group or attend a code camp or conference, which will give you ample opportunities to meet new people and exchange ideas.

There is also a huge emotional reward in giving back.  If you have some experience that you can share with others, doing so is likely to make you feel really good about yourself and provide a benefit to someone who could use your help.

If you are feeling down in the dumps or depressed, one instant cure is to do something nice for someone else.  Is there a developer you know that could use your help?

#4 Set a course

If you don’t know where you are headed in your career, there is no better time to figure it out than now.

So many developers drift aimlessly through their careers without thinking about where they want to be and what they want to become.

It is not enough to say that you want to become a good software developer or programmer—you need to set a definite direction that you are progressing towards.

With a clear goal in mind, your mind will employ the power of your subconscious mind to help you achieve that goal.  Without one, you’ll just float adrift never reaching any real destination.

(By the way, this is one of the most powerful realizations you can discover in life.  Once you learn to harness the power of your subconscious mind, you’ll be amazed at what you can accomplish.  The book that explains it better than I can here, is Psycho-Cybernetics, I highly recommend it.  One of those “must read” books.)

This doesn’t mean you have to chart out your life and decide where you will be in 20 years, but it does mean that you should at least have a plan of what you intend to accomplish by the end of this year and at least have some kind of destination out a bit further than that.

It is really worth taking that time to sit down and think about what you want to accomplish.  Don’t even worry about how you will accomplish it. It is much more important to focus on the what.  The how will come automatically once you tackle the hard problem of what.

Make this your best year yet!

Hopefully this post gave you some ideas you can use to help you to move the ball forward this year and really move towards some clear and definite goals.

One of my goals this year is to finish building my course on How to Market Yourself as a Software Developer.  I plan to include topics like the one in this post to help you chart a definite plan to market your skills and really boost your career.

It is only available for limited pre-order now while I am getting together a group of early adopters that will help me shape the rest of this course, but if you want to know when it will be released or you are just interested in more posts and software developer career advice, like this one, sign up here and I’ll keep you updated.

What are you doing this year to become a better software developer?

Beginning Lua

My last Pluralsight course for this year is out!

Beginning Lua

I started out this year with the goal of creating 30 Pluralsight courses, this Beginning Lua course represents the completion of that goal.

It definitely feels great to accomplish what I had planned, even though the process may have been a bit painful at times.  This is definitely the biggest single undertaking I’ve ever accomplished in my career.

I hope you enjoy the course.  It turns out learning Lua isn’t very difficult at all, especially if you have already been using JavaScript– you’ll find plenty of similarities in how you structure your code.

2013 12 02 10 10 59 Beginning Lua

Here is the official course description:

Lua is an extremely versatile and popular programming language that you’ll find embedded in many other applications like Adobe’s Lightroom or even World of Warcraft. Many developers are surprised to find that even very popular games like Angry Birds are written in Lua.

In this course, you’ll learn how to quickly get started writing programs and scripts with Lua. I’ll take you through the basics of Lua, show you some tricks that demonstrate the Lua’s flexibility and even show you how to use Lua in an object oriented way.

We’ll start off in this course by learning a bit about Lua itself and Lua’s history, as well as learn how to download Lua and use the popular SciTE IDE for creating and running Lua code.

After we are setup and ready to develop some Lua code, we’ll learn the basics of Lua as we jump right in and build our first application. We’ll go over Lua’s type system and learn how to assign variables, utilize operators, use conditional logic and create loops.

Once we’ve got the basics covered, we’ll explore two powerful concepts in Lua: functions and tables. We’ll learn how functions work in Lua and what makes them so powerful, and we’ll see how tables can be used for more than just storing simple data.

Even though Lua itself doesn’t have a class construct, we’ll learn how to do object oriented programming in Lua using tables and metatables.

Finally, we’ll wrap up the course by learning a little bit about the standard libraries that come with Lua. I’ll show you some examples of using some of the most useful functions in the standard libraries and show you where you can get more information about them.

What Programming Language Should I Learn?

I often get asked by beginner programmers what programming language they should learn.

This, of course, is a tough question to answer. There are so many different programming languages today that a new developer, or even a seasoned developer, wishing to retool his or her career, could learn.

I’ve actually tried to answer this question before in a YouTube video, but I want to revise and refine my answer a bit here, because some of my views have changed and I’d like to give a bit more detail as well.

112213 0123 WhatProgram1 What Programming Language Should I Learn?

The wrong question to begin with

It turns out that what programming language you choose to learn is not actually all that important

Things have changed quite a bit from back when I first started my career in software development. Back when I first started out, there were much fewer choices of programming languages and there were much fewer resources available for reference. As a result, the choice was much more important.

For example, I started out learning C and then C++. At that time, it took quite a bit of work to master the language itself and to understand all of the standard libraries that were available. A good C or C++ programmer back then had a very in-depth understanding of every nook and cranny of the language and they needed this knowledge, because of two main reasons.

  1. References were not as widely available, so figuring out a syntax or library available involved flipping through a huge book, rather than just typing some keywords into Google.
  2. Programming, in general, was done at a much lower level. There were far fewer libraries available to be able to work at higher levels, so we spent more time working with the language itself and less time working with APIs.

Contrast that with the programming environment of today, where not only is information widely available and can be accessed with ease, but also there are a large number of programming languages that we effectively use to program at a much higher level due to the vast amount of libraries and reusable components available to us today.

In today’s programming environment, you tend to not need to dive as deeply into a language to be effective with it. Sure, you can still become an expert in a particular programming language, and it is good to have some amount of depth in at least one language, but you can literally learn a new language in less than a week and be effective with it almost immediately.

Now, before your alarm bells go off and you write me off as crazy, let me explain that last sentence in a bit more detail.

What do you mean you can learn a programming language in a week?

What I mean by this is that once you understand the basic programming constructs available in just about all programming languages, things like conditionals, loops and how to use variables and methods, you can take that same knowledge to a different programming language and just learn how to do those same things in that language’s syntax. In fact, most IDEs today will even help you with the syntax part, making your job even easier.

If you are already fluent in multiple programming languages, you probably agree with what I am saying, but if you have only ever learned one programming language or none at all and are looking to learn your first programming language, you might be a little skeptical. But, take it from someone who has learned and taught programming languages which I have learned in a week, the basics are pretty much the same.

Check out this book which basically deals with this exact subject, Seven Languages in Seven Weeks: A Pragmatic Guide to Learning Programming Languages.

Now, if you are just starting out, it is pretty unlikely you’ll be able to learn a whole programming language in a week. This brings us to the question, you may be asking yourself…

So, what programming language should I learn then?

Hold up. I’m still not quite going to answer that question. Because, it still isn’t quite the right question.

Instead of getting hung up on what programming language you want to learn, you should instead ponder what you want to do.

Learning by doing is the most effective way to learn, especially if you are doing something you have an interest in or is fun to you.

So, I always start new want-to-be developer out by asking them what they want to build.

Do you want to build an Android application? How about an iOS application? A web page? A game?

First, figure out the answer to this question and then let that answer guide you to choose the technology and programming language you will use to achieve that goal.

Don’t worry so much about which programming language or technology is most valuable. You can’t make a wrong decision and regret it later, because it won’t take you much time to retool later if you need to. Once you have the basics down and have actually used a programming language to build something, you’ll find that doing it again will be much easier.

112213 0123 WhatProgram2 What Programming Language Should I Learn?

I like to encourage new developers to write a mobile application—especially an Android application.

Here are some reasons why:

  • A complete Android application can be built by a single person. Creating a complete application will really help you to feel confident about software development and is one of the best ways to really learn to code. I spent a good deal of my early career only being able to create bits and pieces of things, and it was frustrating, because I never knew if I could really “code.”
  • By learning Android, you learn Java and how to use libraries and APIs. This will give you a good programming language to start with and you’ll get some valuable experience with APIs.
  • Google gives you some free help and makes things pretty easy to learn. Since Google really wants you to create Android applications, they have put quite a bit of work into creating easy to use tools and tutorials to help you be successful quickly. (I’ve also created some tutorials, which you can watch at Pluralsight here as well.)
  • You can actually make money while learning and teach yourself a very valuable and upcoming skillset. Not only can you sell your Android application or monetize it in some other way, but you will be learning a complete set of software development skills for a platform that is in very high demand.

Aha! So Java it is then?

No, not exactly.

If you had to press me hard for a programming language suggestion for someone just starting out, I would actually suggest JavaScript.

It is no secret that I have a sort of love / hate relationship with JavaScript, but I would be a fool, and doing you a disservice, to tell you that it is not one of the most valuable programming languages to learn today.

JavaScript may not be the most pretty or elegant language, but it is everywhere and it appears that despite my best efforts to stop it, it will continue to grow and spread for at least quite some time.

If you learn JavaScript, you’ll be able to create applications in many different spaces. Mobile, web, and even robotics can be programmed using JavaScript. And, although I was quite skeptical at first, HTML5 game programming with JavaScript is actually quite good. I created a Pluralsight course on creating an HTML5 game using JavaScript, and I have to admit that I actually really enjoyed the experience.

Summing it up

So, just to be clear. My recommendation is that you focus on what you want to build and let that guide your technology choice, with a slight biased toward Android development, because of the reasons I outlined above. But, if you absolutely want to choose the most valuable programming language to learn, at least at the time of writing this post, it is definitely JavaScript. Like or hate it, it is used everywhere.

I’m actually working on some products to help developers manage their careers and lives better which will cover topics like this one a bit more in-depth. If you are interested in receiving some updates when I publish an interesting article or video, or when I launch some of those products, feel free to sign up here. Don’t worry, I won’t spam you. J

Why I Don’t Do Code Katas

Update: be sure to check out this comment chain to see a bit more clarification on what code katas really are.  Thanks for Cory Foy for pointing out that I was unfairly calling all code katas as solving the same programming problem over and over again.  Only some people treat code katas that way and this post is about why that kind of code kata is not effective.  I also updated a few words in this post to reflect this point.

I don’t want to seem like I am bragging, but there is something I just have to get off my chest.

But, before I tell you what amazing skill I have mastered through countless hours of boring practice, let me tell you a bit about my training schedule.

Everyday I get up in the morning. I put on my shoes. I begin my practice.
Usually I start with a small warm-up, just to get the blood flowing on the way to my office at the end of the hall.

Later in the day, I’ll wander out of my office for lunch and practice more on the way to the kitchen.

Right now as I am typing out this blog post, I am on the treadmill honing my craft one painstaking repetitive step at a time.

That is right, you may have guessed it by now—I am a master walker.

All my life I have been practicing this humble skill.  Each and every day I practice my secret craft.  I see other fools riding around on mopeds and motorized scooters sheepishly talking of their perceived skill at bipedal transportation.  But, although outwardly I acknowledge their words, inwardly I know that I am special, because I hone my skill to a craft.

Sounds ludicrous?  That is what it sounds like to me when some people talk about doing code katas.

Code Katas

What is a Code Kata you may ask?  Some people think a Code Kata is when you solve the same programming problem over and over again, thinking you are actually practicing something other than using shortcuts in your IDE. (To be fair, not all people view Code Katas that way.)code kata thumb Why I Dont Do Code Katas

These kinds of Code Katas come from a failed attempt to forcibly simulate the same kind of practicing that a musician or athlete would perform in order to become better at their vocation.

Why Code Katas aren’t effective

Don’t get me wrong, the intention behind Code Katas seems to be well placed, and I am all for software craftsmanship (although not the elitism that sometimes accompanies it.)  But, just as walking every single day doesn’t make you a master walker, and driving a car every day doesn’t make you a superior driver, solving the same sets of programming problems over and over again won’t make you a master programmer.

If you still have your doubts, consider old people.  Old people are not master walkers or master drivers, yet they have been doing both of those activities day in and day out for many years.  Not only do they not master these skills, the skills actually atrophy—they become worse at them, and not just because their muscles and reflexes become worse from age, it is because repeating the same thing over and over again without an increasing level of challenge actually results in the mind becoming complacent with the activity which leads to the eventual degradation of it.  (At least, this appears to be the case to me.)

Don’t lose hope though, a little later on I will tell you a real way to practice your craft in software development—one that will give you results—but, first let’s dissect the cases of walking and driving a little bit further to see why repeated practice of those activities seems to have diminishing returns.

Doing the same thing over and over again doesn’t make us better at it

We first learn from walking and driving, because everything is new and challenging.  Although walking seems like a repetitive process, it is actually the lack of repetition that provides the challenge our brain and body need to actually benefit from it.

As a toddler learning to walk or a teenager learning to drive, we are constantly bombarded with new scenarios and challenges that we haven’t faced before.  What happens when the dog runs by and brushes our leg?  How does this affect our balance and what do we have to do to adjust?  What about this new surface?  The carpet seems to absorb our feet and create more friction when we attempt to walk on it.  How do we compensate to balance on this surface?  Walking with socks on the floor gives us less grip, etc.learning to walk thumb Why I Dont Do Code Katas

But, as an adult, or experienced walker or driver, we are not challenged in nearly the same way;  we’ve already seen most of the scenarios.  Our daily commute to work rarely presents us with an unfamiliar stimulus or problem to solve.  We operate on autopilot, automatically walking and driving to our destinations without much effort or thought.

Repeatedly writing the code to solve the same programming problem over and over again is exactly the same thing, except unless you are introducing new challenges by adding constraints and twists, you are only benefiting from the exercise the first, and perhaps, the second time, you undertake the activity.

Now, not all programmers who do Code Katas repeat the exact same code over and over again.  Some of them attempt to solve the same problem, but this time not using any loops or limited the line count to a certain number or some other similar constraint.   This kind of practice is actual worthwhile practice which challenges the mind and introduces new scenarios that create new neural pathways in the brain and strengthen others. (Here is a great example of book that encourages you to do just that.  I highly recommend working through the problems in this book.)

Simply typing the same code into the same IDE over and over again for 10 minutes a day may make you feel relaxed and calm or even like a concert violinist arduously practicing their scales, but at the very best it will make you faster at using your IDE and typing code; skills which can be easily practiced through the course of a normal day’s work.  If you want to be really good at writing the code to sort lists of words and calculate prices for grocery store items in a cart, go ahead, be my guest.

How real mastery is achieved

If you are resisting what I am saying at this point, it is likely because you still mistakenly believe that walking and driving are in a different category than playing music, sports and programming.  But, the truth of the matter is that walking, running, music, sports, and programming are in the same category, or rather, there are no categories.

It turns out there are actually master walker and master drivers.  One sport that is not all that widely known goes by the name of Parkour or Freerunning.  Don’t believe me, check out this video for an example.  In this sport, the athlete becomes exceptionally good at traversing around everyday locations on their own two feet.  It is amazing what some of these practitioners can do—just watch the video if you don’t believe me.

And as for driving, I probably don’t need to convince you that Nascar is “kind of a big deal.”

My point is that you are not going to become a Parkour expert or Nascar driver by just walking around your neighborhood or driving your car to and from work, even if you do tend to drive like a bat out of hell.  To get to that level of skill in those seemingly mundane activities, you have to constantly practice at a higher level of difficulty and continually introduce new challenges.

In fact, when we actually look at what real musicians and sports athletes do, it is much of the same.  I seriously doubt many musicians you hear on the radio or see in concert repeatedly played “bah bah black sheep” or “twinkle twinkle little star” on their instruments until one day they achieved mastery.  And in the professional sports world, achievement only comes through repeatedly pushing beyond one’s limits day after day.

The point is this: if you want to get better at something, repeating practice alone is not enough.  You must practice with increased difficulty and challenge.

How to improve your programming skills

So, how then do you become a master craftsman at the vocation of software development?  If you don’t use Code Katas, how do you practice your craft?
Let me start off by giving you the best example I have ever seen.

This is Jennifer Dewalt’s blog; she decided to learn to code by building 180 websites in 180 days.  While you are sitting at your keyboard typing the same 20 lines of code into your IDE over and over again, Jennifer is creating a new thing every single day and facing a brand new challenge.

Who do you think will improve their skills more after 180 days, you or Jennifer?  I know who I’d hire without even thinking twice.

I get lots of emails asking me about the best way to learn programming or how someone can improve their skills.  Recently, I’ve gotten a lot of emails asking about how to learn Android development.  Do you know what I tell all these inquisitive minds?

Make Android apps.

But, umm, what book can I read?

No book, just come up with an idea and try to create it.  Figure out what you need to do along the way.  When you get stuck, go look for the answer or seek help.
But, I need to know what I am doing first.

Says who?  Do and then learn.  Learn and do at the same time, reading a book or repeating the same exercise over and over again won’t make you smarter or more skillful; constantly challenging your mind and current skills will.

Want to learn more?

I’ve got plenty more to say on the topic and many more techniques that are way more effective then Code Katas which you can use to hone your programming skills.  I can’t fit it into a single post like this, but I’ll be putting it into the top secret project I am working on to help developers boost their careers and learn to market themselves.

If you’d like to be one of the first to be notified when it is available, sign up here.  I’ll be including lots of practical valuable information that you probably won’t find anywhere else.

So, what do you think?  Do you do Code Katas right now?  If so, do you think they are actually useful?  Let me know in the comments below.