Category: Careers

Being a developer is hard. Not only do we have to know technical skills, but we also have lots of soft skills that we’ve to get good at.

In this article, we’ll look at the ways that we can get better as developers.

Reassess Our Workflow

Reassessing our workflow often helps us find better ways to work. We should adopt them to the situation to suit our needs in the short term.

Working From Home

Working from home takes discipline. We got to do the work by removing temptations and distractions like televisions, social media, and many other things that can distract us at home.

This may be hard. But it’ll definitely help us to get things done at home, which helps us survive in our jobs or if we’re working for ourselves.

Code for Accessibility

When we’re writing our code, we should be considerate of users that may not be able to do all the things that healthy people can do.

Therefore, we should think about accessibility when we’re writing our code so that they can enjoy our production the same way that anyone else can do.

Honor Our Commitments

If we commit to something then we should deliver them by the date we committed to.

Otherwise, if we fall behind, we should update everyone so that they’ll all adjust their expectations.

Be Proactive

Helping others when we have time is always a good idea. They’ll all be thankful if we help them.

Build a Portfolio and Online Presence

A portfolio is a great way to promote ourselves. We may not need it now, but it can get us extra opportunities if we don’t need them and if we need to get a new job, then they’ll help us even more.

Also, we should all have a public online persona so that people know that we exist on the Internet.

Today’s world isn’t just confined to where we live, and opportunities can come from anywhere.

Therefore, we should take advantage of that so that we can get opportunities wherever they’re from.

Remember Why We Love Programming

We got to remember whey we love programming so that we don’t get discouraged when we’re going through tough times.

Take a break if we’re building negative feelings. We got to think as to why we got into programming in the first place so we can reignite our passion.

Share Our Knowledge

Sharing our knowledge anywhere including meetups, conferences and online are a great idea.

Teaching our knowledge help others so they can share it with others. It doesn’t only help the people we’re directly teaching, but a lot more other people that the people we taught are teaching.

Recognize Our Weaknesses

We should recognize our weaknesses so that we can learn things to improve our weaknesses.

It’s important that we improve them so that we get better in the future.

Thinking about The Big Picture

Thinking about the big picture is always needed. Most systems that people use are big so that we have to know about the big picture even though we only work on a part of it.

There’re are a few parts that we have to think of to build the big picture. There’s the business side which we have to meet the needs of.

There’s the users’ side which actually provides the features that users need.

Then there’s the technology which we use to build the whole solution. We have to know how each part interacts so that we can work with them easily.

Develop Quickly

We got to able to create the correct code quickly so that we can deliver our stuff. This got to come with experience.

Every code base is different so that when we move on to a new company, we got to learn everything from scratch again about their codebase so we can develop quickly again.

Find the Ideal Solution

The ideal solution should be found before coding. We got to think from the users’ perspective and all the ways that our solutions could fail.

We probably need another person to help us find our flaws if the feature is complex.

Conclusion

We got to think about the user and stakeholder when we’re writing. This means that we should honor our commits and update them if we can’t.

Also, we should get the big picture so our solutions won’t do things that are unintentional.

Finally, when times are tough, we should remind ourselves whey we like programming.

Getting a job that fits us is hard. Therefore, we should do our due diligence and ask some questions before so that we know if the job is good or not.

In this article, we’ll look at some questions we should as interviews in an interview to see if the company we’re interviewing for is a good fit.

What’s the Process for Managing Code?

We should ask this to see how code is managed.

Things that we should definitely hear are things like version control. Ideally, it’s done with Git so that we can have both remote and local repositories.

If there’s no version control, that’s definitely no good. If it’s in some centralized system in some office, then we might want to think twice if we want to work from at least part-time.

It’s also possible that proprietary software is used which probably isn’t ideal.

Having automated pipelines for building and deployment are good. Otherwise, the job is probably going to be miserable if we have to do manual builds and deployments since it’s so risky and error-prone.

