How a programming portfolio can help you

How a programming portfolio can help you

Having a programming portfolio when you are a software developer can be the single best thing you can do in order to get the job you want. A portfolio helps by showing what you are able to do, even when you have just finished studying and have no real work experience. I am really surprised that developers do not use this useful resource more often in order to show what they can do.

Interviewers are tired of reading resumes

Resumes are broken for developer positions. That is true. I often have to review several resumes and it is not an easy or pleasant task. We don’t have time to interview everyone, so some filtering needs to be done. Almost all the resumes use the same words, same objectives. You know what I mean, and of course, my resume looks the same too.

What I want to see as an interviewer is what you can do and what you want to do. Show me that and you will probably be at the top of the list of candidates. The interview will probably be easy too, talking about things you have already built and know well. The decision might even be almost made before the interview, using the meeting just to get to know each other better.

What is a good programming portfolio

A programming portfolio is not like a designer portfolio. It is more difficult for developers to show what you can do. There is no golden rule when it comes to programming portfolios. When I read a resume, I always look for those first: a github account or a link to a website. If you have one of those, you are already on the top 5%.

An active github account can be a your best letter of recommendation. Some of us, though, are not as active in github as we would like to be, or do not like the openness of it. Not everyone wants to be popular, ninjas or hackers, and some of the best developers I know just want to get their work done right.

Another option is creating your own website or blog with your work or articles on it. This also implies being visible to everyone, but you can have control over it. You don’t even have to use your real name if you don’t want to. You can add pieces of code that you like and explain a bit about your side projects. If you are just out of school or college, I am sure you can put some of the projects you had to do there.

The last option if you really do not want to have an online presence is to have a paper portfolio. This is how I got my first job. I luckily got an interview, and I prepared a simple document with the work I had been doing at college and by myself.

Conclusion

You will get more exposure and chances to an interview by having a programming portfolio. Most interviewers are not used to it so it is a way of standing out of the rest of candidates. It is a way of showing what you are really capable of, something that a resume cannot explain.

TypeScript typing and why you should use it

TypeScript typing and why you should use it

I consider TypeScript static typing to be the best single feature in TypeScript. Of course, there are also other useful functionalities like classes, interfaces or generics, but those alone would not make me decide to make the change. In this article we will see how TypeScript typing works and how to use it to our advantage.

About TypeScript Typing timing

TypeScript code cannot be executed directly, it needs to be compiled into JavaScript first. JavaScript is a dynamically typed language. This means that the resulting compiled JavaScript is not typed. So, TypeScript typing is static and gets executed on compile time. Lets see a simple example:

let a: string = "Hello";

We just defined a variable a, of type string, and initialised it with the Hello value. This compiles to the following JavaScript:

var a = "Hello";

As we can see, the type information gets removed.

TypeScript basic data types

TypeScript offers the same data types as JavaScript and some extra useful additions. Lets start with the most basic types: boolean, string and number:

let a: boolean = true;
let b: string = "Hello";
let c: number = 78;

Once we defined a variable with a type, we cannot assign other kind of data to it:

let a: boolean = true;
a = "Hello"; // Error: type "string" is not assignable to type "boolean"

Then, we have arrays. Arrays are defined by appending [] to the type of data in the array:

let d: string[] = ["Hello", "world"];
let e: number[] = [48, 97];

A new type is tuple. A tuple is a type of array where the number and type of data is known from the beginning. It is useful if we need to return multiple data from a function:

let f: [boolean, string] = [true, "Hello"];

We can also define the types for JavaScript plain objects, like we would define a Map in other typed languages:

let g: {[key: string]: string} = { hello: "world" }

The any and void types

Because JavaScript code is also valid TypeScript, explicitly indicating types is not a requirement. TypeScript handles this by assigning the type any when no other type cannot be inferred.

let a;
a = "Hello";
a = 4;

In this example, a becomes of type any. This allows us to assign any type of data to it, like we would in JavaScript.

We can also explicitly set the type to any:

let a: any = "Hello";

This can be useful when dealing with legacy JavaScript code or when using external libraries that do not offer type definitions. Other than that, we should try to define the types of data correctly.

The contrary of any is void. It is mainly used to indicate that a function does not return anything:

let h: () => void = function(): void { 
    console.log("hello"); 
}

Avoid using the any type as much as possible

By default, TypeScript accepts implicit any. This is useful, as we have seen, when working with JavaScript code. When I am dealing with new projects, I always set the compiler noImplicitAny flag to true, and I recommend you do the same. This will alert us when we are not setting the types of our data and TypeScript cannot infer the type for us. This can also be set in the tsconfig.json file of your project.

Even if not necessary, I always try to declare the type, even when TypeScript can automatically infer it from the data. I believe this will allow keeping more easy to understand code, and reduce errors.

Conclusion

The addition of static typing that TypeScript offers, allows us to write more maintainable and easy to understand code. We have seen some basic data types like number, string, boolean, array and how to use them. We have also seen some new TypeScript types, like tuple, and the ability of defining plain object signatures. Finally, we learnt about the any and void types, and why we should avoid the any type and embrace explicit type declaration.

Side Project: Dealing with lack of motivation

Side Project: Dealing with lack of motivation

It is not something that only developers do. Everyone does it. We start things and stop before completing them. Specially, for developers, it is not uncommon to have an idea and work on it for some time, and then forget gradually and leave it unfinished.

This time I will focus on programming side projects. A side project is a project besides your normal work at your job. Even though, I believe some ideas might also be applicable to the day job as well as to other purposes or hobbies.

The box of forgotten projects

I could count a lot of times that this has happened to me. Game ideas, a cool library or utility, an smartphone application, my twitter account, my personal blog, a diet. I can start with a lot of motivation, and then stop suddenly one day, or move to the newer cooler thing. Don’t get me wrong: sometimes moving to the newer cooler thing might be the right thing to do.

Motivation does not last forever. It might be months, weeks or days, but there is always a time when the spark disappears and we don’t feel like going on with our project anymore.

For example, this new blog. Right now I feel like I could write forever. But experience tells me that there will come a time when it won’t be like now. I will need something to keep it going on. How can we overcome that phase?

Think about the objective of your side project

We all have unfinished projects. I have lots of failures. I still do fail and will fail many times. But after many failures, I realized that the objective or motivation is the most important ingredient for success. Probably all the objectives are valid. But depending on each person, one might be more helpful than other in order of accomplishing the goal.

Think deep about the reasons you are doing the project. Is it to learn? Is it to help others? Is it to become rich? Is it for fun? If the reason does not seem to motivate you enough, try to focus towards another more rewarding objective.

When the moment where we lose the motivation comes, think again about it and try to motivate yourself again.

Creating habits

I realised that creating habits it’s the key to being able to continue. Well, creating the habits and then following them, of course. Try to set a day or time of the day you want to dedicate to your project. Try to adhere to it. If the time comes and you don’t feel like working on your side project, trust me and just force yourself to do it for ten minutes. Probably after ten minutes you will want to continue doing it.

Don’t give up. It is ok to change objectives, and to change things that are not working. But do not use that as an excuse for leaving a project. Creating habits and thinking about the objectives will help you accomplish your dreams.