In 2023, mobile apps are expected to generate a staggering $935 billion in revenue, with the Apple App Store and Google Play Store hosting nearly 2 million and 2.9 million apps respectively.

This booming ecosystem, however, is not without its challenges. Developers face the daunting task of crafting apps that perform seamlessly across multiple platforms, ensuring consistent user experiences while contending with the constraints of time and resources.

In this complex domain, Flutter emerges as a powerful solution, poised to tackle these challenges head-on. With its single codebase ethos, it has democratized mobile app development, offering a unified approach to creating expressive, compiled applications for mobile, web, desktop, and embedded devices. 

This article breaks down Flutter, how it works, its key features, and the skills required to harness its full potential. Whether you’re a hiring manager seeking to understand what Flutter brings to the table, a tech recruiter aiming to spot the right talent, or a tech professional evaluating the next skill to master, this article aims to illuminate the Flutter pathway and its significance in the field of app development.

Understanding Flutter

Flutter‘s journey from a nascent project named “Sky Engine” in 2015 to Google’s flagship framework for UI development has been marked by significant milestones. Officially released in 2017, Flutter set out to address a critical industry bottleneck: the complexity of crafting consistent, high-quality user interfaces across different platforms. It did so by leveraging the Dart programming language, which was chosen for its scalability, ease of learning, and ability to compile to ARM and JavaScript, thus offering both mobile and web compatibility.

As developers clamored for more efficient ways to build apps, Flutter’s promise of a single codebase for multiple platforms caught the industry’s attention. The framework’s ability to bypass traditional performance bottlenecks associated with cross-platform approaches solidified its reputation. 

Flutter’s significance is underscored by its adoption for major applications by global companies. It has not only streamlined the development process but also empowered smaller teams to build complex, reliable, and responsive applications that stand up to the demands of a diverse user base.

Flutter’s Architecture

Flutter is architecturally innovative, standing apart from other frameworks with its layered, modular approach that ensures maximum customization and fast rendering. The architecture is designed around a few core principles:

• The use of widgets as the fundamental building blocks of UI
• The employment of the Dart language for its performance and ease of use
• The incorporation of a reactive framework model that facilitates a declarative style of UI programming.

At the base of Flutter’s architecture is the engine, written primarily in C++, which provides low-level rendering support using Google’s Skia graphics library. This engine is the powerhouse of the framework, giving Flutter apps their renowned performance and crisp visuals.

Above the engine lies the Flutter framework, which is rich in pre-designed widgets that follow specific design languages, like Material Design for Android and Cupertino for iOS. These widgets are not just stylistic elements but encapsulate all the critical platform differences, allowing for apps that look and feel native on any platform.

The framework is organized into layers, with each layer building upon the foundation provided by the lower layers. At the top is the Material and Cupertino libraries, which provide high-level building blocks used directly by developers. Below that are the animation and painting layers that give developers precise control over the graphical and interactive aspects of an app. Even deeper, the rendering layer translates the widgets into lower-level geometry that can be painted onto the screen, and at the core, the widgets layer manages the layout and user interactions.

As we touched on briefly, developers interact with Flutter through the Dart language, which is optimized for building UIs that run smoothly at 60 frames per second. Dart’s reactive programming model, coupled with Flutter’s layered architecture, enables developers to create highly responsive and expressive user interfaces with ease.

Key Features of Flutter

Flutter’s draw lies in its array of features designed to tackle common development challenges while delivering high-quality applications. Key features include:

• Hot Reload: This feature is a game-changer for productivity, allowing developers to see the effects of their code changes in real time, without restarting the app or losing its state. It encourages experimentation and can significantly speed up the development process.
• Widget Catalog: Flutter’s extensive catalog of customizable widgets provides a fast track to creating beautiful and complex UIs that are consistent across platforms. From layout and navigation to functionality and aesthetics, these widgets cover virtually all aspects of app design.
• Cross-Platform Development: Flutter allows the same application to be deployed on iOS, Android, web, desktop, and embedded devices, with minimal platform-specific tweaking. This unified codebase methodology reduces complexity and streamlines the development workflow, resulting in considerable savings in time and resources.
• Performance: Flutter apps compile to native ARM code, which means they perform like native apps on both Android and iOS. Its performance is further enhanced by the Skia Graphics Engine, which allows for expressive UIs that run smoothly.

Flutter’s Advantages

The practical advantages of Flutter in mobile app development are diverse and impactful:

• Development Efficiency: Flutter significantly accelerates the development process with the ‘hot reload’ feature and its comprehensive set of fully customizable widgets. This efficiency is a boon for developers under tight deadlines and companies looking to reduce time-to-market.
• Consistency Across Platforms: The widget-centric design of Flutter ensures a consistent look and feel across multiple platforms, which is critical for brand identity and user experience.
• Performance: Apps built with Flutter are compiled to native ARM code, ensuring that they operate with the performance and speed of a native application.
• Community and Ecosystem: With strong backing from Google and a vibrant community, Flutter boasts a rich ecosystem of plugins and tools. The availability of a wide array of packages simplifies the incorporation of complex functionalities into applications.
• Ease of Integration: Flutter can be seamlessly integrated into existing systems, allowing businesses to leverage their current investments while modernizing their applications.

Skills Required for Flutter Development

Working with Flutter landscape requires a specific set of skills that go beyond general programming know-how. Essential technical and soft skills include:

• Proficiency in Dart: Understanding the syntax and concepts of Dart, Flutter’s programming language, is essential. It’s beneficial for developers to grasp object-oriented concepts, asynchronous programming, and the nuances of the Dart ecosystem.
• Understanding of Reactive Programming: Developers should be familiar with reactive programming concepts, which are central to Flutter’s architecture. This includes managing app state and understanding the stream of data within an app.
• Widget Lifecycle and UI Composition: Knowledge of how to compose and manage widgets — the core UI building blocks of Flutter — is crucial. Developers must understand the lifecycle of a widget to efficiently manage state and resources.
• Platform-Specific Expertise: While Flutter is cross-platform, familiarity with platform-specific APIs and tools can be important, especially when developing custom plugins or interfacing with native code.
• Adaptability and Problem-Solving: The ability to quickly learn and adapt to Flutter’s growing ecosystem is valuable. Developers should have strong problem-solving skills to tackle the unique challenges that arise during development.

These skills enable developers to fully leverage Flutter’s capabilities and create sophisticated, high-performance applications.

