What is SOLID?

I know what you are thinking and no not the state of matter but in a software engineer capacity. This is an acronym that stands for the 5 principles of software development.

Single-Responsibility Principle

The first principle is called the Single-Responsibility principle, which says that a class should only have one job. So if you have a class that does some sort of calculation and then you have several other methods that print out the calculation in multiple formats then you may want to extract those out into there own class. That is because that class has become something that now does two jobs instead of just one.

Open-Closed Principle

The second is the Open-Closed principle, which says that objects should not be able to be modified but should be able to get extended if needed. Another way to put this is that it should be easy to modify the behavior of a class without actually having to modify the class itself. An easy way to achieve this is to create an interface for a class and then pass that class into another object.

Liskov Substitution Principle

The third is the Liskov substitution principle and it has a very formal saying to explain what it means. The short version however is that every subclass or derived class should work as a substitute for their parent or base class. This means that any derived class shouldn’t modify the behavior of the parent class. Essentially you need to have a very generic abstract class that you inherit from. Take an example like having a circle class and a rectangle class. Both of these classes need to inherit from a generic abstract class called shapes. This will allow you to implement things specifically for each class without interfering with the other classes. It also allows you to create new shape classes easily.

Interface Segregation Principle

The forth is the Interface Segregation principle, which states that a client should not have to implement an interface or depend on a method that it does not use. So if an interface is needed to be implemented by a class and it forces that class to actually implement a method that it will not be able to actually use, for whatever reason. Then it may mean that a new interface needs to be implemented that does not have the method.

Dependency Inversion Principle

The fifth is the Dependency Inversion principle, which states that a high level module should not depend on a low level module. Instead the modules should depend on abstractions. This means that when thinking of the interactions between the high level module and low level module it should be thought of as an abstraction. This allows for decoupling between the two modules.

These five principles are easy to grasp in concept and can be very helpful when coding. The hardest part is to remember to use these principles as you code and sometimes things will slip by but that is what refactoring the code is for.

What is a Full Stack Developer?

This is can be a common question to people new to the world of development. It actually just has a simple answer, it means that someone is working on the full range of technologies when working on a project. Specifically the developer is not just specialized in one area like the database, front end (HTML/CSS), or just some language like Java. So a full stack developer will be familiar with all of those technologies and how to use them. Usually this will mean that a full stack developer will make more money then someone who just does front end work. It is important to determine what kind of work that you like to do when finding a job. That is because it would be more beneficial to only work in the front end of things if that is what you prefer then force yourself to work all over the technology stack. Don’t forget that this does not mean a full stack developer is not specialized in any area. They may have a specialty in database development but have a good working knowledge of all the other areas. That is about all there is to the question, “What is a Full Stack Developer?”.

Is a computer science degree worth it?

Some people are wondering if it is even necessary to get a computer science degree nowadays, especially with the cost of college steadily increasing. Even big companies like GOOGLE are getting rid of the requirement of having a degree in order to get a job with them. However, I still think that getting a degree can be beneficial and even justify the cost of the degree. This is because most of the time when you learn to program you mainly are just learning how to use a programming language. This is true for code bootcamps as well since they only give you a crash course in how to understand to use a programming language. Usually the bootcamps use a language that the companies that they have contacts with use. This makes it easy for you to easily get a job with that specific company. A degree makes getting a job in any programming language easier. A degree in computer science however will teach you much more then just a programming language. A degree will teach you the problem solving skills that are needed to tackle a lot of the problems a software engineer faces in their daily job. It will also teach you the fundamentals of programming that will allow you to pick up any programming language easily. This means that what you learn when you get a degree in computer science will allow you to keep up with the field in the long run and not just get you a job at a local company that will be hard to get away from without the necessary training again. This basic knowledge from a college is something that can’t be overlooked when thinking about what you want to do with your life. This does not mean however that it is wise to go to a very expensive college and be a hundred thousand dollars in debt. It would be better to find a college that is in a reasonable price range and get the degree for cheaper.

But I haven’t used the knowledge from my degree on the job!

This is a common statement from many people who graduate from college and then get a job as a software developer. The statement is actually true in some way. That is because all of the things that you do in college are mainly building blocks and learning how to solve problems, while the job requires you to solve much more difficult problems with the latest, or most outdated, technologies. This means you are tackling a very different thing in the real world then you are at a college. That is because college is not supposed to prepare you for the job like a bootcamp. College, like I said before, is to prepare you to tackle a wide variety of problems by giving you the foundation to problem solve fast and learn new technologies easily. This means you probably won’t see a lot of direct correlations between what you have learned from college and what you will do on the job.

Design Patterns

This is another topic that was not fully covered in my computer science degree and I think it is a very useful topic for when you actually start working. Design patterns are basically reusable solutions to common problems. They fall under three categories: creational patterns, structural patterns, and behavioral patterns.

Creational Design Patterns

Creational design patterns are all about class instantiation.

Names of Patterns:

Abstract Factory
Builder
Factory Method
Object Pool
Prototype
Singlton

Structural Design Patterns

Structural design patterns are all about class and object composition. It does this with classes by using inheritance to compose interfaces and then composes objects in different way in order to obtain different functionality.

Names of Patterns:

Adapter
Bridge
Composite
Decorator
Facade
Flyweight
Private Class Data
Proxy

Behavioral Design Patterns

Behavioral design patterns are more concerned about communication between objects.

Names of Patterns:

Chain of responsibility
Command
Interpreter
Iterator
Mediator
Memento
Null Object
Observer
State
Strategy
Template method
Visitor

As you can see there are many different patterns for each category. Although do not think all of these patterns will answer all of your programming problems. There is some debate on how useful design patterns actually are and when to use them. I would find a pattern that you find interesting and try to implement it in a side project before using it for actual work and be sure that using a pattern is the best way to do things before implementing it in your project.

You can find more information on all of these patterns at Source Making

Easy to access cheat sheets for programmers

One thing that is very different from going to school for computer science and actually having a job as a software engineer is that in school you are expected to keep everything inside your own head and not rely on an outside source. In the world of software engineering you have the option to actually look up anything that you do not know off the top of your head. Granted that you cannot constantly be looking up things and even if you do it very rarely it ends up taking a lot of time trying to find the specific thing you are looking for. That is where cht.sh comes in handy. This website lets you look up cheat sheets on a lot of different languages and even has a way of searching the web for content if it does not already have the answer you are looking for. It isn’t even necessary to go to the website in order to look things up. You can simply use the command line to access everything. It has some predefined cheat sheets and even has a tutorial over the basics of many languages. There is a command for searching the documentation or if it can not find it then it will simply look up an answer for you. It is a very nice tool to have as a developer and can come in handy when needing a quick refresher on something.