Starting from the bottom

Lately, it seems a lot of people are reaching out to me asking the same question: “I have zero experience, but I want to be a programmer. Where can I go to get started?”. It can be frustrating and overwhelming trying to learn software engineering skills, but it is absolutely worth everything you put into it. As far as statistics go, “Software Engineer” is the highest paid position for new students graduating college right now. There are also the benefits of working from home, setting your own schedule, and more. On top of that, there is an abundant need for new developers currently in the market.

So maybe you find yourself in need of a career change, looking for something new, or wanting to make programming your career. My goal in this article is to show what steps I have taken over the years, what has helped others, and what business owners are looking for in interns and junior developers.

Step 1: What kind of software developer do you want to be?

Identifying what kind of work you want to do is going to define how you approach this guide and is the most important step of becoming a software engineer. All software engineering boils down to are these simple categories:

Category Description Pay
UI / UX (Designer) Designs the part of systems that users interact with. Specializes in user-friendliness and polished look. $
Front-End Developer Develops the part of the systems that users interact with. Sometimes this position entails design as well. $$$
Server-Side Developer Develops the part of the systems that handle business logic, security, and interactions with a database. $$
Database Administrator Architects, develops and maintains databases and server infrastructure. Typically handles data integration as well. $$$
Mobile Developer Develops applications to run on iOS, Android, and other mobile OS. $$$
Full-Stack Developer Jack of all trades that can excel at all the above positions to handle any project from start to finish. $$$$$

Do you have a knack for design? Are you artsy? Then you might want to start as a UI/UX engineer and move into front-end development. Not so creative, but you can process intense logic and structure? Start as a Server-Side developer or Database Administrator. Keep in mind that you are not limited to any one or two of these positions. In fact, the more you know and closer you get to being a Full-Stack Developer, the more you will be able to do on your own, and the more companies or clients will be willing to pay you for doing so.

Step 2: Join the community

I cannot emphasize how important being a part of a developer community is. This is how you know what to learn, what the best practices are, and who is teaching them.

  1. Twitter
    The number one, easiest way to gain access to a community is Twitter. If you do not have a Twitter account, please stop reading this now and come back when you have one. This concept is easier shown than described. Let’s take, for example, that in step one you chose Front-End Developer. Good choice! It’s a very in-demand position. So your focus programming language is going to be JavaScript. Today’s most popular javascript frameworks that companies are looking for skills in are React, Angular, or Vue. The developers working on these different frameworks are the leaders of the javascript community. All day long they are tweeting about new features they are working on, what’s coming out in the next release, polling the community to see what they should work on next, etc. Follow these people. This is your gateway into any software community.
    The following list is comprised of leaders in the JavaScript community I follow and engage with:
    Todd Moto – Angular GDE & Owner of Ultimate Angular
    Max Lynch – CEO of Ionic
    Uri Goldshtein‏- Meteor Developer
    John Papa – Developer Advocate at Microsoft
    Dan Abramov – React Developer at Facebook
    These are just a few of my favorites, but you get the point. If you want to be a good developer, learn from good developers. Be concerned about what they are concerned about. Check your feed regularly.

  2. GitHub
    Another great tool for thriving communities is GitHub. Sign up for an account, and start seeing what others are working on and how they write code. You can actually go look at the source code of Angular, and see exactly how the pros at Google write JavaScript. What’s more than that, you can actually edit and submit changes that you think are helpful to the project. This is an excellent way to join the community, and a well-used GitHub account looks great on a resume.

  3. LinkedIn
    There is one more social platform that you must be on. Dare I say it… LinkedIn. Yes, Linkedin may not be the best social platform out there, but one thing is true: It is loaded to the brim with recruiters that are constantly seeking new talent for their customers. Connect with these people, communicate with them, and they will try to match you up with a company that’s looking exactly for you (that’s their job).

Now that you are a part of the community, and the channels to gain the most current information are open, we can start focusing on skills.