Flutter’s Role in Shaping the Future of App Development

Flutter has proven to be more than a fleeting trend in the tech industry. As of January 2023, one in five new apps on the Google Play Store use the framework, more than all other cross-platform frameworks combined. This surge in usage signals a broader shift toward more efficient, flexible, and expressive app development practices.

The framework’s commitment to facilitating a single-codebase environment without compromising on performance is resonating with the developer community. With its collection of widgets and tools, Flutter enables the creation of high-quality applications, while also streamlining the development process. As businesses continue to seek out cost-effective and time-efficient solutions for app development, Flutter’s advantages become increasingly relevant.

With its impressive adoption rates and commitment to continuous improvement, Flutter is poised for an expansive future in app development. It’s expected to see enhancements in performance and efficiency, and a broadening in the scope of supported platforms and devices, indicating its potential to surpass traditional mobile boundaries. For those looking to stay ahead in the dynamic field of app development, embracing Flutter’s innovative approach may well be the key to unlocking new opportunities and driving success in the mobile age.

This article was written with the help of AI. Can you tell which parts?

The post What Is Flutter? A Look at Google’s UI Powerhouse appeared first on HackerRank Blog.

In the world of software, application programming interfaces (APIs) act as the critical connective tissue, enabling different software systems to communicate and share data and functionalities. Take the example of a weather app on your phone. When you check the weather for your location, the app is likely making an API call to a remote weather service, pulling current conditions, forecasts, and other data right into the interface you see. That’s APIs at work.

But there are a number of different ways to approach building APIs, and each of these protocols follow a unique set of rules and standards. Among the most common API protocols employed today is REST.

Built on the foundational principles of HTTP, REST APIs have become a go-to choice primarily for their simplicity and adaptability. They are easy to understand, making the learning curve for developers relatively short. They are also highly scalable, an attribute that makes them perfect for both startups and large enterprises alike. Plus, because they are built upon HTTP, they integrate effortlessly with existing web infrastructure.

So, whether you’re a hiring manager assessing the essential REST API skills for your upcoming project, or a tech professional keen to master this widespread technology, this guide is your comprehensive resource. We’ll explore what a REST API is, how it operates, its fundamental design principles, and best practices. Additionally, we’ll delve into the key skills and tools developers need to work effectively with REST APIs.

What is a REST API?

In the early 2000s, a computer scientist named Roy Fielding introduced a term in his doctoral dissertation that would become foundational in modern web services: REST, or Representational State Transfer. From this concept arose what we now commonly refer to as RESTful APIs, which have become the de facto standard for building web services.

At its core, a REST API is a set of conventions and protocols for building and interacting with web services. It’s not a standard or a protocol by itself but rather an architectural style. Think of it as a set of guidelines for creating a smooth highway of communication between two different software applications.

The key components that define this architectural style are:

• Resources: Everything in a RESTful system is treated as a resource. It could be a user profile, a product in a store, or even a tweet on a platform. These resources are identified by URLs, just like how a web page has its unique address.
• Statelessness: This is one of the hallmarks of a REST API. Each request from a client to a server must contain all the information needed to understand and process the request. The server shouldn’t retain any client context between requests. This ensures scalability and simplicity.
• CRUD Operations: The essential operations one can perform on any data are create, read, update, and delete, often abbreviated as CRUD. In REST, these map to HTTP methods: POST (Create), GET (Read), PUT (Update), and DELETE (Delete).

For instance, let’s say you’re building an online bookstore. If you want to fetch details about a specific book, you’d make a `GET` request to a URL like `https://bookstore.com/api/books/123`. In this case, `/books/123` is the resource identifier for the book with an ID of 123.

While there are many types of APIs out there, such as SOAP or GraphQL, RESTful APIs have gained immense popularity due to their simplicity, scalability, and alignment with the way the web fundamentally operates.

How Does a REST API Work?

When we discuss the mechanics of REST APIs, the foundational element to grasp is the client-server architecture. Consider the workings of a restaurant. You (the client) make a request by placing an order, and the kitchen (the server) processes this order and delivers the dish to you. The interaction is clear, specific, and each party knows its role. Similarly, in the digital realm, a client (say, a mobile app) sends a request to a server, which processes the information and sends back a response, often in the form of data.

Let’s delve deeper into the mechanics of a REST API:

• Statelessness: We touched upon this earlier, but it’s crucial enough to reiterate. Statelessness means every request is an isolated transaction, independent of any previous requests. This principle is akin to having a fresh conversation each time you interact, without relying on past interactions. If a client needs data, it asks for it explicitly. And the server? It processes and returns just that, without “remembering” anything about the client.
• CRUD and HTTP Methods: At the base of REST API interactions are the CRUD operations. When you want to fetch (read) data, you use a `GET` request. When you want to add (create) new data, you use a `POST` request. Updates are done with `PUT` or `PATCH` requests, and deletions, as you might’ve guessed, use the `DELETE` method. Each of these corresponds to an action on the server-side. 
• Responses and Status Codes: After the server receives a request, it doesn’t leave the client hanging; it responds. Often, this response includes relevant data in formats like JSON or XML. Accompanying this data are HTTP status codes: short three-digit numbers indicating the result. For instance, `200` means “OK” (request successful), while `404` denotes “Not Found” (the resource doesn’t exist). These codes offer a quick way for clients to understand the outcome of their requests.

In essence, a REST API operates as a well-orchestrated dance. The client leads by making requests, and the server gracefully responds, ensuring data flows harmoniously between different software entities.

Key Features and Design Principles of REST API

The beauty of REST lies not just in its functionality but also in its guiding principles. While many of these principles are technical, think of them as a set of best practices that ensure REST APIs are standardized, efficient, and easy to use. Let’s dissect some of these core principles.

