Forem: Erica V

All about unit testing: 11 best practices and overview

Erica V — Tue, 19 Apr 2022 23:32:52 +0000

Unit testing is one of the primary types of software testing. As is generally the case with software testing, unit testing can’t guarantee that no bugs will occur after your application is deployed. However, by testing the smallest repeatable pieces of code in your applications, unit testing helps catch bugs in the building blocks of your project before they affect your integrated application.

As an essential software development process, unit testing is a valuable skill to know as a developer. If we’re able to follow unit testing best practices, we’d already be unit testing during the development phase. However, this isn’t realistic for all software development projects. Therefore, unit testing can happen after your production code is written, and is essential to ensure that extended and refactored code remains functional.

Today, we’ll cover an overview on unit testing and unit testing best practices.

We’ll cover:

An overview of unit testing
- What is unit testing?
- Benefits of unit testing
- Test planning
- Test coverage
- Unit testing frameworks
11 unit testing best practices
Wrapping up and next steps

An overview of unit testing

What is unit testing?

Unit testing ensures that the units within your program are working as expected. Since the person who wrote a piece of code would have the greatest insight as to its expected behavior, it’s usually the developer’s responsibility to unit test. In combination with end-to-end tests and integration tests, unit testing helps ensure code quality early on in the development process.

A unit is the smallest piece of code in your program that is repeatable, testable, and functional. Units can be functions, classes, methods, and so on.

The previous figure depicts unit testing alongside other software testing levels, wherein each level has its own scope:

Unit testing tests each software module.
Integration testing tests the combined modules according to system design documents and functional requirements.
Functional testing tests a program’s desired functionality based on requirement analysis documents and the user manual (i.e. ensuring the expected output for a given input). This is sometimes divided into system testing and acceptance testing.

Black box and white box testing are two approaches to software tests, wherein:

Black box testing tests software behavior without knowing the implementation details of a software module. These tests are derived from the software specification document.
White box testing tests the actual implementation of a software module., wherein the inner architecture of the program is known to the tester. These tests give us implementation insights to develop more comprehensive tests.

For unit testing, white box testing is usually the most suitable option, particularly when our modules are smaller and their code is easier to comprehend. On the other hand, black box testing is a good option for later stages of a project, when modules have been integrated to create a complex software.

Benefits of unit testing

Some benefits of unit testing include:

Simplifies debugging: By testing the functionality of small units, you can catch bugs before they affect more units in the integrated application.
Encourages more loosely coupled code: By intentionally reducing interdependencies between units, we get more loosely coupled code, a coding best practice.
Faster than functional testing: As units are very small, you can run several unit tests in seconds (provided you’ve automated them).
Minimize code regression: After code is refactored or extended, you can rerun all test suites to ensure your new or updated code doesn’t break existing functionality.
Better code coverage: By breaking an application down into the smallest testable components, unit testing helps increase your code coverage.

Test planning

A test plan dictates a unit test’s complexity and design. Because we have limited time and budget for any development project, it’s not always possible to exhaustively unit test a project. Taking this into consideration, a test plan will determine which resources will be allocated to unit testing. A test plan is one of the key parts of the software development lifecycle.

Test coverage

Test coverage is a metric to determine how thoroughly we've unit tested our software. As a general rule, we want to maximize test coverage as much as possible.

Test coverage can be further classified as follows:

Function coverage: The percentage of functions which have been tested
Statement coverage: The percentage of statements that have been tested. Sometimes, it includes all the statements that have been executed at least once during the testing.
Path coverage: The percentage of paths that have been tested. A software may have multiple paths (or branches) taken by it based on conditions, such as, user’s input, environment sensing, and other events.

Unit testing frameworks

A unit testing framework is software that enables us to quickly code unit tests and automate their execution. In the event that a test fails, frameworks can save the results or throw an assertion.

There are dozens of unit testing frameworks available for various programming languages. Some popular unit testing frameworks include Cunit, Moq, Cucumber, Selenium, Embunit, Sass True, HtmlUnit, and JUnit (one of the most widely used open source frameworks for the Java programming language).

We can save a great amount of time and resources with unit testing frameworks, which include the following features:

Test suite: A set of test cases that are grouped for test execution purposes, which allows us to aggregate multiple similar unit tests.
Test runner: A component which automates execution of a series of test cases and returns the test result to the user.
Test fixture: A predefined state or fixed environment in which we run tests, ensuring that our tests are repeatable across multiple test runs.

11 unit testing best practices

1. Write tests for a number of scenarios

When writing a test case, be sure that you’re considering all possible scenarios. In other words, don’t just write a test for the happy path. Think about other scenarios as well, such as error handling.

2. Write good test names

A good unit test name should explicitly reflect the intent of the test case. Follow consistent naming conventions, and only use shorthand if they’re easily understood by a reader.
Writing good test names supports code readability, which will make it easier for yourself and others to extend that code into the future.

3. Set up automated tests

Opt for automated unit testing with the help of a unit testing framework. An even better practice is automating tests in your continuous integration (CI/CD) pipeline.

The alternative to automated testing is manual testing, wherein we manually execute test cases and gather their results. As you can imagine, manually testing small units is incredibly tedious. It’s also less reliable. Automated tests are surely the way to go here.

4. Write deterministic tests

False positives and negatives are common in software testing, and we must be diligent in order to minimize them. The goal is to have consistent outputs for tests in order to verify the desired function. Unit tests should therefore be deterministic. In other words, as long as the test code isn’t changed, a deterministic test should have consistent behavior every time the test is run.

5. Arrange, Act, and Assert (AAA)

The AAA protocol is a recommended approach for structuring unit tests. As a unit testing best practice, it improves your test's readability by giving it a logical flow. AAA is sometimes referred to as the “Given/When/Then” protocol.

You can use the AAA protocol to structure your unit tests with the following steps:

Arrange: Arrange the setup and initialization for the test
Act: Act on the unit for the given test
Assert: Assert or verify the outcome

The following code demonstrates the AAA structure in testing the absolute value function in Python:

def test_abs_for_a_negative_number():

  # Arrange
  negative = -2

  # Act
  answer = abs(negative)

  # Assert
  assert answer == 2

6. Write tests before or during development

Test-driven development (TDD) is a software development process through which we enhance our test cases and software code in parallel. In contrast to a typical development methodology, TDD involves writing test code before production code. TDD has several advantages, including increasing the code coverage of unit tests.

The process of TDD looks as follows:

Develop a unit test for a desired feature
Write the shortest possible code to pass that newly created test
When the test passes, refactor your code to improve maintainability and readability
If another feature is needed, repeat this process

The following figure illustrates the TDD development process:

7. One use case per unit test

Each test should focus on a single use case, and verify the output is as expected for that tested method. By focusing on one use case, you’ll have a clearer line of sight into the root problem in the event that a test fails (as opposed to testing for multiple use cases).

8. Avoid logic in tests

To reduce the chance of bugs, your test code should have little to no logical conditions or manual string concatenations.

9. Reduce test dependencies

Tests should not be dependent on each other. By reducing dependencies between units, test runners can simultaneously run tests on different pieces of code.
A unit can be considered testable only if its dependencies are staged (i.e. stubs) within the test code. No real-world or external dependencies should affect the outcome of the test.

10. Aim for maximum test coverage

While we can aim for 100% test coverage, this might not be always desirable or possible. Such comprehensive testing may have budget and time requirements beyond our ability. In some cases, such comprehensive testing is theoretically impossible (i.e. undecidable). That being said, we should aim for the most possible coverage given our constraints.

11. Keep proper test documentation

Maintaining test documentation will help both developers and, in some cases, the end users (e.g. in the case of an API).

Testing documentation should fulfill the following criteria:

Reviewable: A test by any given resource is reviewable by others.
Repeatable: A test is documented such that it can be repeated multiple times. This enables us to verify that a bug is fixed in an updated piece of code by repeating the same test.
Archivable: Tests and related bugs can be archived in documentation, serving as a valuable resource for future extensions of the project.

Wrapping up and next steps

Wherever you are in your coding journey, learning to unit test will ensure that you can check your balances in the applications that you develop. In some companies, unit testing is taken care of by quality assurance (QA) engineers, but for the rest, software developers are responsible for mastering this craft. By validating your code as you write it, unit testing is invaluable in ensuring your development project comes together with minimal bugs. If it seems like a tedious task to test your application on a small scale of units, remember that you have various testing frameworks at your disposal to streamline the process!

One of the most popular unit testing frameworks is JUnit.
If you work with Java, you might consider diving into unit testing with our course, Pragmatic Unit Testing in Java 8 with JUnit 5. JUnit is one of the most popular unit testing frameworks. You can use JUnit to write test methods with special directives, automate test executions with test runners, indicate test failures with different assertions, and record your test results. This course includes tutorials and all the information you need to leverage JUnit to efficiently test and develop your Java applications.

Happy learning!

Continue learning about software testing on Educative

Start a discussion

How do you do unit testing? Was this article helpful? Let us know in the comments below!

3 philosophies that influenced software development

Erica V — Fri, 15 Apr 2022 20:27:43 +0000

I started my undergraduate studies by pursuing a double major in philosophy and mathematics. While people often remarked that these subjects were complete opposites, this couldn’t be further from the truth. Philosophy is not only linked to math and sciences – it’s their ancestor. Philosophy has had a profound impact on most scientific fields, and computer science is no exception.

A philosophy is a way of thinking that determines how we understand ourselves, the world, or the right thing to do. Much like a program, a philosophy is composed of a set of premises and principles that determine how we handle events. Whether or not we’re aware of it, there’s a philosophy driving everything we do – from the way we honor history, to the way we develop software.

Today we’ll discuss three philosophies that have influenced software development, in ways big and small.

We’ll cover:

A bit of history
3 philosophies that influenced software development
- Open-source philosophy
- Minimalism
- Kaizen
Wrapping up and next steps