Step 3: Get to know your tools

  1. IDE (Text Editor)
    We’re not ready to jump right into code just yet. First, you need to download, install, and get a little more comfortable with your tools. You can start googling around what the most popular IDEs (Integrated Development Environment) are for your target position/programming languages. IDE is a fancy term for the text editor you are going to be writing code in. My personal favorite IDE, that covers most programming languages well is VS Code. It’s created by Microsoft, runs on every operating system, and is very customizable.

  2. Source Control
    Source control is basically a single repository on a server somewhere where your code sits. It allows multiple people to work on the same code files- without getting in each other’s way. Source control is not something that you will need right away to get started, but EVERY company uses it. There are several different programs for source control, but Git is the most popular, and a must-have skill to be listed on your resume. Download it, watch a video on YouTube on how to use it, and start figuring it out.

  3. Google
    Google is, and forever will be, your friend. There is no developer on this earth that can go a day without having to google some syntax issue or a problem they run into while programming. Keeping with the JavaScript theme, something you might find yourself googling a lot at first is: “Sort an array of strings alphabetically”. Do not feel that googling a solution to your problem is cheating. It is research.

Step 4: Start Coding

This is it. The moment you have been waiting for. It’s time to actually write some code.

  1. Basics
    Before you really dive deep into making your first application (whether it be mobile, a website, etc.) you need to understand the basics. For this step, I recommend free online interactive courses to get you started. Code Academy is one of my favorite of such sites. It is free to get started and has plenty of awesome beginner courses in relevant technologies. Of course, there are always actual college courses you can take. I don’t necessarily recommend attending college, as I believe they don’t teach the most up-to-date practices, and it takes years and tremendous amounts of money to finish your curriculum and earn a degree. I have known several successful software engineers, in addition to myself, who only have a high school degree.

  2. Your First Project
    Once you feel confident enough in your basic skills, it is time to pick a personal project. Think of something that is of interest to you, that also will force you to learn a skill that will be beneficial in the real world. I emphasize the “Of Interest To You” part. If you are not interested in your personal project, you will get bored quickly and leave it unfinished. So, let’s say you want to build a mobile app and learn some great real-world skills as well. Check out Ionic Framework. Building an app with Ionic will force you to learn its underlying framework, Angular. Set requirements for yourself. For example: “My app needs to take a picture, and save it in a database. I’ll also want a screen to display those images later.” Then, do it! Find examples online of other developers that have done a similar project. Watch tutorials on YouTube. Get your project working, and don’t give up. Having these small, personal projects ready to show on an interview is huge. It shows your potential employer that you can get it done. You may not know the ins and outs of the technology, or how exactly it works, but you were able to figure it out and get it working. Having a few of these projects ready to show can sometimes be better than passing the technical interview.

Step 5: Rinse and Repeat

The steps outlined in the article do not go away after you pass your first interview and land your first job as a software engineer. Technology is constantly changing and your skills will need to as well. Perfect these steps. Stay humble and learn how to teach yourself new things quickly and effectively, and you will have success as a programmer.

Note what Steve DiFranco, CEO of Alt Media Studios, and a long time friend of mine has to say on this matter:
“In general, as a business owner, I’m always looking to hire people who are hard workers and eager to learn. In the past, I’ve seen younger developers come to me with a major overestimation of their own capabilities. That attitude leads to problems down the road because, to put it frankly, these Developers just aren’t as good as they think they are. So for us, it’s more than the skills that someone brings to the table; it’s their General attitude toward work and an eagerness to learn proper techniques.

If I am looking for skills I do want to see practical applications of those skills in some format. For example, a recent hire was able to demonstrate a system he built which contained features that allowed users to log into an account management portal and also pay and register for certain things. The system wasn’t anything glamorous but it worked and I was able to see his code was neatly done. But beyond that, this particular developer was successful because he showed a good attitude toward wanting to learn and improve.

My advice to any individual who wants to become a developer is to stay humble.”
– Steve

Now we’re here.

So in conclusion, you have figured out what kind of developer you want to be. You joined the online community and began learning from the best in the industry. You found the tools required to do your job and familiarized yourself with them. You started learning your new skills and honed them with personal projects. You are now ready for your first interview. Enjoy your new career as a software engineer.

Looking for a place to apply? I’ve personally known Steve at Alt Media Studios to bring on new developers and coach them into their new career. Steve is always looking for fresh talent.

In this post, we will investigate why TypeScript could be the transpiler for you.
For helpful resources regarding ECMAScript 6, check out this GitHub repo.
If you are new to TypeScript and not sure what it is, head on over to Peleke’s post: Why You Shouldn’t Be Scared of TypeScript. He does an excellent job of describing what TypeScript is compared to some of its competitors.