• Uniform Interface: This is the cornerstone of any RESTful web service. The idea is to have a consistent interface, ensuring interactions are uniform across different parts of an application. For example, if you’re fetching book data, the endpoint might be `https://bookstore.com/api/books`. If you’re retrieving author data, it could be `https://bookstore.com/api/authors`. Notice the consistency?
• Stateless Operations: As emphasized before, each request from client to server must contain all the info necessary to understand and process that request. Imagine going to a coffee shop and ordering a latte. If, on your next visit, you just said “the usual,” but the barista had no memory of you, you’d need to specify your order again. That’s statelessness in action.
• Client-Server Architecture: By segregating the user interface from the data storage and processing, we ensure that each can evolve independently. It’s like having a separate kitchen and dining area in a restaurant. Diners don’t need to know the kitchen’s operations, and chefs don’t dictate where diners sit.
• Cacheable Data: Caching is the practice of storing data in a cache so that future requests for that data can be served faster. In REST, responses from the server can be labeled as cacheable or non-cacheable. When data is cacheable, clients can reuse earlier responses to improve performance and reduce server load. It’s akin to keeping your favorite snacks at hand rather than fetching them from the store every time you’re hungry.
• Layered System: This principle stipulates that a client cannot, and should not, distinguish whether it’s directly connected to the end server or an intermediary. This abstraction allows for load balancing, shared caches, and more, all leading to optimized performance.
• Code on Demand (optional): While not always used, this principle allows servers to extend a client’s functionality by transferring executable code. Imagine if, along with your restaurant dish, you received a mini recipe card, allowing you to recreate that dish at home!

Adhering to these principles doesn’t just make an API RESTful; it ensures that the API is robust, flexible, and primed for the challenges of modern web applications.

Best Practices for Designing REST APIs

Designing a REST API isn’t just about ensuring it functions; it’s about crafting an experience for developers. Just as a master chef ensures both taste and presentation, an effective REST API should be both functional and intuitive. Here are some golden rules and best practices to keep in mind:

• Use Meaningful HTTP Verbs: The HTTP protocol offers verbs like `GET`, `POST`, `PUT`, and `DELETE` that map perfectly to CRUD operations. Ensure these verbs are used appropriately. For example, a `GET` request should only retrieve data and never modify it.
• Consistent Naming Conventions: Choose a convention and stick to it. If you’re using `camelCase` for one endpoint, don’t switch to `snake_case` for another. Also, aim for intuitive names. `/getAllUsers` is more self-explanatory than `/gAU`.
• Version Your API: As your API evolves, changes can break applications that depend on it. By versioning your API, for example, using a structure like `/v1/users`, you ensure older versions still function while allowing for enhancements.
• Graceful Error Handling: When something goes wrong, offer clear feedback. Instead of a vague `400 Bad Request`, provide details like `Missing field ‘username’ in the request body.`
• Prioritize Security: Always use HTTPS for encrypted connections. Implement authentication and authorization methods like OAuth to ensure only authorized users can access and modify data.
• Support Pagination, Filtering, and Sorting: For APIs that can return a large amount of data, these features are essential. Instead of overwhelming a client with 10,000 book entries, offer them in pages of 50, with the ability to sort by title or filter by genre.
• Maintain Good Documentation: An API is only as good as its documentation. Tools like Swagger or Redoc can help generate interactive docs, making life easier for developers trying to integrate with your API.
• Avoid Exposing Database IDs: Instead of directly exposing database primary keys, consider using UUIDs or slugs. This makes the API cleaner and abstracts away direct database references, adding a layer of security.
• Rate Limiting: Especially for public APIs, setting limits on how many requests a user or IP can make in a certain time frame can help protect your system from abuse or overuse.
• Caching Mechanisms: Speed up frequent and repeated requests by implementing caching mechanisms like ETag headers or tools like Redis.

Key REST API Development Skills and Tools

Skills

• Understanding of HTTP Protocol: Before diving into APIs, get a solid grasp of HTTP — how requests and responses work, status codes, headers, methods, and so forth.
• Proficiency in a Programming Language: Whether it’s Python, Ruby, Java, or JavaScript, you’ll need to be comfortable in at least one programming language. This isn’t a one-size-fits-all scenario; the language often depends on the specific requirements of your project.
• Data Handling Skills: JSON or XML are commonly used data formats in REST APIs. Knowing how to parse these formats or convert them into usable forms in your chosen programming language is crucial.
• Authentication and Authorization: Master the basics of securing APIs through methods like JWT (JSON Web Tokens), OAuth, or API keys.
• Database Knowledge: You don’t need to be a database admin, but understanding how databases interact with your API, be it SQL or NoSQL, can give you a significant edge.

Tools

• Postman: From testing endpoints to automated testing, Postman has features that simplify the API development process.
• Swagger: An excellent tool for API documentation, it also allows for endpoint testing directly from the documentation, enhancing developer experience.
• Git: Version control is an essential part of any development process, and REST API development is no exception. Git enables collaboration and version tracking.
• Docker: For containerizing your API and ensuring it runs the same way across different computing environments, Docker is invaluable.
• API Gateways: Tools like Kong or AWS API Gateway help manage your API by handling authentication, rate limiting, analytics, and more.
• Monitoring Tools: Implementing real-time monitoring through tools like Grafana or Datadog can help you track how your API is used and alert you to any issues that need attention.

Key Takeaways

By now, you should have a well-rounded understanding of what REST APIs are, how they function, the principles that guide their design, the best practices for crafting a great API, and the essential skills and tools that can make your REST API journey a resounding success.

Whether you’re a hiring manager looking to make informed decisions, or a developer eager to dip your toes into the world of APIs, a strong grasp of REST can only be an asset. These APIs are the engines behind much of the digital transformation we’re witnessing today. They’re empowering businesses to integrate, innovate, and scale like never before.

This article was written with the help of AI. Can you tell which parts?

The post What Is a REST API? Bridging the Gap Between Software appeared first on HackerRank Blog.

In the dynamic field of web development, some languages flash brightly and then fade, while others become integral technologies. PHP, the powerful scripting language behind a staggering 77.4 percent of all websites with a known server-side programming language, belongs decisively to the latter category. Yet, despite its ubiquity, the full depth of PHP’s capabilities often remains underexplored and underappreciated.

Tracing the evolution of PHP from its inception as a simple set of Common Gateway Interface binaries to its current status as a critical pillar of web development reveals a compelling tale of resilience and adaptability. PHP’s journey reflects not only its inherent strengths — ease of use, flexibility, and compatibility with numerous databases and operating systems — but also its ability to stay relevant and useful in an ever-changing technological landscape.

In this comprehensive exploration of PHP, we’ll shed light on its key features, diverse applications, and the current hiring landscape for PHP professionals. Whether you’re a tech professional looking to enhance your skills or a hiring manager seeking to understand the language’s relevance, this deep dive will deliver valuable insights into the language that revolutionized web development. 

Understanding PHP: The Basics