A bit of history

Before our discussion, I want to address one of philosophy’s most obvious and important contributions to computer science. Namely, our earliest binary representation of data came from a branch of philosophy called logic. Specifically, Boolean logic provided the framework through which we represent data in binary digits (0s and 1s). These binary digits are called bits in computer science. Bits are our tiniest units of data, and are the building blocks through which we animate lifeless hardware into functional machines.

Boolean logic was developed by George Boole in the 1850s. A mathematician and philosopher, Boole was building upon the findings of his predecessors. The hardware to physically realize these bits came much later thanks to findings in quantum physics. Still, Boolean logic was a breakthrough that’s often credited for transitioning us into the Information Age.

3 philosophies that influenced software development

Minimalism

From decluttering to software development, minimalism has had a widespread impact on many areas of our lives. While the term “minimalism” was first coined to describe a post-WWII Western art movement, the term found itself applied in various contexts where there was a benefit to doing more with less.

Generally, minimalist philosophies value:

Simplicity
Utility
Doing away with the unnecessary

Minimalism worked its way into software development in the 1970’s. In these early days of programming, developers worked to optimize programs within the constraints of limited hardware resources and budget. While our hardware capabilities and budgets have certainly grown since then, minimalism remains an influence in software design and development.

We see minimalism’s influence on many communities and technologies, including:

Unix: The Unix operating system's corresponding Unix philosophy values minimalism. One of its principles is the “Rule of Modularity: Write simple parts connected by clean interfaces.”
Python: Python is a language that values minimalism and simplicity. Python has its own philosophy known as The Zen of Python, wherein one principle is “Simple is better than complex”

Minimalism in software development advocates for:

Doing more with less code
Minimizing resources needed
Employing a modular approach, wherein each module is highly focused

Open-source philosophy

Open-source software is software that makes its source code available to the public. We owe today's abundance of open-source software to open-source philosophy and the open-source-software movement in the 1990s.

The open-source philosophy is closely linked to the hacker ethic. Indeed, many open-source activists were hackers (a term with positive connotations in this context). Like the hacker ethic, the open-source philosophy believes software and information should be freely available to anyone who wishes to use or improve upon it.

Open-source philosophy advocates for:

Sharing source code
Open collaboration with diversity of perspectives
Free exchange of information

The open-source-software movement was a response to the increased privatization and commercialization of software around the advent of the personal computer (PC). This privatization was a contrast to the early days of programming, when researchers and programmers openly collaborated and software was shared in the public domain. Open-source philosophy advocates for bringing source code back to the hands of the people.

We now enjoy an abundance of open-source technologies, including:

Apache web server
Linux operating system
GIMP
Kubernetes

Kaizen philosophy

Kaizen is a Japanese business philosophy that has influenced countless industries. The term Kaizen roughly translates to “change for the better” or “continuous improvement.” Kaizen was first implemented by Japanese businesses after WWII. It became popular in the US in the 1980s.

Kaizen advocates for:

Small, incremental improvements in processes and activities
Elimination of waste
Giving all employees ownership over small improvements

Kaizen’s incremental approach laid the groundwork for agile development methodologies, including lean development. Agile methodologies share a focus on continuous improvement, and are widely used by software development teams today.

Wrapping up and next steps

A program is not so different from a philosophy. They both inform how we move through the world – and in the case of programs, through the world as data. As a programmer, how you develop software can reflect your values, your purpose, and what you believe in.

Like this piece? Don’t miss any of our other posts! Follow Educative for more thought-provoking pieces and hands-on tutorials on software development.

Happy learning!

Continue learning about software development on Educative

6 tips: Finding your balance as a mother and software engineer

Erica V — Fri, 18 Mar 2022 21:03:49 +0000

Writing code, unit testing, then feeding your baby: Unless you’ve seen it firsthand, it might be difficult to imagine juggling both motherhood and software development. If you don’t have relatable role models who have done it before, you might be wondering if it’s possible to take on both roles (and come out in one piece). The answer is: Yes! While it’s not easy, finding a balance between your career and children is done by many determined women around the world.

At Educative, we’ve had the honor to speak with many women who have found space in their life for both motherhood and coding. Whether you’re a mom who wants to break into tech or a developer who doesn't want to give up on her career, we hope you’ll enjoy this piece inspired by the experiences of mothers who code.

Today we’ll cover six tips on finding your balance as a mother and software engineer.

We’ll cover:

6 tips: Finding your balance as a mother and software engineer
- 1. Know your limits, and work around them
- 2. Look for synergies between your worlds
- 3. Communicate your needs
- 4. Redefine your wins
- 5. Drop the guilt
- 6. Don’t give up on your dreams
Wrapping up and next steps

6 tips: Finding your balance as a mother and software engineer

1. Know your limits, and work around them

Once you’re a mother and a developer, your daily responsibilities have doubled (if not tripled). But, despite the changes in your life, there are still only 24 hours in a day. By recognizing your limits, you can set boundaries and delegate tasks as appropriate.

Setting boundaries is a skill that many are still trying to master. We don't mean that you should talk to your infant about boundaries! But you can experiment with setting boundaries in some areas of your life as a mother. For instance, you can limit the hours for which you're "on call" for caregivers of your child. You may also need to set new boundaries with work. For instance, if you've been open to overtime in the past, you may need to set a hard boundary on your hours now that you have a child. As Dawn Parzych put it during one of our Educative Sessions, “Know your limits, and say no when you need to.”

Delegating is an important skill that applies not only to leadership but motherhood as well. Don’t be afraid to ask for help, whether it involves household chores, shopping, and childcare. Leveraging your support system – be they friends, family, or hired professionals – will help free your bandwidth to get some focused work done.

2. Look for synergies between your worlds

Helping develop a human life is undoubtedly different from developing an application. And yet, motherhood and software development stand to share a lot in common. Both roles call for late nights, constant learning, and surprises that require your immediate attention. Far from being polar opposites, your two identities of mother and software engineer can find synergy with each other. Try to be curious about how you can transfer knowledge from one sphere to the next.

During our talk with her on Educative Sessions, Dawn Parzych highlighted the synergies she found between DevOps and parenting. She reflected that they're both a continual learning process.

“It’s all about iterating, seeing what works, what doesn’t work.” – Dawn Parzych, Developer Advocate (Hear her full story on our episode of Educative Sessions, "What DevOps and Parenting Have in Common")

3. Communicate your needs to your manager

Be specific about your needs with your manager so that they can better support you. When you feel concerned about your workload, be open with them. By helping your manager better understand your experience, needs, and roadblocks, they’ll be better able to advocate for you in this new phase of your life.

“Once you start speaking up, you realize that people are really supportive.” -- Anjana Shankar, Sr Distributed Systems Developer (Hear her full story on our episode of Educative Sessions, "A Tech Mom's Struggle During the Pandemic")

Here are some accommodations you can ask for:

Flexible work hours
Remote work options
Breastfeeding breaks and facilities

If you’re having a difficult time coming to understandings with your manager, you might want to consider joining the great developer job search of 2022 in the interest of a work environment that better supports the needs of working mothers.

4. Redefine your wins

You may not have the time to tackle all the things you want to do. Compromising your expectations can be difficult, especially if you’re a high performer. But remember that your life circumstances have changed drastically. In this new reality, there will always be something left on your to-do list at the end of the day, so you should adjust your expectations accordingly.

“Look for the small wins and celebrate them.” – Dawn Parzych, Developer Advocate (Hear her full story on our episode of Educative Sessions, "What DevOps and Parenting Have in Common")

So, how would you have time to celebrate wins when this might be the most sleep-deprived era of your life? Your celebration might be as simple (and crucial) as taking five minutes for a simple self-care activity. If you get good at identifying the small wins, this means you should’ve earned a little bit of time for self-care each day.

5. Drop the guilt

Examine any feelings of guilt that are weighing you down and ask yourself if they're necessary. Chances are, you may be holding yourself to unrealistic expectations. Guilt follows many working mothers around. When you're with your child, you may feel guilty about being away from your work. Conversely, you may feel guilty about being away from your child when you're at work.

Many women find themselves in the habit of apologizing, and working mothers are no exception. When reflecting on how she handled the moments when her child interrupted her video meetings, Anjana Shankar said, “I realized that being apologetic was adding to my guilt.” By learning to fully accept that the circumstances of her life had changed, she was able to stop her habit and release the unnecessary guilt.

“You don’t have to set unrealistic expectations for yourself. Accept that sometimes you have bad days, sometimes you have good days.” – Anjana Shankar, Sr Distributed Systems Developer (Hear her full story on our episode of Educative Sessions)

6. Don’t give up on your dreams

If there’s anything we’ve learned from our conversations with women in Educative Sessions, it’s that persistence is the key to responding to failure. When challenges present themselves along the way, keep your focus on the dream that got you started in the first place.

Navira Abbasi is now the director of the coding bootcamp she initially failed. Despite her failure and wounded pride, Navira returned for a second attempt. This time, she modified her strategy based on lessons she learned from her first time around. Having been asked to be the director, her persistence and hard work didn't go unrecognized.

Chinenye Ikpa, a Software Developer at Decagon, pursued her coding dreams when she was already a mother of four. As a mother, her family and society expected her to stay home or work in a less demanding industry. But Chinenye refused to sacrifice her career ambitions. She’s now a developer who treats challenges as opportunities to be a role model for her children:

“I teach them that they should… practice once a week, never give up, that we go for gold. When I'm down, I think of those things that I repeat to them, and we repeat to ourselves daily. I get up, and I show them how it’s done.” – Chinenye Ikpa, Software Developer (Hear her full story on our episode of Educative Sessions, "It’s Never Too Late! A Mother’s Pursuit of Code")

Wrapping up and next steps

