DEV Community: Jason Shelley

3 Reason Why Javascript Should be your First Language

Jason Shelley — Mon, 13 Dec 2021 16:32:28 +0000

There are many languages to choose as your first language, i.e. Python, JavaScript, Go, and Ruby. All these languages have been heralded as easy languages to learn. There are good reasons to call these languages “easy”.

They are easy to set up and relatively easy to start creating projects.
They have easy syntax and concepts that a beginner would find easy to understand right away.
They have vibrant communities around them.
There are a ton of libraries to help you build robust programs.
There are many tutorials, books, videos, courses and other resources to learn these languages.

Another reason to learn one of these languages is there are many companies looking for developers who know these languages and they are willing to pay a decent wage. For example, the average JavaScript developer with experience can make over $100,000.

But which one of these languages should be your first language?

There are three reasons why Javascript should be your first language.

1) Language

The actual Javascript language, ignoring the platform i.e. browser or Nodejs, has been a matter of controversy for years. Many people love it, others hate it. It is a widely used language with a long history. But the language has gone through so many revisions, that now we are stuck in this hybrid state, where some developers write JavaScript one way and other developers write it another way. This could be very intimidating and down right annoying at times. But in reality, it created a world where a developer can learn how to code in different mindsets.

JavaScript is a multi-paradigm scripting language. It supports object-oriented, imperative, and functional programming styles. Even though it’s a dynamic language, you can use strongly typed languages that are built on top of JavaScript, like Typescript.

The flexibility of the language allows you to write in all these different paradigms. Mastering these paradigms can benefit you later on when you want to learn another language that emphasizes one of these paradigms, i.e. an object oriented language.

2) Platform

JavaScript started in the web browser. It’s one of the core technologies of the web. Learning JavaScript allows you to understand how the web works. The amazing thing about Javascript is you literally have access to thousands and thousands of websites at your fingertips. That means you have access to all these websites’ Javascript code. You can read other people’s code, learn, and practice.

Getting started with JavaScript is relatively easy. Open a browser and start playing with code in the console, or open up any text editor and start writing some code inside of html tags and then open the file in your browser, no setup required.

Now, JavaScript engines are common components of both server-side website deployments and non-browser applications. With the creation of Nodejs, React Native, Cordova, Electron and other application frameworks, you can build mobile applications, desktop applications, games and server side applications and services.

JavaScript has even appeared in some embedded systems.

To be honest though, depending on your requirements and needs, JavaScript may not always be the best solution for non website apps.

The fact that you can learn JavaScript and transfer that knowledge to a different platform is very powerful and a great incentive for learning the language.

Even though many languages, like Python, can be used across different platforms, Javascript still dominates the web.

3) Concepts & Design Patterns

The third reason why you should learn JavaScript is that there are concepts and design patterns that are openly exposed to you while learning the language on different platforms.
For example, if you write server side JavaScript using Nodejs, you are introduced to principles and design patterns that are at the core of the Nodejs ecosystem. For example, you will learn the following concepts and design patterns:

Modules
Event Loop
Callbacks
Event Emitter

1) Modules
The concept of modules teaches you how to structure your code in small well defined components. Each module should focus on one thing and it should do it well. This helps you keep your code simple and understandable. This also helps with testing. This concept is seen throughout all of Nodejs APIs. This is good training for new developers.

2) Event Loop
When you learn about Nodejs asynchronous nature and it’s Event Loop, you are actually seeing the reactor pattern in use. This design pattern is an event handling pattern. Each I/O operation/event, i.e. file access, network operation, etc, is associated with a handler (see callbacks below). When an operation is done, its result is passed to the handler and the handler is invoked. The event loop handles all of this.

3) Callbacks
Because of Nodejs asynchronous nature, it uses a unique design pattern at its core called the callback pattern.When an operation is done, it sends the result to another function.

This pattern has pros and cons. But you are exposed to another design pattern, so it is still good for new developers to see how design patterns are used.