PHP, short for Hypertext Preprocessor (though it originally stood for Personal Home Page), is an open-source server-side scripting language. It’s designed to create dynamic web pages and applications. Embedded within HTML code, PHP allows developers to add intricate functionality directly into their web pages, seamlessly bridging the gap between static HTML and dynamic content.

PHP was created in 1994 by Rasmus Lerdorf, initially as a set of Perl scripts he used to maintain his personal website. Over the years, PHP has developed into a full-fledged programming language, with a large community of developers constantly contributing to its growth and improvement. 

One key distinguishing feature of PHP is its server-side nature. This means it runs on the web server, rather than the user’s device. This offers PHP a powerful edge in terms of processing capabilities — it can interact with databases, manage files on the server, and perform a host of other tasks that client-side languages cannot handle.

This fundamental quality allows PHP to generate dynamic content on websites — everything from real-time data updates to personalized user experiences. In fact, it’s this dynamic content generation that’s behind PHP’s vast popularity in web development.

Unpacking PHP: Key Features and Advantages

PHP’s widespread use and popularity aren’t just a matter of happenstance. It’s earned its place in the web development world through a rich set of features and advantages that cater to a wide range of applications and user needs.

Simplicity and Flexibility

At the heart of PHP is a commitment to simplicity and flexibility. Its syntax is straightforward, making it easy to pick up, especially for those with a background in C or JavaScript. But don’t let that fool you into thinking PHP can’t handle the heavy lifting. It’s an incredibly flexible language, able to adapt to a range of applications, from small personal websites to complex web applications.

Compatibility

Compatibility is another key advantage that PHP brings to the table. It’s platform-independent and can run on most operating systems, including Windows, Linux, and MacOS. Moreover, PHP plays well with other technologies. It can easily be embedded in HTML code, and it supports a wide range of databases, making it a versatile tool for web development.

Community and Library Support

PHP has a strong, vibrant community that’s constantly working on improvements and additions to the language. This means regular updates, patches, and new features that keep PHP relevant and powerful. Moreover, if you’re ever stuck on a PHP problem, there’s a good chance someone in the community has already found a solution and is ready to help.

The PHP community has also contributed to an extensive library of tools and resources that can make your work even easier. From pre-built modules to handle common tasks to frameworks that provide structured environments for building robust applications, PHP’s library support is a gold mine for developers.

PHP at Work: Practical Use Cases and Applications

PHP is more than just a scripting language. It’s a versatile tool that’s found its place in a variety of applications. Let’s explore how PHP is put to work across different scenarios.

Powering the Web: Websites and Content Management Systems

PHP’s first claim to fame is in web development, where it’s used to build a significant number of websites on the internet. Household names like Facebook and Wikipedia are built on PHP, a testament to its capacity for building large-scale, high-traffic websites.

And it’s not just massive sites that lean on PHP. Content Management Systems (CMS) like WordPress, Joomla, and Drupal use PHP as their backbone. These systems power millions of smaller websites and blogs, providing user-friendly interfaces for managing content — all thanks to PHP’s flexibility and ease of use.

Delivering Dynamic Content: Web Applications and User Interaction

PHP shines when it comes to creating dynamic web page content and interactive applications. Online forms, shopping carts, user registration systems, and more — all these can be built using PHP. Its compatibility with a wide range of databases means PHP is often the go-to language for creating and managing data-driven websites and applications. 

Beyond the Web: Server-Side and Command-Line Applications

While PHP is best known for its role in web development, its capabilities don’t stop there. It’s also used for server-side scripting, automating tasks that would be tedious or impractical to do manually. 

PHP is even used for command-line scripting, allowing developers to run PHP scripts directly from the system command prompt. And while it’s not as common, PHP can even be used to develop desktop applications. This versatility makes PHP a multifaceted tool, useful in a broad array of programming scenarios.

The Current Hiring Outlook for PHP Professionals

Now that we’ve explored the world of PHP in detail, it’s time to talk about why it matters to you. Whether you’re a tech professional considering learning PHP or a hiring manager looking for in-demand skills, understanding the job market for PHP professionals is crucial.

Demand for PHP Developers

Despite the rise of new technologies and languages, PHP remains a staple in the tech industry, and the demand for PHP professionals continues to grow. Websites, especially those built on popular content management systems like WordPress, need skilled PHP developers for customization, maintenance, and improvement.

The versatility of PHP, as we’ve explored in the previous sections, also contributes to its demand. Professionals who can leverage PHP’s capabilities in web applications, server-side scripting, and even command-line applications are valuable assets in many different sectors.

Industries and Companies Hiring PHP Developers

The industries hiring PHP developers are as varied as PHP’s applications. Tech companies, marketing agencies, media organizations, educational institutions, and more all look for PHP skills. And of course, any company with a significant web presence, such as e-commerce companies, often have in-house PHP developers.

Furthermore, PHP developers often find opportunities in freelance and remote work. Given the nature of PHP work — often revolving around web development — many tasks can be done from anywhere, making PHP skills useful in the growing gig economy.

Keeping Skills Up to Date

One of the keys to staying competitive in the PHP job market is keeping your skills up to date. PHP, like many technologies, is continuously evolving. Following PHP’s updates, learning new features, and understanding the best practices is crucial for PHP developers. Thankfully, PHP’s active community and extensive online resources make it easier to stay on top of these changes.

Key Takeaways

As you can see, PHP is far more than just a scripting language used to create dynamic web pages. It’s a versatile, robust tool that holds significant sway in web development, powering platforms from small personal blogs to social media giants.

With PHP’s adaptability across various applications and the sustained demand for PHP skills in the job market, this programming language holds a unique and valuable place in the technological landscape. PHP offers myriad opportunities for both tech professionals looking to broaden their skill set and organizations aiming to strengthen their capabilities. 

Despite the emergence of new technologies, PHP has stood its ground, proving its resilience and relevance. PHP remains a reliable constant — a testament to its power, versatility, and enduring importance.

This article was written with the help of AI. Can you tell which parts?

The post What Is PHP? Inside the Language That Revolutionized Web Development appeared first on HackerRank Blog.

Software engineering and software development are two of the most in-demand careers in the tech industry. And with the U.S. Bureau of Labor Statistics projecting the number of software jobs to increase by 25 percent over the next decade, demand for these skilled professionals will only grow. 

But there is often confusion between the roles of software engineers and software developers. While the two terms are often used interchangeably, they can actually refer to distinct roles with unique skill sets and responsibilities. Understanding the differences between software engineers and software developers is crucial for both hiring managers and early career professionals looking to navigate the industry. 

