As a developer you encounter many ways of doing code, many ideas, some of them are nice and you are amazed on how nice and optimal is the implemented solution but some of them are really something that makes you wander about code and how a developer can write such a bad code.

Many times, this is covered in expressions like “ hey, it works” or “hey, we get the clients/money in, so all is ok”. Yes, this is 100% true but you need to understand, as a product owner or a business owner that this is what you call a medium product or even worse then this.

Recently, a customer provided his code to implement new features to me and I discovered a Laravel application with a SQL file :). Probably you have guessed … the migrations where not up to date with the database and the SQL file was the source of the “truth”.



If you wonder why or how can this be, it is very simple: life as a developer is like this; full of challenges. I remember when I was a junior developer I was scared of this situation and probably left the customer like this. With the time I learned to “own the mess”. This process is best described on the book “Clean Code” by Robert C. Martin (Uncle Bob).

Getting back to the customer, I was in the faze to tell him “hey this is crap, you need to pay more” or “hey, I am not doing this” because you can imagine that also in the rest of the code you can’t even think of something like PSR2. This is in my perspective the basic decent stuff a developer can at least do. Anyway, I “owned the mess” and carried on with my task. I looked on the SQL file, upgraded the hole migrations to a normal flow and moved on.



You may wonder why I did this? My answer is the I am not afraid of the “legacy code” or of the “spaghetti code”, I usually find real gems in this kind of code and as a result of my effort I implemented PHPUnit tests.

This is another topic on why you should at least try to get tests implemented in your project and if you have a new project just use TDD. I know it is super time consuming and very stressful, but the benefits on the long run are huge. The stability and the reliability of your software will be always there! If the tests are written is a good way and you test the code right, you are close to become a better developer then the majority.

Designing Effective and Secure RESTful APIs: A Comprehensive Guide

In this presentation, we delve into the intricate process of creating RESTful APIs that not only meet the expectations of developers but also stand as reliable pillars for businesses in the long haul. APIs are an integral part of our daily online interactions, often unnoticed, fueling functionalities from social media interactions and weather updates to booking rides and beyond. They are the backbone of our modern digital experience. Let's embark on a detailed exploration with a focus on best practices for crafting APIs that developers find intuitive and businesses can depend on for stability and growth.

Tip: Opt for Clear, Logical Naming When naming entities within your API, clarity and logic should be your guides. Rather than obscure identifiers like "getCart123", choosing self-explanatory names such as "carts123" makes it evident that the API deals with a collection of items. Consistency in naming conventions and URL structures enhances the API's usability, making it straightforward for developers to understand and interact with.

Tip: Emphasize Reliability with Idempotent API Design Idempotency ensures that multiple requests have the same effect as a single one, crucial for preventing inconsistencies especially in the face of network retries. While GET and DELETE methods naturally align with idempotency, POST methods may require additional mechanisms, like client-generated unique IDs, to avoid unintended duplications. Understanding and implementing idempotency is vital for creating stable and reliable APIs.

Tip: Implement Versioning for Future-Proof APIs As your API evolves, versioning is key to introducing changes without disrupting existing integrations. Prefixing URLs with version numbers (e.g., /v1/carts123) allows for seamless transitions to newer versions, ensuring backward compatibility and giving developers the flexibility to update at their convenience.

Tip: Incorporate Pagination for Optimized Data Retrieval To manage data delivery efficiently, incorporating pagination is essential. It limits the volume of data returned in a single request, enhancing performance and user experience. Both page-offset and cursor-based pagination have their merits, with the choice depending on the specific requirements and data dynamics of your API.

Tip: Leverage Clear Query Strings for Effective Data Sorting and Filtering Utilizing query strings for sorting and filtering enriches the API's flexibility, allowing users to easily customize data retrieval. This approach not only makes the API more intuitive but also facilitates the addition of new criteria without impacting existing functionalities.

Tip: Prioritize Security from the Start Security should never be an afterthought in API design. Protect sensitive information by preferring HTTP headers for authentication over query parameters and ensuring all traffic is encrypted with TLS. Implement comprehensive access controls and stay informed on best security practices to safeguard your API.

Tip: Simplify Cross-Resource References Maintain simplicity in linking related resources within your API. Avoid complex query parameters by using straightforward paths, thereby making the relationships between resources clear and easy to navigate for developers.

Final Tip: Plan for Rate Limiting Implementing rate limiting is crucial for protecting your API from overload and abuse. Define sensible request quotas based on various criteria to ensure fair usage and protect against potential attacks. This not only secures your infrastructure but also promotes equitable access across all users.

By adhering to these guidelines and focusing on RESTful principles, you'll be well on your way to designing APIs that are not just functional but also secure, efficient, and a joy for developers to integrate.