4) Event Emitter
The event emitter class is at the core of Nodejs. This shows the observer pattern in use. An object can notify listeners when its state changes, i.e. when a button is clicked, when user input text in a text box, etc. This is a common design pattern used in many programming frameworks and platforms.

Seeing how it is used in a production grade framework like Nodejs is good training for new developers.

Every platform has its own pros and cons and design principles. These are just a few I wanted to mention that are associated with Nodejs.

;TLDR;
Javascript is used in many places and it can be fun to write and use in personal projects as well as professional projects. After learning JavaScript you can definitely find a developer job to get experience as a developer. Then you can learn other languages to advance your career.

5 More Books for Full Stack Developers

Jason Shelley — Sun, 05 Dec 2021 18:38:39 +0000

The below books are not typical books you may see on reading lists for full stack developers, which is a pity since these books are extremely valuable.
I tried to stay away from “programming cookbooks” and focus more on books that focus more on concepts and implementations. For example, these five books are around security, databases, system architecture and general software development.
I hope you enjoy them as much as I do!

Security

Ted Harrington brings it home with this excellence read on application security. You may not be in security, but after reading this book, you will definitely have a different outlook on the importance of security in your own applications. It may even motivate you to get into the security field.

This one book is one I don’t see mentioned a lot. Maybe because it was published in 2011. But don’t let that date fool you. This is a must read for any serious full stack developer. Majority of the book is still extremely relevant for today. One of the creators of burpsuite (application security testing tool) is the author of the book. The sheer amount of detailed information that you will learn by reading it is amazing. You don’t have to be in security or be a pentester to understand it. It talks about real features that we build or use everyday on the web and their vulnerabilities. Guarantee after reading this book, you will definitely look at your own web applications differently.

Database

Great book for developers who work with databases. It doesn’t matter if you write SQL for applications to consume, or if you use ORMs to do it. If you work with databases, you should read this book. It’s more of a “deep dive” into databases. It explains things at a high level but well enough for you to understand how databases are structured and how they access data. You will definitely look at your SQL differently after reading this one.

Software Development

If you are a bootcamp grad, CS grad, new developer with less than 3 years, you mentor junior developers, or IT department manager this book is a must read. It’s a handbook for everything you need to know starting out that you didn’t learn in your bootcamp course, CS course, or in your first few years without a mentor.
It gives great advice on how to improve your programming skills, tech debt, working with legacy code, version control best practices, coding best practices, how to use config files and logs in your projects, testing, code reviews and much much more.
Great book!

System Architecture

If you work in an environment that uses the microservice architecture, or your team is considering it, this book is a great read. It takes you from foundation to implementation. It talks in detail about testing, monitoring and security. All three are things you may get wrong if it’s your first time working with microservices.

The Death Trap for the Solo Developer

Jason Shelley — Tue, 30 Nov 2021 17:31:51 +0000

Software development is a skill, an art that can only be mastered through years of hard work and practice. Learning from others can help the journey greatly. In work environments that have developers of different skill levels, pair programming, code review, etc. all contribute to a developer’s growth. Even experienced developers can learn from their peers.

However, sometimes if you are a solo developer at a company or on a project, it’s very easy to miss out on the advantages of working with others. It’s really easy to push code without having a formal process. After a while your project will develop tech debt, but you as a developer will also suffer too. Your motivation will suffer and more importantly, your skills will suffer. If you are a solo developer at a company for several years and you don’t challenge yourself, your skills will suffer the consequences. This is the death trap and it’s hard to escape from it.

I was a solo developer for several years at different companies at different points in my career. Focusing on the below four things helped me to stay motivated to constantly improve myself.

Refactor Code

Do not be happy just because you finished a particular feature and pushed it out to your users successfully. After a month or two (if you do not have any bugs already), go back and see if you can read your code. If you are having trouble reading it, imagine how another developer would feel reading it. Try to refactor your code. See if you can improve the performance and security of the feature.

Are you using third party libraries? Do you need to use them? Sometimes, especially in the JavaScript world, we import libraries just for one feature. (Ever imported momentjs just to use the format method?) See if you can eliminate that library by implementing the feature yourself. Obviously, you have to have balance here. Use your discretion.