Whether you’re looking to hire a software engineer or software developer, or you’re interested in pursuing a career in software development, this article will help you gain a better understanding of the skills and responsibilities associated with each role, leaving you equipped to make more informed hiring decisions or chart a career path that aligns with your strengths and interests.

What is a Software Engineer?

A software engineer is a professional who applies engineering principles to the design, development, testing, and maintenance of software. The role of a software engineer is often focused on the bigger picture of a software system and typically involves a high degree of problem-solving, as well as collaboration with other members of a development team. 

Responsibilities of a Software Engineer

The responsibilities of a software engineer can vary depending on the size and scope of the organization they work for, as well as the specific project they are working on. However, some common responsibilities of a software engineer may include:

• Designing and developing software applications and systems
• Overseeing the strategic planning and management of software projects
• Working with stakeholders to ensure software requirements are met
• Writing and testing code to ensure software quality and reliability
• Collaborating with team members to solve technical challenges
• Writing automated tests to ensure software quality and reliability
• Conducting research and staying up-to-date on industry trends and best practices
• Designing and implementing algorithms to solve complex problems
• Participating in code reviews and providing feedback to colleagues

Unique Skills Required for a Software Engineering Role

Software engineering requires a unique set of skills that go beyond technical know-how. A software engineer must also be able to work well with others, communicate effectively, and think critically. Some of the key skills required for a software engineering role include:

• In-depth knowledge of programming languages, frameworks, tools and operating systems
• Familiarity with software engineering best practices and methodologies 
• The ability to apply engineering principles to software creation 
• Experience debugging software and systems

• Communication and collaboration skills
• Proficiency in advanced mathematics 
• Strong problem-solving abilities
• Project management skills 
• Leadership skills 

What is a Software Developer?

A software developer is a professional who is responsible for writing, testing and maintaining software code. The role of a software developer is primarily focused on the technical aspects of software development, such as coding and debugging. So, where a software engineer is often focused on the design, development and testing of entire computer systems, a software developer may focus more on specific applications or parts of the software. Many software developers even specialize in certain programming languages or types of development — like mobile, front-end or web — in order to set themselves apart in the job market and gain greater expertise in the tools of their trade. 

Responsibilities of a Software Developer

Just like with software engineers, the responsibilities of a software developer can vary depending on the organization they work for, as well as the specific project they are working on. However, some common responsibilities of a software developer may include:

• Writing, testing and debugging code for software applications
• Collaborating with other members of a development team to solve technical challenges
• Participating in code reviews and providing feedback to colleagues
• Staying up-to-date on industry trends and best practices
• Working with end-users to identify software needs and requirements
• ​​Writing automated tests to ensure software quality and reliability

Unique Skills Required for a Software Development Role

Software development requires a unique set of skills that are focused on technical abilities and attention to detail. While a software developer must be able to work well with others and communicate effectively, their primary focus is on writing high-quality code. Some of the key skills required for a software development role include:

• Strong coding skills in one or more programming languages
• Attention to detail and a focus on writing high-quality code
• Knowledge of software development best practices and methodologies
• Ability to connect the big picture to the smaller components of a system or application
• Familiarity with software testing and debugging processes
• Knowledge of algorithms and data structures 
• Time management skills
• Creativity

What are the Differences Between a Software Engineer and a Software Developer?

While the terms software engineer and software developer are often used interchangeably, there are noteworthy differences between the two roles.

Scope of Work

The primary distinction between software engineers and software developers is in the scope of their work. Software engineers focus on the big picture — the entire software development life cycle – from requirements planning and analysis to the testing and deployment of new software. They leverage their extensive knowledge of programming languages, computer operating systems, advanced mathematics, and software development best practices to determine the best way to build and maintain complex software systems. Software engineers focus on, for example, how, where, and what data is stored. Or what tools to use to ensure a smooth integration with the existing codebase. 

Software developers, on the other hand, focus on the “development” phase of the software development life cycle. Their work involves building the individual components of a software system — often components they have specialized knowledge in – like front-end or back-end systems or mobile applications. They work with engineers to understand the requirements and design specifications, and then implement them.

Think of it like a restaurant kitchen. Software engineers are like the head chefs, creating the menu, choosing ingredients that complement one another and determining the right methods for cooking and preparing the food. And software developers are like the line cooks. They take the head chef’s vision and bring it to life, executing the recipes to perfection.

Focus on Technical Skills

While both software engineers and software developers require strong technical skills, their different focuses lead to specialization in different skills.

Software engineers tend to be more involved in the early stages of software development, such as requirements gathering, system design, and architecture planning. This requires engineers to have greater proficiency in a range of programming languages, frameworks, tools, and operating systems, as well as a broad understanding of various methodologies, trends, and best practices. They need to know how all the moving parts will work together in order to design software systems that are scalable, maintainable and efficient. 

Software developers, on the other hand, tend to focus more on the coding and testing of smaller-scale projects and may work more closely with end-users to ensure the software meets their needs. While they may possess many of the same technical skills as an engineer, their knowledge tends to be more focused and specialized, giving them a deeper understanding of the limitations and possibilities of specific software tools or programming languages. They take an engineer’s design specifications and find the best way to implement them in the code.

Education and Training

Software development is often seen as a subset of software engineering, so when it comes to education and training, there can be a fair amount of overlap between software engineers and software developers. But the level of education and training required for these two roles can and often does differ. 

Given the broader scope of a software engineer’s work, they’re often required to have more comprehensive technical education. They learn how to apply engineering principles and the scientific method to the entire software development life cycle, and are educated in subjects like systems design and analysis, software validation and testing, and software architecture. Some companies may even require a bachelor’s or master’s degree in computer science, software engineering, or a related field. However, with the rise of engineering bootcamps and more accessible online learning resources, there are more opportunities than ever for engineers without traditional education backgrounds.

A software developer may choose to take a similar educational path as a software engineer, allowing them to work in either role, or specialize in a particular programming language or type of software development. While software developer roles are less likely to require a college degree, many developers still choose to pursue higher education for the strong skills foundation — and leg-up in the job search — that a degree can provide. However, given that software developers’ main focus is on writing high-quality code, they often need less education than an engineer, which can make it easier to get started in a career as a software developer — particularly for people who are self-taught or don’t have a traditional coding background. 

Job Titles and Roles