As with motherhood, keeping up as a software engineer requires constant learning. A child’s needs may change just as quickly as in-demand tech stacks. While it’s surely not easy, we celebrate the women who have claimed their space as both mothers and software engineers. If the journey seems daunting, just know that you’re not alone in walking this path.

To hear how other mothers have rocked their tech careers, check out our Mothers Who Code series on Educative Sessions. You’ll hear stories from other women who have blazed their own paths as mothers and software engineers. While we hope you find these stories inspiring, we look forward to seeing what you make of your unique journey as a mother in tech.

Happy learning!

Continue reading about women in code on Educative

Start a discussion

How do you find balance as a mother and software engineer. What concerns do you have if you haven't yet lived both roles? Let us know in the comments below!

Can I become a full-stack Python developer?

Erica V — Fri, 18 Mar 2022 00:00:58 +0000

Want to be a full-stack engineer who uses Python? Great! There are many benefits to using the Python programming language for web development. Python is most popularly used for back-end development. While Python can also be used for front-end development, languages such as HTML are a more common choice. Whether you stick purely to Python or use other programming languages, we'll cover all you need to know in this article.

Today we’ll discuss why Python is a great tool to take with you on your journey to become a full-stack developer, and what you’ll need to learn along the way.

We’ll cover:

What does a full-stack developer do?
Full-stack development with Python
What you’ll need to learn to become a Python full-stack developer
Tips for becoming a Python full-stack developer
Wrapping up and next steps

What does a full-stack developer do?

Being a full-stack engineer means you’re able to work both ends of web app development: The front-end and the back-end. Front-end development concerns how the application appears to the user. In other words, front-end development involves programming the browser, or the client-end. On the other hand, back-end development concerns the logic that governs the application. Back-end development involves programming the remote server and communicating with one or more database(s).

The concepts of back-end and front-end are illustrated in the following figure:

In theory, a full-stack developer can take an application from the design stage all the way through to deployment. However, in application, this is only feasible for very small projects. While a specialized back-end developer might have a deeper knowledge of back-end development, such as database design, a full-stack developer has more of a generalized knowledge. On a large real-world project, full-stack engineers are generalists who help bridge the gap between two highly specialized forces: Front-end and back-end developers.

Full-stack development with Python

There are many benefits to using the Python programming language for web development, including a relatively fast development time. However, the best part about using Python as a full-stack engineer might be the career opportunities it can open up for you. There remains a demand for full-stack and back-end Python engineers. Because Python is commonly used in data science and machine learning, you can add these to your back-end skillset as you advance as a full-stack engineer.

Back-end development using Python

There are numerous Python back-end frameworks include Flask, Django, Turbogears, CherryPy, Pyramid, Bottle, and Falcon. However, we'll discuss the most popular frameworks: Django and Flask.

Django

Django is a free and open-source project with a large developer community. As such, it sees frequent enhancements in its features of security, user and roles management, and database migration management. Django also has a REST framework that fully supports RESTful Web APIs.

Flask

Flask is another popular Python web framework. More lightweight than Django, it's known as a micro-framework. Flask is commonly used to develop the back-end of APIs. You'll find many pluggable features available in the Flask community.

Front-end development using Python

Unlike back-end development, front-end development in Python is still in its infancy. For this reason, HTML, JavaScript, and CSS are typically used at the front-end. However, a few front-end Python frameworks have been developed recently, such as Skulpt, Brython, and Anvil.

Since it’s relatively more mature, let's discuss Anvil. Anvil is a full-stack framework that can be used for both front-end and back-end development. We can use Anvil to develop a web page’s UI components through drag-and-drop components on Anvil's graphical interface. We can also modify the properties of UI components, and associate those components with events (Python functions). Anvil helps with back-end functionalities such as database manipulation, file management, and user authentication.

What you’ll need to learn to become a Python full-stack developer

What you need to learn depends on your past experience. Here’s an overview of what you’ll need to know.

Programming in Python

If you don’t already know Python, you’ll want to learn Python well. You’ll be programming servers with it, after all. But before you start doing that, make sure you’re comfortable with Python fundamentals, from algorithms and data structures, to object-oriented programming (OOP) with Python. While the latter isn’t absolutely necessary, you might consider learning OOP techniques as it can reduce your development time in the long run.

On that note, here are some tips for learning Python as a beginner developer.

Web development fundamentals

If you’re an absolute beginner to web development, you’ve got two sides to acquaint yourself with.

Front-end development

Here’s a minimal list covering what you’ll need to know to get started with front-end development:

Web fundamentals of HTML, JavaScript, and CSS
A front-end JavaScript framework like AngularJS, ReactJS, VueJS
A JavaScript library like jQuery
Optionally, a CSS framework like Bootstrap

Back-end development

Here’s a minimal list covering what you’ll need to know to get started with back-end development:

Designing and building Application Programming Interfaces (APIs), including REST APIs
CRUD operations
A database like MySQL, MongoDB, PostgreSQL, or SQLite
Python back-end frameworks such as Django or Flask
Git for source code management and version control

Tip: There are various web frameworks to choose from. To narrow down your choices, consider the factors that are a priority for you. For instance, you might want to opt for a tool that has decent community support and good documentation.

Tips for becoming a Python full-stack developer

Here’s some guidance for your journey as a full-stack Python developer:

Think of this as a long-term journey: If you’re starting from scratch, you may have a long road ahead of you – and that’s exciting! If you get impatient with your progress, remember that the time you spend learning and practicing now is going to minimize your knowledge gap, which will only help strengthen the foundation for your future growth.
Aim for generalist knowledge first, then go deeper: Since your range of knowledge is covering several topics, you don’t need to have the same depth of knowledge as a specialist would. Start with the minimum that you need to know, and practice that until you’re great at it. You’ll gain a greater depth of knowledge with work experience over time.
Plan your progress with small, achievable goals: Your learning curve might take a while simply because full-stack engineering involves various languages, frameworks, and techniques. If you have a lot of new concepts to learn, it helps to structure a plan that decomposes your final goal into several small goals with realistic deadlines.
Focus on one tech stack at a time: Master one stack first. You can (and should) pick up additional technologies later on.
Learn with peers: You can do this in any way that suits you. Find a fellow Python learner, take classes, do a bootcamp or join a Python Discord server.

Wrapping up and next steps

No matter where you are in your journey as a developer, Python is a great programming language to support you in full-stack development. Learning the skills to carry a web application from design to deployment will not only be a fascinating learning process, but an excellent move for your career as well.

To help you learn the essentials of full-stack development, we’ve created the Quick Start Full Stack Web Development course. With several tutorials and quizzes to assess your progress, you’ll get hands-on experience with each step of web application development. Throughout the course, you’ll learn how to develop a client page with React, create an API with Flask, work with databases with SQLAlchemy, and deploy your application on Heroku.

Happy learning!

Continue learning more about web development on Educative

Start a discussion

What's your approach to learning full-stack? Was this article helpful to you? Let us know in the comments below!

Get started with building Alexa skills: Basics and best practices

Erica V — Tue, 01 Mar 2022 19:04:18 +0000

Over the years, human-computer interaction (HCI) has steadily evolved to allow more intuitive and natural interactions between human and machine. Before the late 1970’s, you needed to be a computer specialist who used text commands to interact with computers. Then, the introduction of graphical user interfaces (GUIs) allowed people who weren't specialists to interact with computers, using visual elements such as icons and menus. Today, the possibilities for human-computer interaction continue to widen with the growing use of Voice User Interfaces (VUIs).

VUIs allow people to interact with computers using voice commands. VUIs are enriched by conversational artificial intelligence (AI), which help make our voice interactions feel as natural as conversations. There are many implementations and use cases of conversational AI, in industries ranging from healthcare to finance. Amazon’s Alexa is one popular implementation of conversational AI.

Today, we’ll discuss how you can contribute to a new generation of voice apps by building your own Alexa skills for Amazon Alexa. Whether you want to be a full-time Alexa developer, build a project to impress at Amazon interviews, or create fun tools to share with your family and friends, this is a great place to start.

We’ll cover:

Building Alexa skills 101
Best practices of voice design
Basics of building Alexa skills
Additional considerations
Wrapping up and next steps

Building Alexa skills 101

Alexa is a virtual assistant that comes with pre-built functions such as weather updates and alarms. You can also create new Alexa skills that users can find and enable on the Alexa Skills Store. Your skills will change the way people interact with smart speakers such as the Echo Dot, or smart home devices like the Echo Show.

You don’t need to be a specialist in conversational AI to develop new Alexa skills. There are various tools and software development kits (SDKs) available to support Alexa skill development. The official SDK for Amazon Alexa skills is the Alexa Skills Kit (ASK). ASK provides self-service APIs as well as other tools that you can use to create your own skill in the Amazon developer console. This includes Alexa skill blueprints, which offer templates for common skills like trivia and games. Alternatively, you can also “Start from scratch” as a template.

To host your backend, you have the convenient option to use Alexa-hosted skills or to provision your own resources. If you opt for Alexa-hosted skills, you can select between Python or Node.js. You’ll also be able to deploy directly to AWS Lambda from the Amazon developer console.

Here’s what you’ll need to start building your own custom Alexa skills:

Knowledge of web basics (e.g. JSON, HTTP protocols, etc)
Knowledge of programming basics (a language such as JavaScript, Python, Node.js)
Amazon developer account

You’ll also need to know some voice design best practices and Alexa basics, but we’ll cover some of that next.

Best practices of voice design

Compared to apps built for the screen, voice-powered apps have their own set of best practices. Voice services should be inspired by qualities of real-world conversations to ensure an intuitive and engaging user experience.
There are four design principles that Amazon recommends following for building Alexa skills.

Be adaptable

People use different words to express the same ideas or intentions. When processing a person’s response, a voice application should be able to consider the many different paths that can yield the same results.