Can you see a better algorithm, design pattern, or data structure to use to improve the code? Can you remove unnecessary comments, i.e. dead code? Can you add better comments to explain certain business logic?

The point is, code is never perfect the first time it’s written. Code reviews can help us to improve our code. But solo developers will have to implement their own code review process in order to reap the benefits. Having a set time to refactor code after every release can help you with that.

Test, Test, Test

You should always test your code before giving it to the end user. That’s programming 101. But as a solo developer, you might not have a tester to rely on. That means you have to be the tester. You might have to perform functional, integration, system testing and user acceptance testing.

Why is testing especially important for solo developers?
Testing helps you to stay focused on the quality of your code. It’s really easy to feel overwhelmed as a solo developer. You might have to wear several hats. This could easily affect the quality of our code. For example, we might have so many things to do in a short time. Then, we get a request to make some minor tweaks to our code to meet some change to business requirements. After we make the tweaks what should we do? Remember, we still have so many other things to do. But we still have to test, test, and test our code.

Testing holds us accountable to our code. When you test, and you see a bug, you have to fix it before giving it to the user. If we were on a team of developers, we would be held accountable for our code by other developers. Solo developers should hold the same standard if we are working alone on a project. It’s for our best interest. It keeps our skills sharp.

Testing helps you to stay focused on the quality of your code.

Documentation

Documentation is probably the least favorite part of software development. But writing documentation for our software helps us in two ways.

The first way is it helps us to think like a user. When we write code, we are thinking like a developer, but documentation is for the user. This means, we have to take our code and express it in a way that a non-technical person can understand. It gives us a different perspective and this ultimately helps us to be better developers.

The second way is it helps us to stay honest as developers.
Documentation is like a binding contract between the user requirements and our code. When we have to explain how to use the new features we implemented, we know if it really works or not. It’s really easy to push a new feature that’s half built and to tell the end user it works. But when we have to create documentation on how to actually use the new feature, especially if we include screenshots, it will help us to be honest about our code. It’s also proof that our code meets the user requirements.

Documentation is like a binding contract between the user requirements and our code.

Challenge Yourself

There are so many other things we can do to avoid the death trap of working as a solo developer in a company or on a project. These were just a few points. The point is we have to keep challenging ourselves. We have to keep improving our skills. We have to keep moving forward. Remember, if we don’t challenge ourselves, no one else will.

Developers Remember This Before Your Interview!

Jason Shelley — Sat, 20 Nov 2021 17:51:59 +0000

Interviewing can be very stressful. You may worry if you will make a good impression, or what type of test they will give you. But there are a few things to remember when you go to an interview.

The Employer’s Interview

Employers typically have a particular mindset when interviewing developers, “I am going to spend my money to pay you to render a service for me. So I want to make sure I am getting my money’s worth.” In other words, they want to make sure you are a worthwhile investment, or that you bring value to the company. Because many employers (not all) think like this, they typically use the interview process as a way to determine a developer’s value. You will meet with various people, answer questions both personal and technical, take coding challenges, and build an app. Some companies even have personality tests. A company has the right to have all these things in the interview. After all, it is their money.

But the exact opposite is true too! Developers should have a similar mindset when going to any interview. “I am going to spend my time rendering a service to you. I want to make sure my time is well spent and well compensated.” Here is why developers should think this way.

Time vs Money

Time is more valuable than money. You can have all the money in the world, but if you don’t have time to spend it or enjoy it with your loved ones, then the money is pointless.

As a developer, our time is valuable. We spend our time with our families, our friends, learning new skills, enjoying hobbies, and handling our responsibilities. Our time only becomes more valuable as we get older.

We don’t have the time to waste on pointless interviews. When you go to an interview, the employer is being interviewed just as much as you are. You need to make sure that the job will compensate you for your skills and that it will allow you to grow as a developer.

Employers are checking to see if we have the right skills for the job. Developers should check if the employer has the right environment for us to grow.

Thus, developers should interview the employer.

The Developer’s Interview

Developers should have a list of questions ready to ask the employer. Some examples are:

How many developers are on the team?
What is the personality of the team, are they fun and laid back or serious?
What type of source control do you use?
Do you have a code review process?
Do you have peer programming?
How do you encourage or help your developers to continue to grow?
How do you help your developers have a healthy work-life balance?
Walk me through a typical day at the office
Can I see an example of user requirements?
How many sprints do you cover in a quarter?
Does the IT department have its own budget?
How do you track bugs?

There’s nothing wrong with asking questions like these in an interview. You are investing your time in this company. Invest wisely!

New developers definitely have to learn this way of thinking. Just because you are new in the field doesn’t mean you have to accept any job. Find a job that will compensate you and will allow you to grow. If the job doesn’t meet these two criteria, do not waste your precious time.

Our time only becomes more valuable as we get older. We have to invest it wisely. Invest it in learning and improving yourself. Improve your programming skills. Improve your thinking ability. Improve your personality. These are skills that make us more valuable. Do not waste your time on a company with a toxic environment or an environment where you cannot learn and grow.

Signs of a Pointless Interview

If you see a job that lists every skill under the sun, beware this interview will most likely waste your time. If you see a job posting like the below for a front end position but it lists NON front end skills, it’s probably not worth your time.

What You Bring to the Team
SQL
DevOps
Building APIs
React
Typescript
CSS

BS in Computer Science or equivalent and 5 years of experience
Accredited Full Stack Web Certification and 6 years of experience
This is from a real job posting for a front end position. This company wants you to know DevOps?! And what is Full Stack Web Certification, isn’t this position for a front end developer? Is a full stack developer stronger than a front end developer? Not necessarily. A full stack developer could be stronger on the backend but suffer on the front end. They didn’t even list HTML and JavaScript (knowing React doesn’t mean you know JavaScript). Job descriptions like this give you a view into the company. A company like this doesn’t know what their developers do, or they expect too much out of their developers. Front end is front end, backend is backend. The job description should be clearer. If they want someone who knows both, they should ask for a full stack developer. Companies that do not have clear job postings are an indication of communication issues.

;TLDR;
Going to an interview certainly can be stressful. But remembering that you can also interview the employer will help alleviate some of the stress. During your interview process make sure to see if the company can bring value to your career. If not, find a company that will. Invest in your future!

How to Improve Your Coding Skills for Free

Jason Shelley — Sun, 14 Nov 2021 20:00:29 +0000

It is amazing how many people have join the ranks of coders over the last few years. Whether you are a professional coder or just code for fun, learning this skill will definitely change your outlook on life and how you think.

With the advent of online tutorials, bootcamps, YouTube videos and blogs, learning the basics of coding is extremely easy.

However, some of these resources are limited in what they offer. Sure, you can learn theory, algorithms, data structures, etc. But if new developers would like to improve certain skills, for example, how to structure a large application, how to create performant and secure code, how to create test cases, log and fix bugs, documentation, communication with other team members, etc they need to get their hands wet. One of the best ways to do this is to join an open source project.

For many new developers though, joining an open source project seems daunting. They may feel they do not have the skills to contribute, and such fears are understandable. I could spend the rest of this article explaining why they shouldn't let fear stop them from joining an open source project, but instead I will offer another solution.

Another Free Alternative

Many articles talk about how to use GitHub, Gutbucket, Gitlab, or a similar open source repository to upload your code. Many of these articles fail to help new developers to see the rich and vast amount of information these free repositories have to offer to new developers.

We will use GitHub as an example. You can create a free account using your email address. You can search, download, read through and play with code that experienced developers have created and uploaded for other people to use.

What are the benefits?

Many of these repositories are real, live code that thousands of people use everyday. You will learn valuable lessons on how to structure code, how to use code to tackle a problem, proper documentation, proper testing, logging and resolving bugs, how to commit code with proper commit messages, how to structure branches and releases, how to use CI/CD (if the repo is using it), how to write performant code, how to write secure code, etc.
You can learn so much from these projects. You can learn at your own pace. And this is a free method to improve your coding skills.
The main point is you do not need to join an open source project to improve your coding skills. You are welcome to download the code, read it, run it, play with it, and learn from it.
Build your skills. Build your knowledge. Build your confidence.