The stress level of everyone involved will go through the roof if the code is built and deployed manually.

How Long are Typical Sprints?

That’s more of a preference for us. If we want a more relaxing job, then longer sprints are good.

If we want a fast-paced environment, then shorter ones are better.

In either case, we just have to take a pick and see what we like better.

How Many Developers are on the Team?

Ideally, we want to have smaller teams since big teams have big meetings and more communication overhead.

We don’t want to have too many big and long meetings getting in our way. That’ll make anyone miserable in the long run.

However, larger teams will probably have more people to learn from and share knowledge.

Are There Any Offsite Travel Required?

This is another question for us to gauge our fit for a company.

If we love business travel, then we can go for a job with travel. Otherwise, we pick ones that don’t need to travel to do our job.

Do Developers Have Time to Learn on the Job?

Learning is always important and it’s ideal that we get time to learn on the job.

If they do give us time to learn on the job, then that means they care about our growth. They’re paying money for us to learn on the job.

Otherwise, they probably don’t care about our own growth that much and that may reflect on the company’s willingness to retain employees.

How Much Vacation Days Do We Get?

Vacation days are important. Either we can bring it up in the interview or we can bring it up when the offer is received. Either way, we’ve to know that so we can know how long we can take vacations for and still get paid.

The company should be able to have someone fill in for us so that we can have vacations. This is important since we don’t want to think about work when we’re on vacation.

What Are The Processes for Emergency?

Bad things like bad deploys or corrupting data can happen.

Therefore, we should make sure that the company that we may work for has processes to handle those situations.

We should be able to revert bad deploys quickly. Also, we should have lots of downtimes to fix these kinds of issues.

Also, database backups are very important so that we can recover from the in case there’re any issues with the data.

What Technology is the Company Currently Using?

This question may be something that we want to ask if we have any preferences in the technology we want to use.

Ideally, we learn that from the job description, but we should make sure what portion of the system uses those technologies.

Job descriptions probably don’t have such a detail breakdown on how the technologies are used in their systems, so it’s worth asking this.

Conclusion

An interview is a 2-way street, so we should ask questions that’ll help us gauge our affinity for a job or team so that we can be sure that we’ll actually like working there if we get an offer.

If you want to become a successful developer, you have to learn more than writing code to become successful.

In this article, we’ll look at some technical skills that you need to become a successful developer.

Networking

Most apps in the world don’t work in isolation. Instead, they communicate with other computers via networks, with the Internet being most common.

To learn about internet communication, we have to learn about the HTTP protocol thoroughly.

HTTP is the main protocol for communicating over the Internet. We have to learn about GET, POST, PUT, and DELETE requests and how they’re related to database operations.

They represent read, create, update and delete operations in databases respectively.

Also, we have to learn about request and response headers and what kind of data they can contain.

Lots of times we have to make authenticated requests so we have to learn about how to make authenticated to different servers with OAuth and API tokens.

To transmit data, we often use a standardized format to do that. Oftentimes, we transmit and receive data in JSON format.

Also, we have to learn how to transmit files with other data in HTTP requests with form data.

To do real-time communication, we have to learn about WebSockets. They let us send data back and forth between different computers in real-time instead of making requests individually.

Automated Testing

We’ve to learn about automated testing so that we can write tests to make sure our program is working after we made changes to it.

There’re a few kinds of tests, including unit tests and GUI tests. Unit tests test small parts of our program in our code like individual functions or classes.

GUI tests actual test our program like a real user by manipulating our program within a browser or the operating system.

GUI tests are end to end tests that test the whole system.

There’re also integration tests that test a bigger part of a system than a unit test but smaller than the end-to-end GUI test.

Integration test tests parts of a program like unit tests but may include actions like database manipulation that’s not done with unit tests.

Tests are run in test runners like Jest for JavaScript and JUnit for Java, so we have to learn how to use them to run our tests as well.

Cross-Platform Compatibility