Be personal

Your voice assistant is sort of a robot, but it’s serving humans. As such, it should strive toward more human standards. If someone responded to you with the same phrases, you may quickly lose interest in the conversation. To keep the user experience engaging, you’ll need to personalize your voice app to have a variation of responses.

Be available

Voice services should make it clear what options are available to their users. However, you don’t want to overload users with an entire menu of options. Being available means you offer users their available options, while keeping things as simple and brief as possible.

Be relatable

Just like conversations with humans, you want your voice app to feel human and relatable. To do this, we need to make sure that the app’s responses sound natural and conversational. Some of the strategies to help achieve this are using contractions (e.g. “can’t” instead of “can not”) and transition words (e.g. “first”).

Basics of building Alexa skills

To start building your custom Alexa skill, your interaction model will be defined with the following components:

Wake word: A wake word is the word that wakes your virtual assistant. In the case of Alexa, it’s “Alexa.”
Invocation name: Once your virtual assistant is activated and listening, an invocation name tells Alexa which skill you want to open.
Utterances: Utterances are the statements or questions you express to Alexa. Since many different utterances can express the same thing, variation of utterances should be expected, per the “Be adaptable” design requirement.
Intent: Intent is the action that Alexa should take in response to the utterance.
Slot: Slots are variable inputs in utterances. They’re useful for cases like numbers, it’s incredibly tedious and unreasonable to have to enumerate all possible utterances one could tell Alexa (e.g. zero to infinity).

Additional considerations

The Alexa skill building process

ASK has made the Alexa skill building process rather streamlined. However, there are still several steps you’ll need to include in your building process to ensure a good quality voice service.

Your building process will involve several steps, including:

Planning (User experience, intents, etc)
Creating the VUI
Coding the backend logic
Testing (From Amazon developer console or device)
Store listing and certification
Making improvements based on user feedback

Remember the user

Remember, your skill is providing a user experience. The better it is at anticipating your users, the more successful it'll be. You’ll want to moderate all of your design choices by prioritizing the user experience. Let’s consider some of the thought that goes into the building process by focusing on scriptwriting for the user experience.

When you’re building a skill from scratch, the building process will involve writing scripts. Scriptwriting can be fun. Keeping in line the voice design principles, you can personalize your script to give Alexa a bit of personality. However, be sure you don’t lose sight of what’s best for the user experience. Even if you get creative, Alexa’s interactions should still be relevant and reasonably brief.

When writing scripts, you certainly plan for the happy path, which is the ideal interaction you imagine between a user and your skill. However, you should also plan for edge cases. Edge cases are everything outside of the happy path. They may be what you’re not expecting, but they’re something you should plan for. To prepare for edge cases, you’ll need to consider the various types of utterances that your virtual assistant can be trained for, and which of them require a specific rather than general response.

Some edge cases may be questions that are entirely irrelevant, while others may be a help case in which your user may need assistance. For instance, if they ask Alexa, “What’s your favorite fruit?” it’s not a bad idea for Alexa to give a general response such as, “Sorry, I’m a trivia game. Tell me when you’re ready to start playing.” But if the user asks, “Can you help me?” it might be helpful to prepare a specific response that clarifies something for the reader, such as, “This is a trivia game. Tell me when you’re ready to start playing, or say ‘Stop’ to exit.”

Wrapping up and next steps

It’s always exciting to gain new skills, and learning to build voice apps is no exception! Building Alexa skills will open the door for you to experiment with next-gen voice-powered apps. Whether you become a dedicated Alexa developer, or make a hobby out of creating skills, there’s a lot you can do with the help of the Alexa Skill Kit.

For a deeper exploration of building Alexa skills, check out our course Alexa Skills 101: Building voice apps for Alexa. You’ll learn more about voice design and how VUIs can enhance your apps. The course includes a step-by-step tutorial on the Alexa skill building process, quizzes to test your knowledge, and a hands-on mini project.

Happy learning!

Continue learning about next-gen trends on Educative

Start a discussion

What Alexa skill are you building? Was this article helpful? Let us know in the comments below!

7 tips: Being your own role model as a woman in tech

Erica V — Wed, 23 Feb 2022 22:20:12 +0000

We have a long way to go in diversifying the tech industry. According to Stack Overflow’s 2021 Developer Survey, only 4.8% of professional developers identify as women. While this number illustrates how underrepresented women are in tech, this meager 4.8% also accounts for women at the intersections of other groups who see even less representation in the industry. A programmer may not only be a woman, but also a neurodivergent single mother, a queer person of color, or a disabled veteran.

While having a relatable role model is invaluable, they're sometimes absent for those of us who are statistically underrepresented in tech.

On our way to a more diverse future in tech, we need brave individuals who can pave their own path and inspire positive change and promote diversity in the tech industry for generations to come. Today, we’ll discuss what it means to be your own role model as a woman in tech, and 7 tips to help you along the way.

We’ll cover:

What does it mean to be your own role model?
7 tips: Being your own role model as a woman in tech
- 1. Get to know your best self
- 2. Be your biggest advocate
- 3. Claim your confidence
- 4. Build supportive relationships
- 5. Identify and cultivate sources of inspiration
- 6. Embrace the process and accept imperfection
- 7. Give yourself a break
Wrapping up and next steps

What does it mean to be your own role model?

The Educative team has talked to various women across the industry. What we found was that many women didn’t have relatable role models in tech. Undoubtedly, role models and representation can be a game-changer for women speculating a future in tech. The presence of someone “like you” can serve as tangible proof of what’s possible in an industry that suggests otherwise. But when they’re few and far between, there’s power in forgetting the idols. You can blaze your own path and write your own rules instead.

Being your own role model means setting your own standards for success and paving your own path as you navigate your tech career. By looking to your own standards, you don’t need to compare your journey with another person’s to validate your success. We can still be inspired by others, but it’s unfair to make comparisons with role models from entirely different backgrounds. This is especially true if you’re at the intersection of several underrepresented groups (whether it’s gender, ethnicity, or neurotypicality). Being your own role model is a mindset in which you take leadership of your life. In doing so, you can inspire future generations to come.

“Equality in the workspace shouldn’t be an exception; it should be the standard. That’s non-negotiable for me as a leader.” – Mehwish Salahuddin, HR and Office Manager (and one of the many women who power Educative)

We're still writing the story of how diversity and equity in the workplace became the rule, rather than the exception. And you, as one character in this story, have your own unique path to pave.

7 tips: How to be your own role model as a woman in tech

1. Get to know your best self

Part of the beauty of being your own role model is that you don’t have to compare yourself to others. Instead, you need to clarify what success and happiness looks like to you. Your best self is not the person others expect you to be. Your best self is who you want to be, in the best possible scenario. After all, the true measure of your success and happiness should be defined by nobody other than yourself.

In getting to know your best self, ask yourself these questions:

What would I be like in ten or twenty years, if everything worked in my favor?
What would I set out to achieve, if I knew I wouldn’t fail?
What am I known and celebrated for?

In the absence of other role models, your best self will be your guiding light. While she may not feel completely “real” yet, your best self is an important resource that you can turn to when you need perspective in difficult situations.

“Your best self today could be different from your best self a week ago, and yesterday. Make a general vision, and something that’s achievable on a daily basis. **You can be the best version of your best self relative to the day ahead of you – and that's good enough.” – Edit Vosganians, Technology Services Librarian Specialist

2. Be your biggest advocate

We’re often our biggest critics – but we should also be our biggest advocates. Advocating for yourself means having the courage to highlight your accomplishments and have difficult conversations.

Workplaces benefit from a plurality from perspectives and input, so don’t be afraid to communicate. Most people have no idea what you’re going through until you talk to them about it. While it can feel daunting, communicating and addressing concerns head-on can improve a situation for you and your team members. There’s strength in being vulnerable. When identifying problems, try to propose solutions as well. If you can, support yourself with objective facts and numbers too.

As part of an underrepresented group, it’s a common experience to have your voice and your accomplishments left unheard. This can feel alienating and infuriating. Just know that you aren’t alone. When you do face difficulties like this, be sure to take care of yourself and call on your support system for help.

That being said, not everybody experiences a workplace where hard conversations are encouraged. If your employers don’t react well, take it with a big grain of salt. You may be a better culture fit at a different company!

"Working at Google, we have this idea of "Googleyness." It can be interpreted in a lot of ways, but my biggest take on it is to treat others with respect, and call out others when respect isn't being shown. I believe hostility creates toxicity, and that's not an environment I want any women entering tech to be a part of. It's taken me a while to build up the courage to call things out when I see it. If you're afraid of conflict and have an awesome manager, I strongly encourage you to lean on them for support." – Abigail Carey, Developer Advocate

3. Claim your confidence

If you don’t feel like you’re an amazing developer, here’s a little secret about performers: All performers have moments where they don’t feel like playing their part. But they do it anyway. It rings in tune with the saying “Fake it ‘til you make it.” And it works.

No matter your level of experience, you have every right to take up space in the place that you're in. If you’re struggling with self-doubt, you’re not alone in your feelings. Part of the issue could be that you’re feeling imposter syndrome, which is completely normal for high-performing individuals. But as an underrepresented group, there are several other elements that can threaten your confidence, especially mistreatment ranging from microaggressions to demeaning comments.

“Being a Black woman… in this industry… things like [microaggressions] will happen... What helped me… were my female friends and peers… it's happened to them. It's happened to some guys as well. … We have a few people like that in the [tech] culture who feel like they want to take over the room. If you're taking up too much space, they want a piece of that space.” – Timirah James, App Frameworks Evangelist (Hear her full story on Educative Sessions)

Keep a meter on your confidence. When challenges arise, honor your feelings, take care of yourself, and lean on your support system. You’re fully competent and capable, and you have a seat at the table because you’ve earned it. Even if it seems like the odds are stacked against you, believe in yourself, and the people who believe in you too will see you and lift you up too.