How to do it?

Most popular projects will have a Readme file, an example folder, a test folder and a src folder. "src" is short for source, and this is where the bulk of the code can be found.
First, read the Readme file to understand the purpose of the project and how to set up everything. Next, take a look at the example folder. Usually the examples are simple so it will be easy to understand the code. Play around with the examples. This will also help you later when you are looking in the src folder. Finally, take a look at the tests. Run them and see if you understand what's happening. See if you can write your own test case following their format. Obviously, a big project will have comprehensive test cases. But still this is good training.

Just as reading books can open your mind to the world around you. Reading open source code will open your mind to the world of software development.

Should You Learn Deno in 2022?

Jason Shelley — Tue, 09 Nov 2021 05:59:42 +0000

If you are a JavaScript developer, perhaps you have heard of a new JavaScript runtime called Deno. Like me, you probably thought: “Oh no! Here we go again. Is this going to be another Nodejs vs io.js fiasco or npm vs yarn battle.” You might even have thought: “Yet another tool in the JavaScript ecosystem to make our lives miserable.” After all, JavaScript has a history of making developers feel exhausted. Is Deno going to be another reason for developers to dislike JavaScript?

The short answer is No. In fact, it’s the exact opposite. You should definitely learn Deno in 2022. If you want to know why, continue to read this article. If you are already convinced, great! Head over to the Deno website and start learning it for 2022.

Just Another Shiny Tool?

First off, let’s get this out of the way. Deno IS NOT just a new shiny tool for JavaScript. It solves real problems that JavaScript developers face and it offers real productive tools that can help JavaScript developers in our development process.

What is Deno?

The official Deno website said:

Deno (/ˈdiːnoʊ/, pronounced dee-no) is a JavaScript/TypeScript runtime with secure defaults and a great developer experience.

For any Nodejs developer, this explanation alone should make us excited. First, Deno is a JavaScript/TypeScript runtime. Let me repeat, Deno is a JavaScript/TypeScript runtime. It supports Typescript right out of the box! There is no need to download another tool or some transpiler to run your code. Deno treats these languages “pretty equally”.

The command to run JavaScript files is:

deno run YourFile.js

The command to run TypeScript files is also:

deno run YourFile.ts

You can even have files in both languages in your project. This allows developers to be extremely productive. TypeScript is extremely popular and useful in the development process. It helps developers create more clean, efficient and safe code. The Deno runtime offer this feature without any extra work from the developer. This allows developers to focus on building solutions instead of fiddling around with config files.

“…a runtime with secure defaults”.

You have to explicitly set the permissions for your script if you want it to have file, network or environment access. This means when you use a third party package, you will know what that script will access. This is really useful from a security perspective. For example, if you import a third party package named StringValidator and it wants access to the internet, you may want to double check to see what this package is really doing.

Deno can import modules from any location on the web. You also have the option to import your modules from the Deno hosting service, deno.land/x. If you do, you are guaranteed that the module will be there. Because all uploaded module versions are immutable, to prevent breaking programs that rely on them. If you start using a newer version of the module, and find there are security risks, you can easily revert back to the previous version without worrying.

“..a great developer experience”.

What would make Deno a better developer experience than Nodejs?

It’s web compatible. This means your Javascript knowledge that you learned from writing front end apps on FireFox, Chrome, Edge, etc is transferable to Deno. You can use Fetch, Web Workers, Web Storage, Blob, FormData, WebSocket, even Web Assembly and much much more. That’s less third party modules you have to worry about, bye-bye axios.
It has built-in utilities to make development easier. For example,

Linter (deno lint)
Bundler (deno bundler)
Test runner (deno test)
Code Formatter (deno formatter)
Dependency Inspector (deno info)
Documentation Generator (deno doc)

These are not “nice to have” tools. These are necessary tools. When developers see the runtime they are using provides these tools without any extra crazy annoying configuration, it builds their confidence in the runtime and in their ability to use the language better.