Cross-platform compatibility is important for any apps. For web apps, we have to make sure that they work in the most popular browsers.

Also, many apps also have to be compatible with mobile so that we should use to make sure that it looks good on mobile if our apps have to work on mobile.

To make them work on all platforms, we have to make them responsive, which means that the styles adapt to the size of the screen appropriately.

Security

We’ve to learn about security issues with apps and common attacks like code injection, cross-site scripting, cross-site request forgery, etc.

Also, we’ve to learn about cryptography so that we can store secrets securely.

Code injection is where we let attackers run code in our system by providing places for them to run malicious code.

Cross-site scripting is code injection attacks on the front end, where attacks can inject their own scripts and run them with our apps.

Cross-site request forgery is where attackers make unauthorized requests as if they’re an authorized user.

With cryptography, we have to learn about symmetric and asymmetric cryptography. With asymmetric crypto, we have to learn about how to generate private and public keys.

Software Development Life Cycle

Since we’re working on developing software, we’ve to learn about the software development life cycle so that we can get used to the development process faster. The cycle consists of the following:

1. Requirement gathering
2. Feasibility study
3. Design
4. Implementation / coding
5. Testing
6. Deployment
7. Maintenance

Conclusion

Networking is important because apps communicate with other apps and APIs via some network.

Also, we have to learn about testing so that we can make sure our apps work after our changes.

Security is also important since attackers will take any chance that they can attack our systems.

Finally, the software development lifecycle must be learned so we can get used to the process.

If you want to become a JavaScript developer, we just have to do a few simple steps.

They’re simple, but that doesn’t mean they’re easy. In this article, we’ll look at how we can all become good JavaScript developers.

Start With the Basics

We got to learn the good parts of JavaScript, which includes many basic building blocks that we need to build good JavaScript programs.

Now it’s a great time to learn JavaScript since a lot of the good parts are added in the last few years. We can do a lot with the good parts of JavaScript.

The basics include defining and using variables, defining and using strings, array manipulation, and functions.

Those are the building blocks of JavaScript. Since 2015, the features that are added are good.

We can declare variables with let and const . Strings are used everywhere to store text.

The basics also include the use of operators to do arithmetic and assigning values to variables.

They include operators like add, subtract, multiply, divide and assignment. String concatenation is also an important operator to learn, even though it’s been replaced by template string in a lot of cases. This means that template strings are also important since they make our code cleaner.

Arrays and Loops

Arrays are used to store lists of data. We should use to learn the array methods thoroughly and use them. This is to minimize the use of loops.

However, loops are still very useful, so we should use them. Loops let us traverse through lists of data when array methods aren’t adequate.

Objects, Constructors, and Classes

To store data in an organized way, we should use objects. This way, we can group variables as properties of an object.

We should also learn about all the ways that objects can be created. This includes object literals and constructor functions/classes.

Object literals are the process of creating objects outright without calling a constructor or a class.

Constructors are functions that returns objects that have the same members, including instance variables and methods and static methods.

There’re no private variables in JavaScript constructors right now, but they’re being planned.

Also, we should know the instance methods are properties of the prototype property of a constructor. They’re called on the object when we need to call instance methods.

A prototype is template objects that an object inherits from. Most objects inherit from objects.

If we’re going top create constructors, we should use the class syntax. It makes our constructor look more like a regular class, even though it doesn’t act like a regular class underneath.

It adds more error checking to the constructor code we create so we won’t make mistakes as easily as with the old constructor function syntax.

This part definitely trips people up if we’re used to class-based object-oriented languages.

Functional programming

Functional programming concepts are applied throughout the JavaScript language.

For instance, higher-order functions are used everywhere. They’re used in many array methods like map and reduce , which takes a callback function that’s called when we try to get new results from an existing array.

Also, callbacks are used a lot for asynchronous programming, which is required for making any nontrivial JavaScript program since they need to call callbacks so that the program won’t hold up other parts of a program from running.