4. Build supportive relationships

Even on a molecular level, we are nothing without relationships. As the idiom goes, “It takes a village” to raise a child, and the same can be said for our careers. When you’re looking for advice or someone to talk things out with, your community will be an invaluable support that you can turn to. Some people are lucky to find a supportive community with colleagues in their workplace – for the rest of us, it’s up to us to build our own supportive relationships with others. The key to doing this is finding out who you can trust and building mutually supportive relationships with them.

It can take some time to build a community, but it’s well worth the time investment. To meet people, you can participate in study groups, volunteer your time, or go to Meetups or networking events. You can also just focus on building your own community that consists of individual relationships. Be open to individuals with differences too – there’s a lot you can learn by straying away from a narrow window of “like-minded” people.

“I still think it’s very important to volunteer and to reach out. LinkedIn can be scary because you don’t know anyone necessarily, but just reach out to someone who came from the same school or is at a company… that you like or want to know more about.” – Ivette Cortez, Business Program Manager (Hear her full story on Educative Sessions)

5. Identify and cultivate sources of inspiration

All successful people have been inspired by something. Inspiration can be found everywhere. Be curious about the world and look for the things that speak to you. When you don’t have a clear idea of what your “best self” would do, you can turn to these sources of inspiration to navigate your path forward.

Your inspiration could be as tangible as a person or as abstract as a concept. The person could be your next door neighbor. They could also be someone you’ve never met, such as women in tech history or even fictional characters. Apart from people, inspiration can span as wide a range as your imagination allows. It could be found in a philosophical concept, or even in your favorite animal.

"I don’t have a role model, but I have a role motto. My motto is “Get it done.” … Just the satisfaction at the end of the day that I’ve crossed some things off and contributed to the process is enough for me to consider it a good day. I’m happy with myself going home with that." – Edit Vosganians, Technology Services Librarian Specialist

6. Embrace the process and accept imperfection

“I want to be at a place where I’m comfortable not knowing everything. I’ve found that senior people are okay with admitting they don’t have the answers, and those with less experience tend to try and sound right all the time.” - Kaitlyn Yamamoto, Software Engineer

One of the biggest ways we hold ourselves back is by setting unrealistic expectations for ourselves, and prioritizing product over process. If you settle for nothing short of your end result, you may be missing opportunities to be present in the process by celebrating milestones and learning from mistakes. Instead of paralyzing yourself with unrealistic expectations, be content with small steps toward your goals.

It’s important to celebrate not just your end goals, but each step along the way. Acknowledge and celebrate your accomplishments. Set up a consistent reward system. You don’t need to reward yourself based off something being completely “done.” It’s enough that you did your best, showed up, or moved something forward. Rewarding yourself for even the little things will keep your morale strong. Remember that you’re still winning, no matter how imperfect you may feel.

7. Give yourself a break

Self-care is incredibly important. Do you ever write “Rest” on your to-do list? Be they big or small, the challenges you face on the day-to-day add up. Even if others won’t, cut yourself slack and show yourself some love.

Give yourself breaks and opportunities to disconnect and destress. Taking breaks will help you stay strong and resilient through tough times. It will also help you be more productive in the long-term. When you’re in the zone, you may never think the solution to debugging that code is a simple 5 minute break to stretch your bones, give space to your emotions, or clear your mind.

“...We need restoration… recognizing that is a huge first step... Whatever it is, [find something] that really restores that energy for you and gives you energy rather than… you expending energy on something else.” – Mary Thengvall, Director of Developer Relations (Hear her full story on Educative Sessions)

Wrapping up and next steps

Being your own role model is about paving your own path, owning your unique journey, and defining your own standards for success. While you could look to other role models for inspiration, nobody is walking in your shoes but yourself. By owning your story, you can succeed while staying authentic to yourself, and serve as an inspiration for a more diverse future in tech – one step at a time.

To hear about how other women paved their own paths into tech, check out the Women in Tech series on our podcast, Educative Sessions. You’ll hear engaging stories on the challenges they faced, the wisdom that helped them succeed, and the sense of humor that helped along the way.

Happy learning!

Keep learning about developer success

8 steps to an offer: Ace your Netflix software engineer interview

Erica V — Thu, 17 Feb 2022 23:49:23 +0000

So you have an interview at Netflix, or you’ve just submitted an application and are eagerly awaiting a response. Job searches and interviews can be daunting, and Netflix is certainly very particular about who they hire. However, with the right interview preparation, you can cruise through the hiring process and land your dream job.

Today we'll cover 8 steps to help you ace your software engineer interview at Netflix. While this article focuses on Netflix, you can apply much of what you learn to other FAANG companies, such as Amazon and Apple.

We'll cover the following steps:

1. Study the Netflix culture deck
2. Connect your past experience with Netflix culture and values
3. Prepare to grok the system design interview
4. Study the fundamentals in one programming language
5. Learn the ins and outs of the Netflix interview process
6. Shake off your imposter syndrome
7. Have a winning mindset
8. Position yourself as a next-gen engineer
Wrapping up and next steps

8 steps to prepare for your Netflix software engineer interview

1. Study the Netflix culture deck

Many software engineers make the mistake of underestimating the importance of their culture fit in the interview process. Make no mistake – Netflix cares, and so should you.

“Our core philosophy is people over process. More specifically, we have great people working together as a dream team. With this approach, we are a more flexible, fun, stimulating, creative, collaborative and successful organization.” – From the Netflix culture memo

If you haven’t heard from the recruiter yet, they’ll tell you that you need to read the culture deck before your initial phone screen. Even for technical roles, your culture fit is weighs heavily on your candidacy, from start to finish.

So go and check out the Netflix culture memo.

2. Connect your past experience with Netflix culture and values

Look at your resume and start connecting dots between your past experience and Netflix’s values. You’ll want to tell a story about how your past accomplishments demonstrate your alignment with Netflix’s cultural values, such as leadership and candor.

Phone interviews are the very first steps in the interview process. There are two phone calls, where the recruiter and hiring manager will primarily ask behavioral questions to assess your culture fit. All they’ll have in hand is your resume and perhaps your LinkedIn profile. By targeting details in your resume, you’ll build a more tangible story of your culture fit.

Tip: Practice talking about your accomplishments out loud. As opposed to writing a cover letter and resume, sometimes verbalizing our strengths is the hardest part.

3. Prepare to grok the system design interview

Netflix’s technical interview questions aren’t like LeetCode questions. Instead, they’re more open-ended, with the aim of assessing your design skills and subject matter expertise. Since Netflix mainly hires senior developers, this emphasis on design skills is in line with industry expectations. This means you’ll want to study system design principles and practice system design interview questions.

System design interviews ask open-ended questions such as “Design the Uber backend,” “Design TinyURL," or “Design an API.” While you may not be asked this particular question, practicing designing video streaming services such as Netflix will surely be good to know too! Throughout the interview, you’ll share your thought process and whiteboard solutions to demonstrate how you apply design principles to real-world problems.

4. Study the fundamentals in one programming language

Netflix’s technical questions are focused on design, but you’ll still need to show your problem-solving skills with more basic programming concepts. Unless the job description says otherwise, we recommend focusing on a strong working knowledge of one programming language. Make sure to study various programming basics in that language, including design patterns and algorithms and data structures, such as binary search trees and linked lists.

5. Learn the ins and outs of the Netflix interview process

The Netflix hiring process consists of phone calls and onsite interviews. They cover both technical questions and behavioral questions. Since Netflix values hiring for their team, the interview process will not only involve HR and hiring managers, but engineering team members as well. You’ll want to research and prepare for each round in the interview process so that you know what to expect – and what is expected of you.

Reminder: Don’t procrastinate on reading the culture deck. Your culture fit will play a huge part in the interview process, as early as the initial phone screen.

6. Shake off your imposter syndrome

Job interviews make a lot of us nervous, and imposter syndrome can make it even worse. While it’s good to be humble, we often vastly underestimate the value we bring to the table (This is especially true for women in the tech world). If we don’t truly believe in ourselves, it’ll be harder to convince others to believe in us too.

Take some time to reflect and fully own your narrative and your accomplishments. Be generous with yourself and believe that you have the right stuff to blow the other candidates out of the water.

Tip: Sometimes it helps to dress the part. Even if nobody can see you in your PJs during a phone interview, there’s something powerful about embodying your professionalism with a professional "uniform."

7. Have a winning mindset

A winning mindset is the key to success. While this may mean something different to everyone, we challenge you to approach it from what may seem a surprising angle: Be unafraid of failure.

There’s something liberating about fully engaging in the interview process, without getting too hung up about the results. Even if you don’t get an offer, you haven’t failed. With so many other developers competing for jobs at Netflix, sometimes you just won’t be the top pick. Don’t be hard on yourself if you aren’t. Instead, reflect on what you could do better next time – and celebrate what you already did well. Certainly, you’ve become a stronger interviewer – and you’re one step closer to a developer job you love.

8. Position yourself as a next-gen engineer

Netflix is looking for folks who can journey forward with them into the constantly changing landscape of tech. You’ll want to position yourself as the right candidate to evolve and embrace new challenges with them along the way.

To position yourself as a next-gen engineer, express your enthusiasm and awareness of emerging technologies such as machine learning. Even if your position only requires proficiency in one language, express excitement about any opportunities to work with the other technologies at Netflix. Netflix uses various technologies across teams and departments, including Scala, Flink, Kafka, and SQL.

Wrapping up and next steps

Now that you know how to prepare for your Netflix interview, it’s time to get the pedal to the metal and get that dream job.

To help you grok your interviews, we’ve created Interview Prep with Educative. Here, you’ll find all our interview prep resources in one place, from courses and learning paths to free tutorials and educational blog resources. We cover all the bases, from coding questions to system design questions and answers.
Now go show them what you’ve got, and don’t forget us little people when you become a Netflix employee.