Another difference between software engineers and software developers is their job titles and roles within an organization. Software engineers are often seen as senior-level professionals who oversee the design and development of software systems and may be involved in managing other members of a development team. Software developers, on the other hand, are typically seen as entry- or mid-level professionals who are responsible for writing and testing code and may work under the guidance of a software engineer.

How to Choose the Right Role for Your Team

Despite these differences, the lines between software engineering and software development can sometimes be blurred, and many professionals have skills and experience in both areas. Many organizations use the terms interchangeably, and the roles and responsibilities of software engineers and software developers can overlap depending on the size and scope of the project they are working on. 

For hiring managers looking to add software professionals to their teams, the choice of which role to hire for will depend on the specific needs and goals of the organization, as well as the skills and experience of the candidates being considered. 

Remember: software engineers work on the macro-level, while software developers work on the micro-level. If the team is focused on large-scale and complex software development projects with multiple components and integrations, a software engineer may be the right choice. But if the team is focused on coding and testing, say, a new mobile application for an existing system, or needs someone with expertise in a specific programming language or framework, a software developer may be a better fit. 

The size of a company can also be a determining factor. Startups, for example, often operate with leaner teams, which means they need software engineers who can act as both engineer and developer. Enterprise businesses with more robust software teams generally have more resources available to hire both engineers and developers, which allows them to take advantage of the specialized knowledge developers can bring to the table. 

Key Takeaways

Whether you’re looking to hire software professionals or find your next great role, understanding the differences between a software engineer vs. a software developer can be the key to your long-term success. To learn more about the skills and competencies needed for a variety of technical roles and browse our library of up-to-date resources, check out HackerRank’s roles directory.

This article was written with the help of AI. Can you tell which parts?

The post Software Engineer vs. Software Developer: Is There Actually a Difference? appeared first on HackerRank Blog.

Artificial intelligence is no longer just a buzzword, but a powerful field that is changing the tech world in countless ways. From voice assistants and self-driving cars to personalized healthcare and fraud detection, AI is transforming industries — and technical teams — across the board. 

But perhaps no field will be as dramatically impacted by AI as software development itself.

For decades, software development has been a largely manual and labor-intensive process, with developers spending countless hours writing, debugging, and maintaining code. However, with the advent of AI, much of this work can now be automated, freeing up developers to focus on higher-level tasks that require their creativity and expertise. Moreover, AI is being used to enhance various aspects of software development, such as predicting and preventing bugs, generating code, and optimizing performance.

Whether you’re a hiring manager looking to hire the best talent for your AI and software development team, or a developer looking to stay ahead of the curve, this article will provide valuable insights and practical advice for navigating the exciting and rapidly-evolving world of AI and software development.

The Impact of AI on Software Development

AI is already having a significant impact on the software development landscape, and this impact is only expected to grow in the coming years. Some of the ways in which AI is transforming software development include:

• Automating Repetitive Tasks: As mentioned earlier, AI-powered development tools can help automate repetitive and time-consuming tasks, freeing up developers to focus on more complex and creative work. For example, AI can be used to generate code, detect bugs, and optimize performance, among other tasks.
• Improving Efficiency and Accuracy: AI can also improve the efficiency and accuracy of software development. By analyzing large amounts of data and identifying patterns and insights, AI can help developers make better decisions and avoid errors.
• Enhancing User Experience: AI can be used to create more personalized and intuitive user experiences. For example, chatbots powered by AI can help customers get answers to their questions quickly and easily, while recommendation engines can suggest products or services based on users’ preferences and past behavior.
• Enabling New Applications and Use Cases: Finally, AI is opening up new applications and use cases for software development. For example, AI-powered systems can be used for predictive maintenance, fraud detection, and even autonomous vehicles. In addition, tools like ChatGPT, which can assist with building websites and applications, and GitHub’s Copilot, which serves as an AI-pair programmer, are lowering the barrier to entry for people new to coding by providing real-time feedback and suggestions for how to improve their code and work more efficiently.

Overall, AI is transforming the software development landscape in profound ways, enabling developers to work more efficiently and creatively, and creating new opportunities for innovation and growth. However, with these opportunities also come new challenges and considerations.

Challenges and Considerations for Development in an AI-First World

While AI presents many opportunities for software developers, it also raises new challenges and considerations. Here are some of the key issues that developers must address in an AI-first world:

• Ethical and Legal Concerns: In an AI-first world, development teams will need to be able to identify and mitigate ethical concerns related to AI. Already U.S. regulators are examining ways to tackle the potential harm caused by AI, and these regulations will likely have a major impact on the way this technology is used and developed. AI software systems will need to be transparent, explainable, and fair, and comply with all relevant regulations and standards.
• Bias and Discrimination: AI-powered systems can perpetuate or even amplify biases, leading to discrimination against certain groups of people. Development teams will need to be vigilant in identifying and mitigating these biases, and ensure that their systems are inclusive and accessible to all users.
• Data Privacy and Security: AI relies on large quantities of data, and developers must ensure that this data is collected, stored, and used in a secure and responsible manner. They also have to protect users’ privacy and sensitive information, and comply with data protection regulations.
• Skills and Training: Developing and implementing AI-powered systems requires a different skill set than traditional software development. Development teams will need to hire or retrain for skills in data science, machine learning, and AI-powered development tools.
• Scalability and Maintenance: Finally, AI-powered systems can be complex and difficult to maintain, particularly as they scale up and handle larger amounts of data and users. Developers must design their systems with scalability and maintenance in mind, and implement strategies to ensure that they remain reliable and efficient over time.
• Collaboration With Data and AI Teams: In an AI-first world, developers will need to work more closely with data scientists and machine learning engineers to develop and implement AI-powered applications. This requires a good understanding of the principles and tools of data science and machine learning, as well as the ability to work with big data and advanced analytics.

By addressing these challenges and considerations, development teams can ensure that their AI-powered systems are effective, ethical, and secure, and can drive real value for users and organizations. However, doing so will require a collaborative and multidisciplinary approach, with input from machine learning engineers, data scientists, legal experts, and other stakeholders.

AI-First Companies and the Implications for Developers

In recent years, we have seen the emergence of a new type of company – the AI-first company. These are organizations that prioritize the use of AI and data-driven insights to power their business models, operations, and strategies. Examples of AI-first companies include Google, Amazon, Facebook, and Microsoft.

