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 an API and Endpoint?

For most developers these concepts aren’t that complicated and are widely used in the project they are working on. However, I do remember that when getting my computer science degree there was no mention of either of these in any of the courses. The only time it was actually mentioned in a class was when a student was giving a presentation, but it never came up in the coursework. This is fine because a degree isn’t supposed to teach you everything, but it is still something to look into before you get a job because you will need to know these things. An API is a set of methods for interacting with an application. Essentially it is a way for you to access information about an application without having to know how the application works. This is done by giving people access to endpoints in an application. These endpoints are essentially URLs that access a certain method that a developer has set up in order to access information from the application. So you can use an endpoint to get data from an API and then use that data in whatever way you need. It is a really simple thing to learn, but can be easily overlooked. If interested then you can click here to get a little more in-depth view of an API.

Also if you have any questions just ask them in the comments.

The Writer’s Glove

If you are a developer then you have probably ran into the problem that your hands get cold after a long session of typing. Keeping your hands extended from the body can make it hard for some people to keep heat in their hands. It is very hard to find a solution because to type efficiently you need to have your bare hands, or at least your bare finger tips. Although if you try those gloves that have no fingertips on them then you quickly realize that this is not the perfect solution. The best way to keep your hands warm would be to have gloves that cover your hands fully but still allow you to type efficiently. This has been accomplished by “The Writer’s Glove”, which granted was developed for writers in mind, but we developers are writing technically. These gloves cover your entire hand, but they are thin enough that you can still feel the keyboard. They are made out of 100% silk, which makes them feel great on the hands. It does take a few typing sessions to get completely used to the feeling of typing with them on, but it becomes just as easy as typing without them. They also make a pair of the gloves that allows you to use the touchscreen of your phone, which means you won’t have to constantly take them off to deal with any notifications you get on your phone. You can get them from here and also supply them with the code SoftwareUpdates to get a discount on your order today.

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

What is Atom?

If you came to this post wondering what an atom in physics is then I have bad news, I am talking about the text editor Atom. This is a very nice text editor for writing code. It supports many programming languages and has some features, like auto-complete, that makes it great for any programming. It also has several add-ons that can make your life a lot easier, like a nice to-do list add-on. Another thing that I really like about it is that there is a version for all the operating system and they all work very well for each OS. This means that I can be consistent when switching between operating systems. This is just my preference but it is really nice to be able and work in the same environment on all three operating systems. Granted there may be times when you need an actual IDE for the task at hand, but when you don’t require one then I suggest using Atom. There are other alternatives, like notepad++, but it doesn’t work as well with Mac OS as it does with Windows.

Checkout Atom for yourself.

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.

What is the best operating system?

There have been numerous debates on which operating system is the best to use as a software engineer. You will find someone in every corner trying to convince you that the operating system they use is the best. The truth is though it comes down to preference and what kind of software you are using at the end of the day. Even in your job it will come to what the business prefers and what software they are invested in. At my work we are highly invested in Microsoft so it is only natural that we use Windows 10. Granted it’s not my favorite operating system, but that is just my preference. In reality as a software engineer I would suggest that you get familiar with all the operating systems, well mainly Microsoft, OS, and one Linux distribution that you like. This is so you will have experience working in all 3 and be able to adapt when your job calls for it. So I wouldn’t focus on which operating system is better and just learn to use the 3 of them, this will ultimately help you in the long run. Don’t let people convince you that one operating system is better to code in than another either because that just isn’t true. They are all fine to code in and again that really just comes down to preference.