Happy learning!

Continue learning about interview prep on Educative

Start a discussion

Have you interviewed at Netflix before? Was this article helpful to you? Let us know in the comments below!

6 coding best practices for beginner programmers

Erica V — Mon, 14 Feb 2022 21:44:18 +0000

Code is written once. Then it's read, debugged, refactored, and scaled constantly. How you write code today will help you maintain and scale the application later down the road. We’re frequently under the pressure of deadlines in software development.

Regardless, it’s important to use coding best practices to help ensure better quality code for yourself and for anyone who may have to extend that code in the future.

Today, we’ll discuss the importance of using coding best practices, and six best practices you should know as a beginner programmer.

We’ll cover:

Why you should use coding best practices
6 coding best practices for beginner programmers
- 1. Code indentation
- 2. Meaningful naming
- 3. Comments that add context
- 4. Don’t repeat yourself
- 5. Low coupling and high cohesion
- 6. Consider your context
Wrapping up and next steps

Why you should use coding best practices

As a coder, developing a coding style that’s mindful of these best practices will make it easier to extend and debug the code in the future. Even if you’re no longer working with that codebase, the legacy of your work will affect the community of developers who work with that code in the future.

Coding best practices help ensure code quality and codebase health. Using good practices when writing code will support the characteristics of good code, that is: Maintainability, scalability, readability, and portability.

Code is written once and read thousands of times.

Some good coding practices, such as commenting, don’t affect the functionality of a program. However, they do impact the experience for the humans who’ll be reading and maintaining that code. You may be able to get your program to execute, but if you don’t implement best practices, a quickly done task can backfire by creating confusion and problems in the future. Writing good code now will help ease the processes of code reviews, unit tests, and refactoring.

6 coding best practices for beginner programmers

1. Code indentation

Proper indentation is the most important thing you can do to ensure that your code is readable and easy to understand. There are many different indentation styles, such as K&R, OTBS, and Stroustrup. These styles all advise that we add spaces and new lines in our code, so that each block of code is readily identifiable.

In the following code example, it’s difficult to identify the boundaries of functions, loops, and conditional blocks without proper indentation:

#include <stdio.h>
int find(int A[], int size) { int ret = -1; for(int i = 0; i < size; i++) {
if(A[i] > ret){ ret = A[i];
}
  }
   return ret;}
int main() { int A[]={1, 4, 7, 13, 99, 0, 8, 5}; printf("\n\n\t%d\n\n", find(A, 8));
return 0; }

In the following example, we rewrite this code with proper indentation. It becomes much easier to understand.

#include <stdio.h>
int find(int A[], int size) {
   int ret = -1;
   for (int i = 0; i < size; i++) {
       if (A[i] > ret) {
           ret = A[i];
       }
   }
   return ret;
}

int main() {
   int A[] = {1, 4, 7, 13, 99, 0, 8, 5};
   printf("\n\n\t%d\n\n", find(A, 8));
   return 0;
}

2. Meaningful naming

Your code’s variable names and function names should be intuitive. Ideally, we should be able to guess what a function does based on the function’s name.

You should give intuitive names to objects, variables, classes, functions, and constants. However, we also strive to keep our code concise and readable. If the most intuitive name is too long to keep code concise, you’re welcome to use its shorthand. Just be mindful that the shorthand should remain intuitive as well.

The following example of code does not follow meaningful naming conventions. This makes it difficult to understand and reuse.

#include <stdio.h>

int find(int A[], int size) {
   int ret = -1;
   for (int i = 0; i < size; i++) {
       if (A[i] > ret) {
           ret = A[i];
       }
   }
   return ret;
}
int main() {
   int A[]={1, 4, 7, 13, 99, 0, 8, 5};
   printf("\n\n\t%d\n\n", find(A, 8));
   return 0;
}

In contrast, the following code example has the same functionality, but meaningful naming makes it easier to understand.

#include <stdio.h>

int findLargest(int inputAry[], int inputArySize) {
   int largest = -1;
   for (int loop = 0; loop < inputArySize; loop++) {
       if (inputAry[loop] > largest) {
           largest = inputAry[loop];
       }
   }
   return largest;
}

int main() {
   int A[]={1, 4, 7, 13, 99, 0, 8, 5};
   printf("\n\n\t%d\n\n", findLargest(A, 8));
   return 0;
}

3. Comments that add context

Code is for the compiler, while comments are for coders.

Even if other best practices are accounted for, source code can’t always be self-explanatory. When code can’t explain itself, comments should step in. Here, good practices for writing stories apply to writing code: The more you anticipate your reader’s thoughts, the more impactful your comments will be.

Here are some general guidelines for code comments:

Prioritize quality over quantity: Don’t go commenting on every line of code. Comments should still support code readability. If your function name or variable name already infers what is happening, you don’t need to let readers know.
Don’t assume your reader has context: Let your readers know the context behind the code so they can understand why each part is necessary. If you’ve modified code to fix a bug, comments help keep that bug fixed.
Explain the “Why”: Don’t tell us what we can already see in the code. Explain the why behind it. We can see which method or function you’re using, but knowing why helps readers better understand the code.

Code commenting helps make codebases and projects more maintainable. When done well, good commenting can streamline code reviews. Comments also support developer onboarding by helping newcomers familiarize themselves more quickly with a codebase.

The following is an example of code commenting done well.

#include <stdio.h>

/**
* Finds the largest integer from the given array (inputAry)
* of size (inputArySize).
*/
int findLargest(int inputAry[], int inputArySize) {
   //Assumption: array will have +ve elements.
   //Thus, the largest is initialized with -1 (smallest possible value).
  int largest = -1;

   // Iterate through all elements of the array.
  for (int loop = 0; loop < inputArySize; loop++) {

      //Replace largest with element greater than it.
      if (inputAry[loop] > largest) {
          largest = inputAry[loop];
      }

  }
  //returns the largest element of the array
  return largest;
}

int main() {
   int A[]={1, 4, 7, 13, 99, 0, 8, 5};
   printf("\n\n\t%d\n\n", findLargest(A, 8));
   return 0;
}

4. Don’t repeat yourself

Also known as the DRY principle, “Don’t repeat yourself” strives to reduce code duplication. The idea here is that if you have code that’s doing the same thing twice, it should be made into a function. By abstracting code into functions, you can reuse that code and make development more efficient. In addition, avoiding code duplication makes debugging easier, as you won’t have to fix a bug in every instance of repeated code throughout your program.

5. Low coupling and high cohesion

Low coupling and high cohesion are different yet complementary principles. Low coupling encourages separation between unrelated parts of a codebase, while high cohesion encourages integration between related parts of a codebase.

They may sound like opposing principles, but low coupling and high cohesion work together to ensure the maintainability, scalability, and testability of our applications. High cohesion strives to keep a close relation between units that need to know about each other. When it’s time to extend code, we benefit from finding related code in the same places. On the other hand, low coupling strives to reduce dependencies between unrelated units.

If we don't follow this best practice, we risk trending toward high coupling and low cohesion. This results in excessive dependencies, which has several negative impacts. One undesirable result is an increased vulnerability to bugs, as a bug in one unit will affect its dependent units as well.

Low coupling and high cohesion apply to how we treat any of our language constructs, from methods and classes to libraries and APIs. These good practices can be achieved through what are known as SOLID principles in object-oriented programming.

6. Consider your context

Coding guidelines vary across different contexts. Depending on your programming language, company, or industry, there may be different coding guidelines for naming conventions, coding style, indentation, and file structures. Be mindful of your project’s individual needs and honor those coding standards when you can.

Use your best judgment, and adjust to whatever your situation calls for.

It's important to know good coding practices, but rules are simply generalizations without context. To be used well, they need your good judgment. Keeping all these principles in mind, you should follow your instincts as a programmer. There will be times where your context challenges a general principle, and you know your case best. This is what others mean when they say not to take these rules “pragmatically,” and we agree.

Wrapping up and next steps

Writing good code is essential to your success as a developer. By keeping these coding practices in mind, you can ensure that your code is easier to maintain, scale, and debug. The more you code, the better you’ll get at applying and adapting these practices across different languages and projects.

To master more best practices for your coding career, check out the Coding Career Handbook. This course covers everything from writing quality code to career strategy for junior through senior developers.

Happy learning!

Continue learning about coding on Educative

Start a discussion

What best practices have you been using? Was this article helpful? Let us know in the comments below!

Ace Google's behavioral interview: Questions and tips for coders

Erica V — Thu, 10 Feb 2022 20:16:09 +0000

While contradictory, it makes perfect sense: Some of the most important qualities we evaluate in tech professionals aren’t technical. After all, what help would your knowledge of libraries and languages be if you can’t cooperate with your colleagues? Acing the behavioral interview is essential to landing your dream developer job. Today we’ll talk about acing behavioral interview questions at one of the most desirable tech companies: Google.

Google is notoriously committed to hiring people who are a strong cultural fit for their company. Your level of cultural fit is what Google calls your “Googleyness.” Google takes their behavioral interviews seriously. If you take your interview prep just as seriously, you’ll not only pass with flying colors at Google, but you’ll be well-positioned to ace behavioral interviews at other companies too, such as Amazon and Microsoft.

We’ll cover:

Why you need non-tech skills for your tech job
What Google looks for in behavioral interviews
Top Google behavioral interview questions
- Describe your work style.
- How do you handle conflict?
- Tell me about a time you led a project.
- Tell me about a time you had to take hard feedback.
- Tell me about a time you improved a process.
Wrapping up and next steps

Why you need non-tech skills for your tech job

Answering technical questions regarding data structures and algorithms is important. But every big tech company is driven by non-tech values. When you’re a software engineer candidate, it’s not enough to prepare for coding and system design interviews. After all, other candidates may have the same technical qualifications as yourself. You need to demonstrate that your personality and soft skills make you a strong culture fit for the company as well.