A need for ES6+ Transpilers

It’s 2017, and the web’s ever-expanding amount of technology is bigger than ever before. Naturally as web developers, we want to use the latest and greatest technologies possible. There is one problem, however, that has plagued us since the dawn of the web: cross-browser compatibility. Unfortunately, not all browsers support the latest standards from ECMAScript 6 or beyond. Then came the transpilers. They allow us to use the new and exciting features, and then transform or compile our code into an acceptable format for modern browsers. The question is: which transpiler will you choose?

Why choose TypesScript

Babel is still one of the most popular and widely used ES6+ transpilers on the market. It is an excellent choice for JavaScript developers looking to expand their code with ES6+ features. Also, TypeScript was created by Microsoft, who has a reputation of forcing developers to stay in the Microsoft ecosystem of development tools and environments. Yuck. These facts alone will generally scare off any new front-end developers from choosing TypeScript as their transpiler. I’m going to tell you why, despite the facts, TypeScript might be the best transpiler for you.

1. Microsoft, and C-based languages

As mentioned above, locking yourself in the Microsoft ecosystem can scare away many developers. However, if you are already a part of that ecosystem, TypeScript is a dream come true. If you, like myself, come from a background in ASP.NET development, or any kind of C development, then JavaScript may at first be a painstaking language to learn. JavaScript has several common pesky errors, like undefined is not a function; and then, there are things like this:

console.log(9999999999999999 == 10000000000000000); // evaluates to `true`
// Don't believe me? Press F12 right now and paste that into your console. 

The bottom line is this: If you are a full-stack developer using ASP.NET server side, or come from a background with strongly typed programming languages in general, writing vanilla JavaScript can be difficult. If C# and JavaScript had a baby, it would be TypeScript. TypeScript can provide training wheels, so-to-speak, to make writing JavaScript easier for type lovers. Let’s say you want to write a function that adds two variables together. In vanilla JavaScript our code would look something like this:

function add(a, b) {
    return a + b;
}

var c = add(1, 2);
console.log(c); // evaluates to 3

Simple enough, right? Looking at this function at face value, a few assumptions are made:
1. This method always returns the type number.
2. Both parameters a and b would always be passed in with a type of number.
However, we cannot always guarantee this. add may be called from markup, or another developer may be using add incorrectly somewhere else in the code base. You might end up with something like this:

var a = '1',
    b = 2;

var c = add(a, b);
console.log(c); // evaluatues to `"12"`

Now we have some serious problems! Our code expected the number 3 to be returned, but not only did it return 12, its a string. When using the + operator in JavaScript, if one of the parameters is a string, it will concatenate the characters and return a string. Only if both ends of the + operator are numbers will it add them together.

It is errors like these that us type-loving developers hate about JavaScript. In TypeScript, this wouldn’t even make it past the compiler. Let’s see this same function in TypeScript:

function add(a: number, b: number): number {
    return a + b;
}

var a = '1',
    b = 2;

var c = add(a, b); // compiler error: [ts] Argument of type '"1"' is not assignable to parameter of type 'number'.

// -- or --
var a = 1,
    b = 2;
var c: string = add(a, b); // compiler error: [ts] Type 'number' is not assignable to type 'string'.

Imagine all of the headaches cured from just this example alone by adding simple type saftey to JavaScript. In our example above, we typed the variable c as a string, but left a and b un-typed. One of the great benefits to TypeScript, is it is a super set of JavaScript. What that means is that you can write all of the vanilla JavaScript you want in a TypeScript file, and the compiler will accept it.

This example alone was enough to sell me on TypeScript, but there is more.

2. Angular

Angular has grown to be a leading JavaScript framework in web applications today. Which transpiler did the Angular team at Google choose for Angular? You guessed it: TypeScript. In Fact, Google chose to scrap their own AtScript in favor of using TypeScript. Because of this, TypeScript’s community instantly gained the community base from Angular. This is a huge benefit. A larger community base, fueled by Google developers means more content on websites, such as this post, more TypeScript questions and answers on Stack Overflow, more developers finding and fixing bugs, and the list goes on and on.

3. Enhanced IDE support