AI-first companies operate differently from traditional companies in several key ways. First, they are more data-driven, using AI to analyze vast amounts of data and generate insights that drive business decisions. Second, they are more agile and adaptable, using AI to quickly respond to changing market conditions and customer needs. They are also more customer-centric, using AI to personalize and optimize the customer experience.

For developers, this shift towards AI-first companies presents both new opportunities and challenges. On the one hand, AI-first companies require developers with strong skills in machine learning, data analytics, and software engineering to build and maintain their AI-powered systems. These companies also value developers who are creative, innovative, and able to work collaboratively across teams and domains.

On the other hand, AI-first companies can also present challenges for development teams. For example, they may require developers to work with large and complex datasets, which can be daunting for those without a strong background in data management. Additionally, they may require developers to work within a fast-paced and constantly evolving environment, where new tools and technologies are being developed and deployed on a regular basis.

To succeed in an AI-first company, developers need to be adaptable, open-minded, and willing to learn and experiment with new tools and technologies. Some of the technologies that are most valuable to AI-first companies include:

• Deep learning frameworks like TensorFlow and PyTorch
• Natural language processing libraries like NLTK and SpaCy
• Big data processing tools like Apache Spark and Hadoop
• Cloud computing platforms like Amazon Web Services and Microsoft Azure
• Software development best practices like agile development, DevOps, and continuous integration/continuous deployment (CI/CD)

Key Takeaways

The rise of AI-first companies is transforming the software development landscape, creating new opportunities and challenges for developers. By staying abreast of the latest trends and developments in this space, developers can position themselves to thrive in this new and exciting era of software development.

At HackerRank, we understand the importance of developing and nurturing the skills of today’s developers, especially in the emerging field of AI and machine learning. That’s why we created a roles directory that helps hiring managers and tech professionals explore various job families and tech roles. Want to learn more about the real-world skills driving the future’s innovation? Visit our roles directory today.

The post How AI Is Shaping the Future of Software Development appeared first on HackerRank Blog.

Artificial intelligence is rapidly advancing and becoming more prevalent in our daily lives. From chatbots to autonomous vehicles, AI is changing the way we interact with technology. 

But creating AI-powered systems is not a simple task. It requires a specialized skill set to build AI platforms. 

That’s where AI engineering comes in. 

Defining AI Engineering

AI engineering is the process of designing and developing intelligent systems and applications that can learn and adapt from data. AI engineers use various techniques such as machine learning, deep learning, natural language processing, and reinforcement learning to build intelligent systems that can perform complex tasks, such as image recognition, speech recognition, text analysis, and decision-making.

Machine Learning vs AI Engineering

You might be wondering, “Wait, isn’t that just machine learning?” Fair question. Because AI is an evolving field, the exact definitions of and relationship between the machine learning and AI engineering disciplines can be confusing.

Generally speaking, machine learning and AI engineering are two related but distinct fields within the broader field of artificial intelligence. You can also think of machine learning as an important tool used by AI engineers to build intelligent systems, making it one part of the broader field of AI engineering.

Machine learning is a subfield of AI that focuses on developing algorithms that can learn from and make predictions or decisions on data without being explicitly programmed to do so. In other words, it is a set of techniques that enable machines to learn from data and improve their performance on specific tasks over time. Machine learning techniques include supervised learning, unsupervised learning, reinforcement learning, and deep learning.

AI engineering, on the other hand, is the broader field that encompasses the development, deployment, and maintenance of AI systems. It involves applying the principles of software engineering to build robust, scalable, and maintainable AI systems. AI engineering includes designing and implementing AI models, deploying them in production environments, and managing the data infrastructure needed to support the models. It also involves ensuring that the AI system is secure, reliable, and efficient.

In essence, machine learning is a subfield of AI that focuses on the development of algorithms that enable machines to learn from data, while AI engineering is the application of software engineering principles to build and deploy AI systems. 

How AI Engineering Works

The process of AI engineering typically involves the following stages:

Problem identification: The purpose of any AI model is to solve a business or consumer problem. To develop a successful AI model, engineers start by identifying the exact pain point the AI will solve. For example, many knowledge workers have trouble keeping up with tight production schedules. Conversational AI models like ChatGPT solve this problem by automating labor intensive tasks like coding, writing, and research.

Data collection: AI engineering begins with the collection of relevant data from various sources. The data can be in different formats such as text, images, audio, or video. The quality of the data is crucial as it affects the accuracy of the AI-powered system.

Data preprocessing: The collected data needs to be cleaned and preprocessed to remove any noise or inconsistencies. The data is then transformed into a format that can be used for training and building AI models.

Algorithm Development: AI engineers use various machine learning algorithms such as regression, clustering, classification, and neural networks to build intelligent systems. The choice of algorithm depends on the nature of the problem and the type of data being used.

Model Training: Once the algorithm is selected, the next stage involves training the model using the preprocessed data. The model is trained using various optimization techniques to improve its accuracy and performance.

Model Evaluation: After the model is trained, it needs to be evaluated to ensure that it performs well on new data. AI engineers use various evaluation metrics such as precision, recall, and F1 score to assess the performance of the model.

Deployment: The final stage of AI engineering involves deploying the model in a production environment. The model needs to be integrated with other systems and tested to ensure that it works correctly.

AI Engineering Skills

AI engineering is a multidisciplinary field that requires expertise in various areas such as computer science, mathematics, statistics, and domain knowledge. Here are some of the essential skills required to become an AI engineer.

Programming

AI engineers need to have a good understanding of programming languages such as Python, R, and Java, as well as machine learning libraries like TensorFlow and PyTorch.

Mathematics and Statistics

A strong foundation in mathematics and statistics is essential for AI engineering. AI engineers need to be proficient in calculus, linear algebra, probability, and statistics.

Machine Learning

AI engineers need to have a deep understanding of machine learning algorithms and techniques such as deep learning, supervised and unsupervised learning, reinforcement learning, and neural networks.

Data Analysis and Management

AI engineers need to be skilled in data analysis and management, including data cleansing, pre-processing, feature extraction, and data visualization.

Problem-Solving Skills

AI engineers must be adept at problem-solving and troubleshooting. They need to be able to analyze complex problems, identify potential solutions, and test and implement the best approach.

Communication Skills

AI engineers need to be able to communicate technical concepts and ideas to both technical and non-technical stakeholders.

Creativity

AI engineers must be creative and have a strong imagination to come up with innovative solutions to complex problems.

Domain Knowledge