Technical interviews assess whether you’re a good fit for a company’s technology. Behavioral interviews assess whether you’re a good fit for a company’s people.

You may be productive when sitting at your desktop. But when it’s time for code reviews, collaboration, or a hydration break in the office kitchen, your people skills will be important to the success and morale of your coworkers and team members too.

What Google looks for in behavioral interviews

Part of Google’s interview process, like the coding interview, aims to unearth your technical skills. On the other hand, Google’s behavioral interview assesses what they call your “Googleyness.” When you’re looking at a job description, you might be excited about the particular details of the role, or perhaps the opportunity to work with your favorite Google product. But to consider your “Googleyness,” you’ll want to step back and relate Google’s company vision to your core values as a person.

“If we hire you based on your skills, we’ll get a skilled employee. If we hire you based on your skills, and your enduring passions, and your distinct experiences and perspectives, we’ll get a Googler. That's what we want.” - From Google’s How We Hire page.

To show that you’re a “Googler,” think about how you align with Google’s core values and philosophy. All the work you do at Google will connect to one of these core values, which include user-centered design and web democracy.

Here are some qualities that hiring managers associate with “Googleyness”:

Positivity
Sense of humor
Respect and inclusivity
Lifelong learning
Humbleness
Supportive team player
Conscientiousness and ethics

In addition to your “Googleyness,” you’ll want to highlight your unique values, passions, and standards for success too. Show your hiring managers the traits that make you stand out from the rest, and relate them to Google’s values whenever you can.

Wrapping up and next steps

Congratulations! You’re one step closer to your dream job at Google. While behavioral interviews can be nerve-wracking, the right amount of preparation will ensure you come out of the interview round with “Googley” colors. Now that you’ve got the tools and tricks to ace your behavioral interview, you’ll want to be sure you check your boxes for the coding interview and system design interview as well.

To master all things interview-related, check out Interview Prep with Educative. Here you’ll find company-specific interview guides, coding interview tutorials with sample answers, as well as courses and blog posts to help you ace your interviews and land your dream job.

Happy learning!

Continue learning about interview prep

Start a discussion

Do you have tips on preparing for behavioral interviews? We'd love to hear them in the comments below!

13 REST API interview questions you need to know

Erica V — Thu, 20 Jan 2022 00:48:00 +0000

No matter which programming language or technology you’re working with, you’ve probably encountered a REST application programming interface (API). REST stands for Representational State Transfer, which is the one of the most widely-used architectural styles for web services, microservices, and APIs today. APIs that follow the REST architectural style are considered REST APIs.

Whether you’re a junior or senior developer, you may be asked questions about REST API in an interview. To help you ace your next interview, we’ll discuss some common REST API interview questions and answers.

We’ll cover:

13 REST API interview questions you need to know
- 1. What is REST?
- 2. What is a REST API?
- 3. Describe the 5 constraints of the REST architectural style, and their benefits.
- 4. What is the optional architectural constraint of REST?
- 5. Explain the constraints of a uniform interface.
- 6. What is CRUD?
- 7. Explain the HTTP request methods supported by REST, and when they are used.
- 8. What’s the difference between PUT and POST methods?
- 9. Explain what statelessness means in REST.
- 10. What are the advantages and disadvantages of a REST API?
- 11. What's the difference between AJAX and REST?
- 12. What's the difference between SOAP and REST?
- 13. Explain HTTP response status codes.
Wrapping up and next steps

13 REST API interview questions you need to know

1. What is REST?

REST stands for Representational State Transfer. REST is an architectural style for web development. REST architecture lays out guidelines for the transfer of resource representations between clients and servers on the web.

2. What is a REST API?

A REST API or RESTful API is a web API that conforms to the REST architecture style.

3. Describe the 5 constraints of the REST architectural style, and their benefits.

In case they ask for 6 constraints, see the following question about the optional constraint.

A truly RESTful API must conform to the five REST architectural constraints:

Uniform interface:
- Interface between client and server that allows for standardized client-server communication in a single language
- Necessary for the decoupling of client and server
Client-server:
- Client-server model, for separation of concerns between client and server
- Permits client and server to operate and evolve independently
- Supports portability and scalability
Stateless:
- Refers to stateless communication protocol, wherein the server stores no information about session states
- Improves performance by reducing server load
Cacheable:
- Servers mark their responses as cacheable or non-cacheable
- Clients and intermediaries are able to cache server responses
- Reduces client-server interaction, supports scalability and performance
Layered system:
- Layers between client and server, can consist of intermediaries such as proxy servers or load balancers
- Layers have separate responsibilities but are able to interact with each other
- Supports system scalability and security

4. What is the optional architectural constraint of REST?

Code on demand is the optional constraint of RESTful architecture. Code on demand allows the server to send executable code (scripts or applets) to a client upon client request.

Advantage: Extends client functionality, since client can download features after deployment

Disadvantage: Reduces visibility, which is why it’s considered optional

Examples: Java applets and JavaScript

5. Explain the constraints of a uniform interface.

A uniform interface is needed to decouple the client from the server.

There are four necessary constraints to achieving uniform interface:

Identification of resources: Client requests must identify resources using uniform resource identifiers (URIs)
Manipulation of resources through these representations: When clients receive a resource representation from the server, they have all information necessary to be able to modify resource state
Self-descriptive messages: Messages contain all information necessary for recipient to interpret it, including metadata
Hypermedia as the engine of application state: Hypermedia (such as HTML) is the medium for client-server interaction, and the client requires no API-specific documentation to understand server responses

6. What is CRUD?

CRUD is an acronym for the four basic operations used in relational database management system (RDBMS).

Each operation in CRUD relates to an HTTP method that REST supports.

Create: POST
Read: GET
Update: PUT
Delete: DELETE

7. Explain the HTTP request methods supported by REST, and when they are used.

REST APIs are based on HTTP requests or verbs, which each perform a different task.

REST supports the following HTTP requests:

GET method: Request data from server
POST method: Submit data to create new resource on server-defined URL
PUT method: Submit data to update a resource at client-defined URL
DELETE method: Remove resource from server
OPTIONS method: Return request methods supported by a service
HEAD method: Return meta information such as response headers
PATCH method: Modify part of the resource on the server

8. What’s the difference between PUT and POST methods?

This question can stump some developers. Being able to explain this will help you stand out as someone who actually knows what they’re talking about.

Here are the differences between PUT and POST:
PUT:

Idempotent (i.e. multiple requests will yield same result)
PUT responses aren’t cacheable
Updates or replaces target resource with request's payload

POST:

Not idempotent (i.e. multiple requests will yield multiples of the same resource)
POST responses can be cacheable, provided proper cache-control header
Request's payload is processed by the web server based on target resource

Understanding idempotency: An example of an idempotent operation would be the operation of multiplying a number by one. No matter how many times you multiply five by one, you’ll get the same result.

9. Explain what statelessness means in REST.

Statelessness means that the client and server don’t store information about each other’s state. Since the server stores no information, it treats each client request as a new request.

As a consequence, the following conditions would apply:

The client request contains all information required for the server to process the request
Client application is responsible for storing session state

10. What are the advantages and disadvantages of a REST API?

It’s important to know the pros and cons of a RESTful API.

Advantages include:

Designed for high performance, portability, reliability, and scalability
Client-server separation allows each to individually operate and scale
Easy to test and adapt to various environments
Easy to learn as it uses HTTP protocol
Supports various data transfer technologies including JSON, XML, YAML, images, and more
Uses less bandwidth than other methods, such as Simple Object Access Protocol (SOAP) technology

Disadvantages include:

Doesn’t enforce security practices
HTTP method limits you to synchronous requests
Due to statelessness, you might be unable to maintain state (e.g. in sessions)

11. What's the difference between AJAX and REST?

The distinction can confuse beginner developers, so it’s helpful to know the difference.

An AJAX client can make a RESTful request to a REST API (e.g. a get request), but AJAX isn’t an architectural style. It’s a web development technique for client-side applications. REST APIs can be accessed by AJAX clients, but they aren’t inherently implemented with AJAX.

12. What's the difference between SOAP and REST?

Although some REST APIs use SOAP protocols, REST and SOAP are entirely different approaches to building APIs. Interviewers may ask this to assess your depth of understanding.

Here are some of the differences between SOAP and REST.
SOAP:

Protocol
Data format is limited to XML
Heavyweight and requires more bandwidth
Calls can’t be cached

REST:

Architectural style
Allows various data formats including plain text, HTML, XML, JSON, and YAML
Lightweight and requires less bandwidth
Calls can be cached

13. Explain HTTP response status codes.

HTTP response codes indicate the result of client requests.

Common HTTP status codes include:

200: Successful request
201: Entity or entities created from successful request
400: Bad request. Invalid client request.
401: Unauthorized. User isn’t authorized to access a resource and may be unauthenticated
403: Forbidden. User isn’t authorized to access a resource, user is authenticated
404: Not found. Resource not found
500: Internal server error. Generic server error
502: Bad gateway. Response from upstream server is not valid
503: Service unavailable. Result of server-side issue, including overload or system failure

Wrapping up and next steps

Congratulations! You’re now prepared with some common REST API interview questions and answers. Where you go from here depends on your goals.

For interview prep, check out Interview Prep with Educative. Here, you’ll find all our resources for interview prep in one place, from tutorials and practice problems, to tips from industry experts.

To get hands-on with REST APIs, check out one of our interactive REST API courses:

Happy learning!

Continue reading about APIs and interview prep on Educative

Start a discussion

Which REST API interview questions are you practicing? Was this guide helpful? Let us know in the comments below!

4 questions to ask in interviews to assess codebase health

Erica V — Thu, 13 Jan 2022 23:33:34 +0000