We need asynchronously code a lot since JavaScript is a single-threaded language, so we callbacks to run code later in an indeterminate amount of time.

Asynchronous Programming

As we mentioned above, we use callbacks a lot for asynchronous programming. To make async programming cleaner, we use promises to avoid nesting callbacks.

To make promises cleaner, we use the async and await syntax to make things even cleaner.

Therefore, we should learn the syntax to write some clean async code.

Testing

Automated testing is important since we don’t have time to check every part of our program all the time. Therefore, we should write tests to do this for us.

To do that, we should write tests and use test runners like Jest to run them. This way, we know that our app is still working properly.

Conclusion

The basic knowledge for becoming a good developer is a lot. First, we have to learn toe basics, then we have to get to think like async programming, functional programming, and automated tests.

Practice them all and we all can become good JavaScript developers.

Being a developer is hard. Not only we have to know technical skills, but we also have lots of soft skills that we’ve to get good at.

In this article, we’ll look at some ways that we can all become greater programmers.

Take Vacations

No one should feel guilty for taking a vacation. If we’re somewhat useful for our company and the company’s finance are good, we can probably stay.

Otherwise, it probably a good company to work for.

We all need a break so that we can recharge and do work with a fresh mind, which is faster and better than with a tired brain.

Take Breaks During the Day

Taking breaks during the day is important. Take walks and lunch breaks are definitely things that we should be doing during the day.

It’s just not good working the whole day without taking a break.

Track Our Progress

We’ve to get organized so that we can work faster. One way to organize ourselves is to track the progress of our tasks.

It feels good to see some progress during the day. Keeping achievements and progress visible to us is encouraging and makes us keeps going in the long term.

Don’t Be a One-Trick Pony

Learning multiple frameworks and libraries is important since we don’t how they’ll last or how long we’ll at the company that uses those frameworks or libraries.

If we learn more now, then we’ll know them before we need them in our current or next job.

Review Code

Reviewing other people’s code and letting people review our code will make us wiser.

Either way, it’ll expose us to other people’s styles and so we can learn something that we don’t know from them.

Other people that review our code will give us suggestions for us to improve. So either way, we’ll know things that we don’t before after code reviews.

Learn About Design and Marketing

Design and marketing are important parts of the business. Without marketing, there are no sales, and no sales mean no business.

Knowing design skills lets us empathize more with customers’ needs and help us do a better job when we’re working on user interfaces for users since will consider user experience before anything.

It’ll also make our user interfaces more polished than before.

Learn About Technical Skills That We Don’t Work With Regularly

At least learn a bit of the skill that we don’t work with often so we can work with them if we’re asked.

It just makes us more useful than people that don’t know the skills.

Choose the Right Technology for the Project

Choosing the right technology for the project is important even though it might not be the one that we’re most comfortable working with.

We should pick the right one for the project so that we won’t run into problems down the road if we try to fit a square peg into a round hole.

Own Our Mistakes

We should own our mistakes and not blame others for our own wrongdoing.

It just makes people like us more not to point fingers, and it also builds trust among employees.

Review Our Own Code

Reviewing our own code is important for us to improve. We should think if we’re doing things properly and what comments would other people make if they see our code.

This way, we’ll have to make fewer changes later when someone actually reviews our code. It’s much better not to have too much back and forth.

Learning From Failures

Learning from failures will help us get better. We should think of ways to improve after something failed.

Then we can do differently next time and not make the same mistake.

Stay Curious

We should keep updating ourselves on new things since the computer industry changes all the time.

People are always making new hardware and software that may help us with our work.

Also, we can ask questions if we aren’t clear about something.

Conclusion

We got to keep learning from other people’s work and suggestions so that we can improve. Also, we should learn from our mistakes and failure so that we can keep improving ourselves.

Other skills that we don’t work with should also be learned so that we can get better and use them in case we need them in the future.