Your development experience using TypeScript is a great improvement over plain JavaScript. The IDE or text editor is informed in real-time, by the TypeScript compiler, of all errors present in your typed code; this gives a few major advantages. For example, with TypeScript, you can safely do refactorings like renames across your entire codebase. You can use common features like Find all References or Go to Definition. Through code completion you can get inline help on whatever functions a library might offer. No more is there a need to remember them or look them up in online references (for more see DefinitelyTyped). Compilation errors are reported directly in the IDE with the typical red squiggly line. Here are the IDEs / Text Editors that support these amazing features:

More than likely, your editor of choice is in the list above. With TypeScript, you can enjoy writing code more, and debugging errors less.

4. Interfaces

Tell me if you have ever been here before:

function print(user) {
    console.log(user.PersonID); // undefined... not it.
    console.log(user.personID); // undefined... still not it.
    console.log(user.PersonId); // undefined... :'(
    console.log(user.personId); // undefined... C'MON!
    console.log(user.personid); // 123... Finally! :)
}

If you have, you are not alone. TypeScript offers us the ability to create Interfaces. Interfaces are not new to us; plenty of languages like C# feature Interfaces out of the gate. Interfaces allow us to set a contract that all objects inherting from a given interface MUST hold to. Let’s see an Interface in action:

interface IUser {
    personid: number;
}

function print(user: IUser) {
    // we know in real-time that `personid` is a required property of the `user` object.
    console.log(user.personid); // 123
    // in fact, trying to use anything else will throw a compiler error.
}

Interfaces give us type safety on our objects, so we never again need to wonder what we named that one property, or what properties we have available on an object; it is all just right there in the intellisense of our IDE or Text Editor. We also have the option to mark properties as optional or read-only. We can also specify what a constructor should take for any class that inherits from a given interface. TypeScript’s Interfaces give us the ultimate flexibility in the amount of type safety we want to use it. Using Interfaces properly also gives us a practical principle that is extremely important in larger applications: scalability. Do you want to refactor tons of code that interacts with our IUser interface from earlier? Simply change the interface and instantly know all the places your code needs to change. Adding a new developer to a six-month old project? They can join the project knowing in real-time how to interact with any IUser object. This is a huge benefit that will become more and more apparent as you increasingly use Interfaces.

5. ES7 and Beyond!

ES6 still isn’t fully supported by modern browsers yet. Is it wrong to think about ES7 and the future of JavaScript standards? Of course not! TypeScript already has support for several ES7 features, and it will continue to be developed on a path that parallels the common web developer’s desire to use the freshest technologies available. A prime example of this is Decorators. A Decorator is defined as an expression which returns function and can take a target, name, and property descriptor as arguments. You apply it by prefixing the decorator with an @ character and placing this at the very top of what you are trying to decorate. Decorators can be defined for either a class or property. If you have begun using Angular since its 2.0 release, you no doubt have seen or used decorators already. Let’s look at a simple controller in Angular:

import { Component } from '@angular/core';

@Component({
  selector: 'my-app',
  template: `<h1>Hello {{name}}</h1>`
})
export class AppComponent { name = 'Angular'; }

Here, the @Component decorator provides metadata that defines something about the class AppComponent. In Angular’s case, the @Component is going to define how the AppComponent class will interact with the given template. To learn more about Decorators, check out the TypeScript handbook.
TypeScript is here to stay. It will continue to grow in features and functionality that will put you, the developer, one step ahead.

In Conclusion

So to recap, if you are used to having strong types, or are new to JavaScript, TypeScript can ease you into the aches and pains of learning the loosly typed declarations of vanilla JavaScript. On top of that, one of the best JavaScript frameworks ever, developed by some of Google’s top engineers, chose TypeScript as their transpiler. So if TypeScript is your transpiler of choice, you will be accepted as part of a large, growing community of front-end developers. Also, TypeScript is here to stay. Aiding in making web applications scalable today, and looking to the future of what lies ahead for the web, TypeScript will continue to make your life as a web developer easier.

Where do I start?

If you are sold on TypeScript and want to get started immediatly, head on over to website: https://www.typescriptlang.org/. They have excellent documentation to help you get started, including simple installation and beginner tutorials.

Feel free to comment below your likes and dislikes of TypeScript, or if you enjoy using it as much as I do.