We all love good, quality code – and if we don’t, we should. Code that is consistent, clean, and easy to understand is essential to a healthy codebase. A healthy codebase is one that’s optimized for testability, maintainability, and scalability. It helps programmers code more efficiently and makes engineering teams more productive.

The health of a company’s codebase plays a large role in employee satisfaction. Unfortunately, the pressure to quickly add new features imposes harsh deadlines on programmers. The trade-off is a decrease in code quality. This is the reality of the software development world. We can expect a level of imperfection in any company’s codebase, but the important thing is how responsible a company is about resolving or preventing the damage that results from pushing rapid development.

When interviewing to find a developer job you love, there are questions you can ask to get a sense of their codebase health. By asking these questions, you can feel more confident about your interest in the company and the long-term sustainability of your work there.

We’ll cover:

Nursing healthy code and managing technical debt
4 questions to ask in interviews to assess codebase health
Wrapping up and next steps

Nursing healthy code and managing technical debt

To help foster a healthy codebase, companies need to have a regular cadence and strategy with which they manage technical debt. Technical debt refers to the time, money, and resources that are lost in exchange for hasty development. This can consist of code debt, design debt, and documentation debt. By asking their engineering teams to churn out functionalities at a rapid pace, any company can expect to incur technical debt. What’s important is that companies take measures to prevent and pay it off.

A developer-centric company must prioritize managing technical debt, not only for their financial gain but for employee satisfaction and retention as well. An unhealthy codebase is a thorn in the side of many programmers and software engineers. In a 2021 study by Stepsize, 51% of developers confirmed that they had left or considered leaving a company because of technical debt.

4 questions to ask in interviews to assess codebase health

There are questions you can ask in your interview to get a sense for the health of the company’s codebase. Many companies have room for improvement, and these answers don’t have to make or break your decision. While they may not have all the best practices in place, many interviewers would be impressed to have a candidate who is concerned and knowledgeable about matters concerning technical debt.

Note: Be mindful of your tone when asking questions. Come from a place of curiosity rather than judgment. You never know where a company or startup is in their growth.

1. What is your strategy for dealing with technical debt?

This is a high-level question that can give you a sense for how robust a company’s strategy is for managing technical debt. At the very least, your interviewer's answer shouldn’t deny that their company incurs technical debt. At most, it should show that that leadership balances adding new features with repaying technical debt. We hope you’ll hear a well-rounded strategy ranging from code reviews to communication pipelines and incentivizing programmers to clear debt.

2. Do you conduct code reviews?

Despite being a best practice for maintaining code quality and scalability, not every company conducts code reviews. We hope you’ll hear a yes. Code reviews reduce bugs, facilitate optimization, and helps peers share knowledge and skills.

If they conduct code reviews, you can ask additional questions:

What does your approach look like? Some do formal line-by-line reviews, others do informal “check-in buddies,” while others leverage Git to do a code review for all pull requests. It’s worth clarifying if they review code for all projects, as some only prioritize the most “critical” ones.
How are priorities determined? Ideally, the code review’s priorities are informed by a knowledge of the technical debt they’ve recently incurred. The best code reviews will prioritize code quality and coding best practices such as commenting, rather than simple adherence to company or team coding standards.
Who is reviewing the code? Gold stars can be given if code is given a most objective review by peers who aren’t involved in the project. If not, that’s okay too. Again, we have an ideal world, and a realistic one.

3. Do you have CI/CD pipelines?

Not all companies have CI/CD pipelines, but the most successful software development companies do. In a perfect world, CI/CD pipelines should be consistent across all projects and tech stacks. CI/CD pipelines helps teams ship new features faster, increases visibility and collaboration, and helps ensure continuous reliability. A CI/CD pipeline automates CI/CD, which frees up developers' time to focus on, well, development.

4. How much time is spent refactoring code?

Refactoring code reduces code complexity and supports the maintainability, security, and scalability of an application. Refactoring is an ongoing part of the development process. In addition to writing and testing, refactoring is likely to take a good amount of your time. Ask this question to get a sense for how frequently it's done and how it's built into the development process.

Wrapping up and next steps

The better the code health of a company, the more productive you and your team members will be. How a company balances adding new features with managing technical debt will be crucial to fostering a healthy codebase. It allows for effective long-term development – and happier and more productive engineering teams.

To help developers level up in their careers, we’ve gathered all our interview prep resources in one place at Interview Prep with Educative. You can find company-specific interview guides, coding interview tutorials, advice from industry experts and more.

Happy learning!

Continue learning about interview prep on Educative

Start a discussion

What questions would you ask to get a feel for a company's codebase health? How have your employers managed technical debt? Let us know in the comments below!

Is C++ an object-oriented programming language?

Erica V — Wed, 12 Jan 2022 00:04:41 +0000

Object-oriented programming (OOP) is one of the most popular programming paradigms. The C++ programming language is one of many languages that supports object-oriented programming, alongside Java, C#, Python, and JavaScript. Some developers consider C++ to be an object-oriented language, while others argue that it’s not. Today, we’ll discuss object-oriented programming to understand whether C++ is an object-oriented programming language.

We’ll cover:

What is object-oriented programming?
Is C++ an object-oriented programming language?
Object-oriented programming in C++
Wrapping up and next steps

What is object-oriented programming?

Object-oriented programming is a programming paradigm based on classes and objects and four OOP concepts of inheritance, encapsulation, abstraction, and polymorphism. OOP is modeled off the fact that the real world consists of objects, rather than the variables and functions we use in software development. In OOP, each object has properties and functions that it can perform. Objects that share properties and functions can be grouped into classes and subclasses, which serve as blueprints for the properties and functions that an object will inherit.

The foundational OOP concepts are:

Inheritance: The ability of a class to inherit data and behaviors from another class
- The class that inherits features is the derived class, while the class it inherits features from is the base class
Encapsulation: The binding of data to the functions that can perform operations on them
- Enables data hiding, another important OOP technique
Abstraction: The masking of internal functions to present only high-level methods to the user
Polymorphism: The ability to perform the same task in various ways

Consider a sparrow and a penguin. Both have eyes, but they don’t share the ability to fly. Not all birds share the function of flight, therefore the base class of birds wouldn’t assign the function of flight, but the derived classes of flying birds would assign the flying function.

The following diagram illustrates the example of a birds class. Inheritance is what allows the derived classes to adopt the properties and functions from the base class.

Another feature of object-oriented languages is that their syntax allows keywords to restrict and define access to classes, methods, and other members. These keywords are known as access specifiers (or access modifiers), which are essential to implementing encapsulation and abstraction.
The benefits of OOP are numerous. We can leverage OOP to develop applications with less code. Object-oriented programming helps reduce repetition in code, which reduces code complexity and data redundancy. It also increases the reusability of code. Users can create user-defined objects and classes which they can use in other applications.

Is C++ an object-oriented programming language?

C++ is widely considered an object-oriented programming language. Stroustrup developed C++ by adding object-oriented capabilities to the C programming language. When we say that a language is an object-oriented programming language, we often mean that it supports object-oriented programming. However, most popular languages that support OOP are not strictly object-oriented languages. They're often multi-paradigm languages that can support other popular paradigms. C++ falls into this category because it supports several paradigms. It's not an exclusively object-oriented language, but a functional and procedural language as well.

While it can be considered an OOP language, C++ isn’t a pure object-oriented language. Some reasons for this are:

Object is not a primary requirement: A pure OOP language treats all features in a program as objects. However, since C++ supports other programming paradigms, you can write a complete valid program without using a single object.
Class is not a primary requirement: The main() function can exist independent of a class.

Considering these points, it’s safe to say C++ is a partial object-oriented programming language.

Object-oriented programming in C++

C++ offers the essentials necessary to implement object-oriented programming. It has classes and objects, access specifiers, and the OOP concepts of inheritance, encapsulation, abstraction, and polymorphism.

Classes and objects

Classes are user-defined data types that form a blueprint for properties and functions. Objects are an instance of a class. Memory is allocated for objects, while classes don’t take up memory.

The syntax for class definition in C++ is:

class ClassName { 

  / *member variables and functions*/

}; // a semicolon ends the class

The syntax for creating a class object in C++ is:

class ClassName { 

 / *member variables and functions*/
};

int main () {
  int x; // integer object
  ClassName c; // ClassName object
}

Access specifiers

Access specifiers are keywords that serve to restrict and define permissions to access data in class members. There are three keywords that serve as access specifiers in C++: public, private, and protected.

Inheritance

We can implement inheritance in C++ by creating a derived class to a base class.
The syntax in C++ code for this is:

class DerivedclassName : AccessMode BaseclassName {
  // derived class body
}; // a semicolon ends derived class

Here, AccessMode indicates the type of access specifier.

Encapsulation

Encapsulation in C++ is implemented through class and access specifiers.

Abstraction

Access specifiers in C++ help implement abstraction using classes in C++. Header files in C++ are another form of abstraction through which we can implement function calls and methods without needing to know the algorithms guiding a function.

Polymorphism

There are two types of polymorphism in C++:

Compile time polymorphism: Achieved through function overloading or operator overloading
Run time polymorphism: Achieved through function overriding and virtual functions

Wrapping up and next steps

If you’re looking for a practical technique to help you write applications with less code, OOP is a great technique to leverage in C++. C++ can be considered an object-oriented language. While it might not be a pure object-oriented language, it was designed specifically to enable object-oriented programming.

To help you get started with object-oriented programming in C++, Educative has created the C++ for Programmers learning path. This learning path consists of six modules. It covers the basics of C++ and progresses up to cover OOP techniques, data structures, C++ templates, and more.

Happy learning!

Continue reading about C++ on Educative

Start a discussion

Are you interested in learning OOP? What are your thoughts on the debate of C++ being an OOP language? Let us know in the comments below!