Deno also provides built-in modules that are supported by the Deno team. These modules are very useful for everyday programming tasks. For example, Collection module has functions to work with collections like groupBy, partition, union. DateTime module has functions to deal with dates. It also has a module to allow us to use Nodejs modules that do not use non-polyfilled Node APIs.

These are just some of the features that make Deno compelling to learn. But we still haven’t talked about: how Deno handles package management, how Deno handles promises, extending Deno with Rust plugins, Deno Deploy (a serverless solution allowing users to quickly script distributed HTTPS servers) and even compiling your scripts into a self-contained executables!!
Deno looks promising. It has a team of developers and investors to push it to the next level. 2022 is definitely going to be an exciting year for it. Even if it doesn’t replace Nodejs, it will definitely push everyone to a better JavaScript ecosystem.

3 Skills Developers Must Have

Jason Shelley — Mon, 08 Nov 2021 15:51:25 +0000

As a developer, there are certain skills that are needed and then there are certain skills that are a must.

For example, a developer needs to know essential computer science concepts like algorithms and data structures. They also need to know source control, networking basics, database basics, text editors like Visual Studio Code, VIM, Atom, etc. Of course, developers also needs to know the language they are using and they need to know it well.

This list is not an exhaustive list. But this list is pretty standard, regardless the programming language you are using and the type of developer you are, i.e. web developer, software engineer, mobile developer, etc.

But there is a second list of skills that a developer must have. They are debugging, testing and code reading skills.

Debugging

Have you ever heard a developer say: “Finally it works! I have been staring at this code for hours and it turned out to be a silly mistake!” Perhaps you have even said this yourself once or twice. What is the problem here?

Our code does not always do what we expected it to do. When that happens we need to figure out what is happening. To effectively do this we need to make use of the debugger. For many developers, debugging means writing a bunch of console write lines to see what is being produced. This is not debugging!

Debugging means to use a debugging tool to run the code step by step in order to find the exact point of the mistake.

It is a skill to know how to use a debugger correctly, effectively, and efficiently. No one is going to teach you how to debug. In fact, many software courses barely touch on the subject. You have to learn by yourself. Learn what a breakpoint is, a conditional breakpoint, inline breakpoint, how to inspect a variable during debugging, remote debugging, etc. Do not wait until your code has bugs before learning how to use the debugger. Sit down, write some code and step through it to see what happens. Read the debugger documentation. For example, Visual Studio code (VS code) has a built-in debugger for JavaScript. It also has support for debuggers in other languages like Python, C/C++, C# Java, etc. Visit VS code website to learn more about using the debugger.

Once you becomes proficient in using a debugger, you will save loads of time and become a better developer. You will also be able to help others find and squash their bugs faster.

Testing

Testing is an extremely important step to make sure our software is bug free before releasing.

A developer should be familiar with several different testing methods. For example, unit testing, integration testing, and system testing, to name a few. There are many frameworks out there to help us, we just have to use them.

It takes time and patience to learn how to test your code. Many developers may feel testing is not important or that it is a waste of time, especially if they are the sole developer at their company. But it is important. A smart developer will take the needed time to learn this skill and become proficient at it.

Debugging is for the developer. With it, we save our time and reduce stress while we code.

Testing is for the user. With it, we save them time and reduce their stress while they use our software.

Debugging saves time, testing requires time. But the result is better software.

Increase code reading skills

This is a skill that hardly ever makes the list of needed skills for developers. This skill is a must because we have to read our own code when we debug, but we also have to read other developers’ code.

If a developer can’t read other developers’ code, they will waste a lot of time and constantly feel frustrated. Eventually they will just give up and decide to “rewrite the whole thing”.

Take the time to improve your code reading skills. Do coding challenges like TopCoder or Codewars. Here is a list of other coding challenges. Go to GitHub and read code repos. Actively participate in code reviews at your company.

Future benefits

While many job applications will not list these skills (at least not debugging and code reading skills) these skills are definitely required when taking a coding challenge on the job interview. Honing these skills will definitely help you to land the job or at least put you at the top of the list.