AI engineers must have domain knowledge in the area they are working on. For example, a healthcare AI engineer would have knowledge of healthcare processes and regulations.

Continuous Improvement

AI is a fast-evolving field, so AI engineers need to be committed to continuous learning to keep up with new technologies and techniques.

Collaboration Skills

AI engineering is often a team effort, so AI engineers need to be able to work collaboratively with other team members, such as data scientists, product managers, and business stakeholders.

Conclusion

AI engineering is an exciting field that is rapidly evolving and has immense potential to transform various industries. It requires a multidisciplinary skill set, and AI engineers should be proficient in programming, machine learning, data management, deep learning, and deployment. With the increasing demand for AI-powered systems, AI engineering is set to become one of the world’s most sought-after skills.

This article was written with the help of AI. Can you tell which parts? 

The post AI Engineering 101: A Brief Guide to Intelligent Systems appeared first on HackerRank Blog.

A software developer builds software and applications that help users perform specific functions and tasks. Software developers are also responsible for implementing larger frameworks to support specific devices or technology in a network.

In this post, we explore the skills required to be a software developer as well as career paths and its projected job outlook.

What Kinds of Companies Hire Software Developers?

Any company that’s building software or applications will need to hire software developers. The employers hiring the most engineers with this skill set are, unsurprisingly, the world’s largest technology companies, including Amazon, Accenture, InfoSys, Microsoft, and Google.

Though it’s not just Silicon Valley and startups increasing the demand for software developers. Now, more than ever, all companies are becoming tech companies. Companies in every industry need technical talent to help them modernize and innovate their business practices. Finance, social media, aerospace, defense, consulting, retail, healthcare — the demand (and opportunity) for software development talent is endless. 

Software Developer vs Software Engineer

Software development shares a lot of similarities with software engineering, and some companies even use the terms interchangeably. Developers and engineers in these roles work with similar back-end technologies. However, there are fundamental differences in the training, experience, and responsibilities of a developer and an engineer.

• Software developers are responsible for writing, managing, and maintaining software. They’re involved in the full lifecycle of software development, including research, development, testing, and launch. 
• Software engineers are responsible for the design, implementation, and maintenance of complex computer systems. Software engineers develop, design, and test software applications and apply engineering principles to the process of building software.

Types of Software Developer Positions

Software developer titles can vary widely, especially depending on their experience and the company or industry in which they work. Because the “software developer” title is broader than other technical roles, developers and employers often use different terms to describe the same role. For example, web developer and software developer are different roles that are sometimes combined into the job title web software developer.

At the beginning of their career, a software developer typically starts with an entry-level title like junior developer or software developer I. A new developer spends a lot of time learning and studying the codebases and application lifecycle of internal systems. They’re tasked with creating code models and identifying coding bugs.

After gaining several years of experience in an entry-level role, developers might have the opportunity to move into mid-level roles. At this stage, they’re responsible for developing applications from concept to launch. Depending on their specialization, experienced software developers can expect to create anything from operating systems to sophisticated proprietary software.

From there, they may have the opportunity to move into more senior-level roles with hands-on development responsibilities. Titles at this level include senior software developer, lead developer, and senior software architect. How long it takes to reach senior-level depends on the company and the skill level of the developer. 

The key requirement to reach senior-level developer roles is the ability to handle a variety of programming languages, with an exceptional command of computational logic and flow-charting. While they spend several years developing their skills, their responsibilities expand to include taking more ownership of projects, working independently in a team environment, and mentoring project team members. 

Salary Comparisons and Job Outlook

Software developers can expect to earn an average of $96,903. This estimate is based on data aggregated from leading salary data sources: 

• Payscale reports a range of $52,000 to $108,000, with an average of $$74,136
• Glassdoor reports a range of $63,000 to $147,000, with an average of $95,843
• U.S. Bureau of Labor Statistics reports a range of $64,470 to $168,570, with an average of $120,730

Software developer salaries also vary depending on specialization, with in-demand competencies commanding a higher compensation. For example, the average salary for software developers who know Clojure is $106,644. In contrast, the average for those specializing in JavaScript is $65,580.

It’s worth noting that estimates from salary aggregators may be low or out of date. While this has always been true, market conditions have made technical salaries especially volatile since 2020. Total compensation packages, including equity and bonuses, are also changing rapidly.

Requirements to Becoming a Software Developer

Technical Skills

Software developers use a range of programming languages to build software and applications. These include:

• C/C++
• C#
• Java
• JavaScript
• Python
• Ruby
• Scala
• SQL

Recruiters and hiring managers looking for software engineers should also look for in-demand competencies beyond programming languages. These include: 

• DevOps Skills
• Linux experience 
• Back-end frameworks (Ruby on Rails, Django, Laravel)
• Cloud platforms (AWS, GCP, Azure)
• Version control software (SVN, Git)
• Relational database management systems
• Non-relational database management systems

Soft Skills

Technical competence isn’t enough to succeed in software development. Analytical, mathematical, and problem-solving skills are a common part of any technical job. And in a remote or digital-first environment, soft skills are even more critical.

Employers value a number soft skills, such as:

• Communication
• Creativity
• Critical thinking
• Problem solving
• Project management
• Time management

Experience

After skill competencies, the most important qualification for software developers is experience. For many employers, “real-world” experience and training is a critical requirement.

When it comes to education, about 70 percent of developers worldwide have a bachelor’s degree or higher. If you’re recruiting, screening, or hiring engineers, it’s most likely that many of them have a degree. And many companies still require engineers to have four-year degrees.

Lately, companies looking to hire engineers are starting to recognize other forms of education and experience. Competition for skilled software engineers is high, and it’s not uncommon for job openings that require a degree to go unfilled. But employers that prioritize real-world skills over education alone gain access to a much larger talent pool.

Resources for Hiring Software Developers

• Best Practices for Hiring Software Developers: Front-End, Back-End, and Full-Stack
• How to Begin Screening Software Developers
• Developer Hiring Solutions

The post What Does a Software Developer Do? Role Overview and Skill Expectations appeared first on HackerRank Blog.

The post New Guide: Building Distributed Development Organizations from the Ground Up appeared first on HackerRank Blog.

The post Best Practices for Hiring Software Developers: Front-End, Back-End, & Full-Stack appeared first on HackerRank Blog.

The post [Checklist] Your Guide to Assessing Junior vs. Senior Developers appeared first on HackerRank Blog.