Join my Discord Community

Join my Discord community to get the latest updates, ask questions, and connect with other developers.

Latest Blog

What is a Design System According to Atlassian?

In the world of digital product development, consistency and scalability are key. The Atlassian Design System offers a robust framework that ensures a unified experience across all Atlassian products, from Jira to Confluence. By defining a collection of reusable components and clear standards, this design system enables designers and developers to build cohesive interfaces with a consistent look and feel. Let’s dive into the core elements of the Atlassian Design System and explore how it fosters collaboration, efficiency, and accessibility across teams.Core Elements of the Atlassian Design System1. FoundationsThe foundational elements of the Atlassian Design System set the stage for a consistent design language across all products. They include:2. ComponentsA library of reusable, pre-built UI components is at the heart of the Atlassian Design System. These components, such as buttons, forms, navigation elements, and tables, help developers create interfaces quickly and consistently. For example:More complex components, like full comment containers or dynamic tables, combine these foundational elements to address specific use cases, further enhancing the design system's flexibility.3. PatternsDesign patterns provide best practices for common scenarios, such as user authentication, notifications, and content layout. For instance:These patterns ensure a seamless experience for users, no matter where they interact with Atlassian products.4. AccessibilityAccessibility is integral to the Atlassian Design System. Guidelines and tools are provided to make sure every component is usable by everyone, including people with disabilities. This includes:By prioritizing accessibility, the design system ensures a broader reach and better user experience for all.5. Design TokensDesign tokens are fundamental to maintaining a consistent design language across various platforms. These tokens store values for colors, typography, spacing, and other design attributes, enabling quick and consistent changes throughout a product's UI.6. ContributionThe Atlassian Design System thrives on contributions from all team members—designers, developers, and product managers alike. By allowing contributions, such as proposing new components or suggesting improvements, the design system evolves while maintaining quality and consistency. Clear guidelines and a thorough review process ensure that all contributions align with the system’s goals.7. Versioning and Change ManagementVersioning is crucial for tracking changes and managing updates. The Atlassian Design System uses a versioning system similar to open-source projects, with detailed release notes documenting changes, new features, updates, and bug fixes. Key aspects include:How to Use the Atlassian Design SystemBenefits of Using the Atlassian Design SystemConclusionThe Atlassian Design System is a comprehensive toolkit that empowers teams to build cohesive, accessible, and scalable digital products. By providing a structured approach to design and development, it enhances consistency, speeds up workflows, and fosters collaboration across teams. Whether you are a designer, developer, or product manager, leveraging the Atlassian Design System ensures that your work aligns with a unified vision, creating a better experience for users and teams alike.

Why You Might Want to Switch to pnpm from npm

If you’re still using npm for your project, you might want to consider giving pnpm a try. It’s a package manager that’s been getting a lot of attention, and for good reason. Here’s why pnpm might be a better fit for your development workflow:1. Saves Disk Space Like a ProOne of the coolest features of pnpm is its ability to save disk space. Instead of duplicating packages across your projects, pnpm stores them in a global store and creates hard links. This means if you’re working on multiple projects that depend on the same version of a package, pnpm keeps just one copy of it on your disk. Less clutter, more space!2. Faster InstallationsEver been frustrated by slow package installations? pnpm has your back. It installs packages in parallel, which speeds things up compared to npm. Plus, it uses a global cache, so once a package is downloaded, it’s ready to go for other projects without needing to re-download it. Quicker installs mean more time coding and less time waiting.3. Keeps Dependencies in CheckWith pnpm, you get strict dependency resolution. It avoids the problem of accidentally using the wrong versions of packages because it enforces the exact versions specified in your package.json. This can save you from those annoying bugs that come from version mismatches.4. Perfect for MonoreposIf you’re working on a monorepo with multiple packages, pnpm makes life easier. Its workspace feature lets you manage all your packages in one place, ensuring that all versions stay consistent and your workflow remains smooth. Say goodbye to dependency headaches in your monorepo!5. Boosts SecurityBy using strict isolation for dependencies, pnpm helps you avoid accidentally pulling in packages that shouldn’t be there. This can enhance the security of your project by reducing the risk of dependency conflicts and other issues.6. Better Lockfile Managementpnpm’s lockfile, pnpm-lock.yaml, is designed to be more efficient and reliable compared to npm’s package-lock.json. This means you get more consistent and reproducible builds, making sure everyone on your team is working with the same setup.7. Modern and Feature-Richpnpm also supports the workspace feature defined in package.json, making it easier to manage multiple packages. It comes with various performance optimizations that streamline your development process.Bottom LineSwitching to pnpm can bring some serious advantages, especially if you’re dealing with large projects or monorepos. It saves space, speeds up installations, keeps your dependencies in check, and enhances security. If these perks sound good to you, it might be worth giving pnpm a shot.Happy coding!

Building a Scalable Web Application with Single-SPA and Microfrontends

In today's fast-paced web development landscape, scalability and modularity are crucial for managing large applications. One of the most effective approaches to achieving this is through the use of Single-SPA (Single Single-Page Application) and microfrontends. This article will explore how to leverage these technologies to build a scalable web application and provide a practical guide on using a custom script to manage your microfrontends.Understanding Single-SPASingle-SPA is a framework designed to enable the integration of multiple single-page applications (SPAs) into a single application. This allows developers to build a cohesive web application from smaller, independently developed microfrontends. Key benefits of Single-SPA include:Microfrontends ArchitectureMicrofrontends follow a similar concept to microservices in backend development. The idea is to break down a large frontend application into smaller, more manageable pieces. Each microfrontend operates as an independent unit, responsible for a specific feature or section of the application. In a typical setup, these microfrontends are integrated into a single application by a main configuration file.Project StructureIn our example project, the following microfrontends are included:Managing Microfrontends with a ScriptTo streamline the development process, we use a custom Bash script that performs several tasks:Here is the github: Single-SPA and microfrontends offer a powerful approach to building scalable and maintainable web applications. By breaking down the application into smaller, independent pieces, teams can enhance modularity and flexibility. The provided script simplifies the management of these microfrontends, ensuring a smooth development workflow. For further assistance, refer to the Single-SPA documentation and the documentation for each microfrontend.

Coding Principles for Better Code Quality

When it comes to software development, writing high-quality code is a must. Following good coding principles can make your code more robust, scalable, and easy to maintain. Here are ten key coding principles to keep in mind as you write your next masterpiece.1. Stick to Code StandardsEvery programming language has its own set of rules for writing clean code. For example, Python has PEP 8, and Java has the Google Java Style Guide. By following these guidelines, your code will be consistent and easier for others to read and maintain.2. Document and CommentClear documentation and comments are lifesavers. They explain the tricky parts of your code and why you made certain decisions. Focus on the "why" rather than the "what" so others (and future you!) can understand your thought process. Keep your documentation up-to-date as your code evolves.3. Build Robust CodeRobust code handles unexpected inputs and errors gracefully. Make sure your code doesn't crash under pressure by using exception handling and logging. This way, your software remains stable and provides useful feedback when something goes wrong.4. Embrace the SOLID PrinciplesThe SOLID principles—Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion—are your friends. They help you design software that's easy to scale and maintain. Following these principles makes your code flexible and adaptable.5. Make Testing a BreezeTestability is key to good code. Keep your code modular and straightforward to test, so you can catch bugs early and ensure everything works as expected. Automated tests are great for keeping your code in check as it grows and changes.6. Master AbstractionAbstraction is about simplifying complex systems by focusing on the essentials. It makes your code more flexible and easier to manage. Strike a balance—avoid over-complicating things, but don't ignore the importance of planning for the future.7. Use Design Patterns WiselyDesign patterns can solve common problems, but don't overdo it. Each pattern has a specific use case, and overusing them can make your code unnecessarily complex. Use them where they fit best, but keep your code clean and simple.8. Minimize Global DependenciesGlobal variables and instances can lead to confusing state management. Instead, aim for localized state and parameter passing. Keep your functions side-effect-free to make your code more predictable and reliable.9. Keep RefactoringRefactoring is all about cleaning up your code as you go. Regularly revisiting and refining your code helps reduce technical debt and makes it more maintainable. Keep an eye out for areas that can be improved, and don't hesitate to make changes.10. Prioritize SecuritySecurity should always be top of mind. Protect against common vulnerabilities by validating inputs, managing data securely, and using encryption when necessary. Building security into your development process keeps your software and its users safe.Incorporating these coding principles into your daily workflow can make a huge difference in the quality of your code. As you grow as a developer, remember that good coding practices are a continuous journey rather than a destination. Keep learning, adapting, and sharing your insights with others. By doing so, you'll not only improve your own skills but also contribute to a culture of quality and collaboration in the software development community.

Next.js 15 Release Candidate: New Features and Enhancements

The release candidate for Next.js 15 introduces a variety of new features and improvements aimed at enhancing developer experience, performance, and flexibility. Here's a detailed look at the key updates:React 19 Support and React Compiler (Experimental)Next.js 15 RC now supports the React 19 Release Candidate, which brings significant changes and improvements, including an experimental React Compiler. The React Compiler can be enabled by installing the Babel plugin and configuring your next.config.js:and next.config.tsAdditionally, there are updates to hydration error messages, aimed at simplifying and speeding up the debugging process.Updated Caching DefaultsCaching behavior has been adjusted in Next.js 15 RC. Fetch requests, GET route handlers, and client navigations are no longer cached by default. This change addresses common confusion among developers and makes cache management more explicit.Incremental Adoption of Partial Prerendering (Experimental)Partial Prerendering (PPR) allows a hybrid approach where parts of a page are statically rendered while others remain dynamic. This ensures fast initial loads with static content served from the edge and dynamic content streamed in parallel. To enable PPR, update your configuration as follows:and in next.config.tsPPR merges the benefits of static site generation (SSG) and server-side rendering (SSR), providing a unified rendering model that eliminates many trade-offs.New next/after API (Experimental)The next/after API allows you to execute code after a response has finished streaming. This is particularly useful for tasks like logging, analytics, or synchronizing with external systems without making the user wait. Here’s how to enable and use it:Usage Example:Enhancements in create-next-appThe create-next-app tool has been updated with a new design and a flag to enable Turbopack during local development. This streamlines the initial setup process and improves the development experience.Optimizing bundling of external packages (Stable)Bundling external packages can significantly enhance the cold start performance of your application. In Next.js 15 RC, external packages are bundled by default in the App Router. You can opt-out specific packages using the serverExternalPackages configuration option:Next.js 15 RC introduces a range of features and improvements, from supporting the latest React version and improving caching defaults to introducing innovative features like Partial Prerendering and the next/after API. These updates are designed to enhance performance, streamline development, and provide greater flexibility for developers building modern web applications.

The Journey of Software Engineering: From Backlog to Release

In the realm of software engineering, the journey from conceptualization to deployment is a carefully orchestrated process that involves multiple stages and stakeholders. Let's delve into the intricacies of this journey, from the inception of an idea in the backlog to the triumphant release of a polished product.1. Backlog:It all begins with the backlog, a treasure trove of ideas, features, and enhancements waiting to be explored. Here, stakeholders collaborate to prioritize tasks based on business value, user needs, and technical feasibility.Usually stakeholders, project managers and also tech leads, sit down to prioritise this list and have some sort of quarterly plans2. Sprints:With the backlog as our guide, we embark on iterative cycles known as sprints. Each sprint is a focused effort lasting a fixed duration, during which a cross-functional team works collaboratively to deliver a set of user stories or tasks.Most companies work with Sprints, 2 weeks cycle to be able to monitor and get feedbacks from the system.3. To-Do:As the sprint kicks off, tasks are pulled from the backlog into the "To-Do" column, signaling the team's commitment to tackle them within the sprint timeframe.After estimations and refinement sesisons, you have taken responsibility to make these tickets done.4. In Development (In-Dev):With sleeves rolled up and keyboards clacking, developers dive into the heart of the codebase, bringing concepts to life and turning requirements into tangible features. Tasks transition into the "In-Dev" column as work progresses.Each developer on their standup will take a ticket and move it to in-DEV, that's a sign that this engineer is working on what, and if he/she needs an assist or if they are blocked or anything else that might cause a delay.5. Ready for Review:Once development is complete, code changes are submitted for review. This critical step ensures code quality, adherence to coding standards, and alignment with architectural principles. Reviews may involve peer code reviews or pull request approvals by fellow developers.Code review is a practice needs to be taught, it's also comes from WOW or ways of working within the team. So the better the code review, the higher the product lifecycle.6. Design Review:In parallel, design elements undergo scrutiny in a dedicated design review phase. Here, designers, developers, and stakeholders collaborate to ensure that user interfaces are intuitive, visually appealing, and consistent with brand guidelines.It's brilliant to have this step earlier in the process. It will remove tons of smaller tickets later on.7. Ready for QA:With code and design aligned, the spotlight shifts to quality assurance (QA). Testers meticulously verify functionality, conduct regression testing, and hunt down elusive bugs to ensure a robust and reliable product. Tasks transition into the "Ready for QA" column as they await scrutiny.Most companies have QA process which usually happens in dev environments.8. Ready for Deployment:As the QA team gives its stamp of approval, tasks ascend to the "Ready for Deployment" stage. Here, preparations are made for the smooth transition of changes into the production environment. This may involve finalizing documentation, coordinating release schedules, and configuring deployment pipelines.Tests are passed, PR is ready and so on, now it's time to take everything to a most similar environment to production which might be staging, UAT or any other name you might have. (We were calling this Wombat) :D9. Ready for Release:The moment of truth arrives as tasks reach the "Ready for Release" milestone. With all checks and balances in place, the stage is set for the grand unveiling of new features or enhancements to end-users. Rollout strategies are executed, and stakeholders eagerly anticipate user feedback.Final tests, e2e tests and everything is working, if you have or not have feature flags, everything is fully tested, Developers are responsible to double check everything here and release is ready to go live.It's important to note that while this journey provides a structured framework, the engineering process is highly adaptable and subject to iteration and refinement. Each team may tailor its approach based on project requirements, organizational culture, and lessons learned from previous endeavors.In conclusion, the journey of software engineering is a collaborative odyssey marked by meticulous planning, disciplined execution, and continuous improvement. From the humble beginnings of a backlog item to the triumphant release of a polished product, every stage of the process contributes to the creation of innovative solutions that delight users and drive business success.

The Flywheel Strategy: Engineering Your Path to Leadership

In the world of engineering, success is akin to the motion of a flywheel—starting slow but gaining momentum with each turn. The Flywheel Strategy encapsulates this journey, emphasizing the importance of working in a cyclical manner to achieve leadership. Let's explore how this strategy guides engineers through eight iterative steps towards leadership excellence.Step 1: Understanding the Landscape:Upon joining a company, immerse yourself in its vision, mission, and quarterly goals. Identify bottlenecks and challenges to lay the groundwork for success.Make sure you understand it and document it.Step 2: Translating Goals into Engineering Tasks:Translate organizational goals into actionable engineering objectives. Define which features to develop, bugs to fix, and the overall engineering strategy.Engineering vision is always a documentation, with engineering vision, mission and values, you also need to let everyone know what you are working towards to be aligned with.Step 3: Planning with Precision:Create a detailed timeline, prioritize tasks, and assess risks. Define quality standards and set clear priorities to guide your team.Risks and Priorities, all can be crafted in a Gantt Chart.Step 4: Finalizing the Solution:Document the solution architecture, security measures, and workflow. Utilize flowcharts, architecture diagrams, and contracts to ensure clarity and alignment.Documention is a must for engineering, Sequencing diagram or perpahs architecture diagram, API documentions and anything you need to investigate on, all needs to be documentedStep 5: Securing Resources:Ensure adequate resources and staffing to execute the plan effectively. Address staffing needs promptly to maintain project momentum.Step 6: Fostering Team Dynamics:Focus on team dynamics, fostering collaboration, and defining ways of working. Emphasize cross-functional cooperation and establish effective communication channels.WOW or ways of working is a contract between all engineers that they have all agreed on. Step 7: Streamlining Development Processes:Optimize CI/CD pipelines, automate processes, and enhance development-to-production workflows. Prioritize smooth operations to improve productivity.Step 8: Defining Performance Metrics:Establish key performance indicators (KPIs) to measure progress and team performance. Utilize monitoring tools and feedback mechanisms to drive continuous improvement.Conclusion:The Flywheel Strategy embodies the iterative nature of engineering excellence. By embracing these eight steps and iterating through them, engineers can navigate challenges, accelerate progress, and achieve leadership. Each iteration refines the engineering engine, propelling teams towards seamless operation and sustained success in the dynamic landscape of technology.

Power of gRPC in Node.js: A Superior Alternative to Websockets

gRPC utilizes HTTP/2, a binary protocol, which offers significant performance benefits over the text-based protocols like HTTP/1.1 used by Websockets. This results in lower latency and higher throughput, making gRPC ideal for demanding real-time applications.gRPC relies on Protocol Buffers (protobuf) for defining service contracts, which provides strong typing and automatic code generation in multiple languages. This ensures better communication between client and server, reducing the likelihood of runtime errors compared to the more flexible but error-prone nature of Websockets.gRPC supports bidirectional streaming, allowing both the client and server to send a stream of messages asynchronously. This feature is particularly useful for scenarios like chat applications, telemetry systems, and real-time analytics, where constant data exchange is required.1. Define the Protocol Buffer (.proto) File:Use the protoc compiler with the Node.js plugin to generate client and server code from the .proto file.NodeJSAnd On the Client Side:gRPC offers a compelling alternative to Websockets for real-time communication in Node.js applications, providing superior performance, strong typing, and bidirectional streaming capabilities. By following the steps outlined above, you can harness the power of gRPC to build efficient and scalable real-time systems that meet the demands of modern web applications.

Optimizing Path Management in Vite and Remix with vite.config

In the realm of web development, efficiency and simplicity are paramount. As projects grow in complexity, managing paths to various files and routes can become a daunting task. Enter vite.config, a powerful tool that streamlines path management and enhances developer productivity. With the ability to reduce redundant path declarations and simplify configuration, vite.config has become a game-changer for teams seeking to optimize their development workflow.In the provided vite.config snippet, we witness the seamless integration of various plugins and configuration options to optimize path management. By leveraging plugins like vite-tsconfig-paths and @sentry/vite-plugin, developers can effortlessly manage paths and enhance error monitoring capabilities.With vite.config, developers can bid farewell to repetitive path declarations and convoluted configurations. Instead, they can focus on what truly matters – building exceptional web experiences. As projects evolve and requirements change, vite.config remains a steadfast ally, empowering developers to navigate the complexities of modern web development with ease.

Latest Courses

Clean Code Course

In this course, you'll learn the core principles of clean, maintainable, and robust coding practices, specifically tailored for TypeScript. From writing clear, concise functions to organizing files and adhering to SOLID principles, you’ll gain hands-on experience through practical examples and exercises. Gaz will guide you through real-world TypeScript scenarios, showing how clean code improves both readability and scalability.Topics covered include:Whether you're new to TypeScript or looking to refine your skills, this course will provide a solid foundation for writing professional, clean code in TypeScript. Perfect for developers aiming to level up their TypeScript projects or improve team collaboration through cleaner, more understandable code.

Latest Reviews

Multipliers: How the Best Leaders Make Everyone Smarter

Reading Multipliers by Liz Wiseman and Greg McKeown made me pause and really think about what great leadership looks like. It’s a book that goes beyond traditional ideas of what a “strong leader” is supposed to be, showing us how the best leaders focus on bringing out the intelligence and capabilities of those around them. Wiseman defines these leaders as “Multipliers”—the ones who make others smarter, better, and more engaged. It’s a concept that completely reshapes the idea of leadership as a shared effort, rather than a hierarchy.Here’s what stood out most to me as I read:1. The Concept of Multipliers vs. DiminishersWiseman’s core idea is the contrast between Multipliers and Diminishers. Multipliers are leaders who amplify the intelligence of their teams, unlocking potential that even the individuals themselves may not have recognized. Diminishers, on the other hand, unintentionally (or sometimes intentionally) stifle others, limiting their growth. This distinction hit me because we’ve all had that one manager who, rather than empowering us, managed to make us feel less capable. The concept is a wake-up call to any leader or aspiring leader to be mindful of how they’re impacting their team’s abilities.2. Five Disciplines of MultipliersWiseman lays out five key disciplines that set Multipliers apart:Each of these was relatable and grounded in reality. I’ve seen leaders who embody these principles—and I’ve seen those who lack them. For me, this structure provided a roadmap for what I’d aspire to in any leadership role.3. Intelligence Isn’t a Finite ResourceOne of the most inspiring ideas in Multipliers is the belief that intelligence and capability are not fixed resources. Diminishers often lead with the assumption that there’s only so much intelligence to go around, which makes them hesitant to delegate or allow others to shine. Multipliers, on the other hand, view intelligence as something that grows with collaboration and contribution. This perspective struck me as both empowering and humbling—it’s a reminder that leadership is about creating an environment where everyone’s potential can expand.4. The Power of Asking Questions, Not Giving AnswersMultipliers don’t feel the need to be the “smartest person in the room.” They focus on asking insightful questions that prompt others to think deeply and come up with solutions themselves. This approach resonated because it highlights the strength in humility. Multipliers aren’t afraid to say, “What do you think?” or “How would you solve this?” Instead of providing all the answers, they guide people to find their own. This is something I’ve seen few leaders do well, but when it happens, the results are undeniable.5. Creating a Safe Space for Bold IdeasThe Liberator discipline, in particular, emphasized that Multipliers create safe environments where people feel comfortable sharing bold ideas, even if they might be a bit rough around the edges. This was an especially refreshing takeaway. I’ve often found that the fear of judgment keeps people from sharing creative solutions or ambitious goals. Multipliers break down those barriers, making it clear that everyone’s input is valued and that taking risks is not just accepted—it’s encouraged.6. The Lasting Impact of Multiplier LeadershipWiseman’s examples of real-life leaders who practiced the Multiplier approach drove home the long-term benefits of this leadership style. When people feel empowered and respected, they tend to be more innovative, resilient, and committed. This book isn’t just about making leaders look good; it’s about showing how impactful leadership can positively transform teams and organizations as a whole. It’s a reminder that leadership done right doesn’t drain people’s energy—it fuels it.Multipliers is a must-read for anyone who wants to be a leader that truly brings out the best in others. The book doesn’t just point out what we should avoid as leaders; it gives actionable advice on how to build a leadership style rooted in curiosity, respect, and trust. Wiseman’s approach makes it clear that effective leadership isn’t about overshadowing your team—it’s about giving them the space and encouragement to shine.This book made me rethink my own behavior, even outside of traditional “leadership” roles. It’s a reminder that whether we’re leading a team, a project, or just managing our own responsibilities, we all have the opportunity to act as Multipliers and make those around us better, smarter, and more engaged.

The Psychology of Money: Timeless Lessons on Wealth, Greed, and Happiness

Reading The Psychology of Money by Morgan Housel (in this summary by Tommy S. Meyers) felt like a fresh take on personal finance. It’s not just another guide to building wealth; it’s a deep dive into the psychology behind financial decisions, revealing why we make money choices the way we do and how those choices impact our lives in ways we might not even realize. Housel’s ideas emphasize that money is more about behavior than knowledge—a powerful insight that challenged my own assumptions about finance.Here are the main takeaways that resonated with me:1. Money Isn’t About Intelligence; It’s About BehaviorOne of Housel’s key points is that being good with money isn’t necessarily about having a high IQ or access to insider information. Instead, it’s about understanding your own behavior and being consistent with it. This means acknowledging your personal relationship with money and knowing when your choices are driven by emotion rather than logic. This takeaway was eye-opening because it strips finance of all the complex jargon and reduces it to something we can control: our habits.2. The Importance of CompoundingWe’ve all heard about the power of compounding, but Housel makes it clear how crucial it really is—not just financially but in every part of life. He uses Warren Buffett as an example, pointing out that much of Buffett’s wealth is due to decades of compounding, not just investment skills. It’s a lesson in patience and sticking with something for the long haul. For me, this reinforced the idea that small, consistent actions—whether in saving, investing, or building skills—are far more powerful than any single big move.3. The Value of Freedom Over More WealthHousel argues that true wealth is not just having a large sum in the bank but having the freedom to live life on your terms. This one hit home for me. Money, he says, should be about gaining more control over your time and choices rather than acquiring more material possessions or status. I found this perspective refreshing and grounding—it’s a reminder that money should be a tool for freedom, not an end goal.4. The Role of Luck and RiskThis book is humbling in its reminder that luck plays a much bigger role in financial success than we often admit, and so does risk. Housel tells us that financial outcomes are shaped by things we can’t always predict or control. It’s a call to stay humble, avoid overconfidence, and recognize that even the best financial decisions carry inherent risks. This part of the book made me reflect on the need for gratitude and perspective in financial planning.5. Enough Is Truly EnoughOne of the most powerful chapters discusses the concept of “enough.” Housel cautions against the relentless pursuit of more, warning that it can lead to risky decisions and dissatisfaction. The concept of “enough” isn’t about settling but about knowing your limits and being content with what you have. This idea is one of the book’s most meaningful messages, encouraging us to seek balance and avoid the greed that often comes with ambition.6. Wealth Is What You Don’t SeeAnother profound insight from Housel is that wealth is often invisible. While society celebrates visible signs of wealth—like cars, homes, and luxury items—true wealth is hidden, like savings and investments. Housel’s approach reinforces that financial security isn’t about outward appearances but about having a buffer, flexibility, and options. It’s a reminder that what you don’t see—the savings, the emergency funds—often matters far more than what’s on display.Final ThoughtsThe Psychology of Money is more than just a finance book. It’s a guide to understanding how our minds influence our money decisions and, ultimately, our happiness. Housel has a gift for breaking down complex ideas into simple truths, making this book accessible to anyone, regardless of their financial background. Tommy S. Meyers’ summary captures the heart of Housel’s teachings, presenting timeless lessons in a way that feels relatable and actionable.This book gave me a fresh perspective on money, helping me see that wealth isn’t always about how much you make but about how you live and the choices you make along the way. I’d recommend it to anyone—whether you’re just starting out on your financial journey or you’ve been at it for years. It’s a reminder that the journey to financial well-being is as much a mental one as it is a monetary one.

The Natural Order of Money by Roy Sebag – A Refreshing Look at What Money Really Is

I recently picked up The Natural Order of Money by Roy Sebag, drawn in by the idea of exploring money from a perspective beyond economics—looking at it as a force shaped by natural order and human behavior. Sebag doesn’t just present another theory on finance; he dives into the philosophy of money itself, and how its role has been distorted by modern systems and values. This isn’t just a book about currency or investment but about understanding the essence of value and the flow of resources as they relate to human life and the natural world. I found it thought-provoking and unlike any other financial book I’ve read.Sebag makes a strong case that money, in its truest form, is connected to the natural order of things, with deep roots in how humans have interacted with resources throughout history. He argues that money isn’t just a construct of banks or governments but is instead a representation of our relationship with nature and each other. This perspective felt almost grounding—it made me think of money not as a separate entity but as something deeply tied to the earth and the resources we share.Sebag delves into how money has become disconnected from its natural purpose, largely due to the rise of fiat currency and centralized financial systems. He critiques how monetary policy has shifted from being rooted in tangible resources (like gold) to being purely theoretical, creating a system where money can be “created” without any real resource backing it. Reading this was an eye-opener—it made me question the value we place on modern currency and how that affects everything from inflation to personal savings.Sebag’s view on gold as the only real, sustainable form of money might sound old-fashioned, but he explains it in a way that feels anything but outdated. He argues that because gold has inherent value, it stands apart from the shifting values of fiat money. He makes a solid case for why a return to resource-backed currency, especially gold, could ground our financial systems in something real and enduring. While I don’t know if a return to the gold standard is possible or even desirable, Sebag’s argument gave me a fresh perspective on why gold has held its value for millennia. It’s rare to find an argument for gold that goes beyond the standard “hedge against inflation,” but Sebag achieves it.One of the most fascinating parts of the book is when Sebag connects money to human instincts and societal behavior. He sees money as something that mirrors our collective values, habits, and even our greed and fears. He writes about how financial systems reveal the state of society—if money flows toward unsustainable or exploitative industries, it reflects underlying issues in human priorities. This concept resonated deeply with me. Sebag’s ideas feel like a wake-up call, reminding us that how we use and value money reveals more about society than we might care to admit.Sebag doesn’t shy away from the ethical side of his ideas. He argues that reconnecting money with natural resources could help create a more sustainable world, where value is placed on things that are truly important rather than on artificial financial growth. This ethical layer gave the book an extra dimension, making it feel like a call to action to rethink our relationship with money. This perspective made me reflect on my own financial choices—whether they align with values like sustainability and real value.Final ThoughtsThe Natural Order of Money is more than a financial book; it’s a philosophical exploration of what money could and should mean in a world that’s becoming increasingly abstract in its valuation of everything. Sebag challenges the reader to look past the numbers in our bank accounts or the price of stocks and instead think about how money connects us to nature, society, and each other.This book left me with more questions than answers, but in the best way possible. It’s rare to find a financial book that makes you question the foundations of currency itself, and even rarer to find one that ties money so intimately to natural order and human values. Sebag’s arguments aren’t light reading, but they’re worth every page. I’d recommend this book to anyone curious about the deeper meaning of money, and how we might redefine it in a way that feels more human and more real.

Top Stack

A Curated Collection of Top TypeScript and Cloud Tools

Tools

Latest Game

Warp.js: Creating Arc Text Moving with a Slider in React TypeScript

Warp.js: Crafting Waving Text Effects in React TypeScript

Paper.js for Creating a Chain Effect in React TypeScript

X/O or Tic Tac Toe Game

Latest App

Building a Clock with Hands Using HTML, CSS, and TypeScript

Building a Real-Time Chat Application with Socket.IO and Express.js

Automate Your Email Sending with Mail Scheduler

Milliseconds Counter App - Interview Question

Latest Package

XML-Sitemap-Generator with Crawlee's CheerioCrawler:

Learnings

Latest HTML and CSS

How to Successfully Roll Out an Internal UI Component Library

CSS Houdini: New Possibilities for Your CSS

Magic of WebP: Making Your Website Faster and Prettier

Optimizing Script Loading in Web Development: Strategies and Techniques

Latest TypeScript

Using the Intl Object in TypeScript: An Overview with Examples

When to Use let vs const in TypeScript

Exploring Promise APIs in TypeScript

Implementing Salt with Encryption in TypeScript

Latest SQL

The Art of SQL JOINs: Combining Data from Multiple Tables

Aggregates in SQL

Exploring SQL Subqueries: Advanced Queries for Data Analysis

SQLZoo SELECT Queries with Order BY

Latest HTML and CSS

How to Successfully Roll Out an Internal UI Component Library

CSS Houdini: New Possibilities for Your CSS

Magic of WebP: Making Your Website Faster and Prettier

Optimizing Script Loading in Web Development: Strategies and Techniques

Latest TypeScript

Using the Intl Object in TypeScript: An Overview with Examples

When to Use let vs const in TypeScript

Exploring Promise APIs in TypeScript

Implementing Salt with Encryption in TypeScript

Latest SQL

The Art of SQL JOINs: Combining Data from Multiple Tables

Aggregates in SQL

Exploring SQL Subqueries: Advanced Queries for Data Analysis

SQLZoo SELECT Queries with Order BY

Latest Security

Describe the difference between symmetric and asymmetric encryption, and when each is appropriate.

What is a Buffer Overflow vulnerability, and how can it be exploited?

Explain SQL Injection and how to prevent it in software applications.

What is Cross-Site Scripting (XSS), and how can it be prevented?

Latest Accessibility

How to make Forms more accessible?

More Accessible with Semantic HTML

What are ARIA (Accessible Rich Internet Applications) roles?

Web Content Accessibility Guidelines (WCAG)

Latest System Design

How would you design system a frontend like Trello?

How would you design an expense app?

Demystifying Oauth2 Sequence Diagrams

How would you design Netflix?

Latest Database

Strategies to Scale Your Database

Session Storage: Limitations and TypeScript Usage

Database Performance and Indexes in Prisma ORM

Cookie Limitations in TypeScript

Latest Design Pattern

Error Boundary React Design Pattern

Context API React Design Pattern

Higher-Order Component (HOC) React Design Pattern

Container Component React Design Pattern

Latest Clean Code

Right Balance: Best Practices for Code Comments in TypeScript

Best Practices for Writing Isolated Tests in TypeScript

Meaningful Test Concepts: Best Practices for Writing Tests in TypeScript

Open-Closed Principle (OCP) Best Practices in TypeScript: Guidelines and Examples

Latest Testing

Using Vitest, MSW, and Faker in TypeScript

Testing SetInterval in React Components

Testing setTimeout Functions in React Components

Testing React Components in Storybook Using Testing Library

Latest DevOps

AWS Databases: A Comprehensive Guide

TLS and HTTPS: Understanding How They Work

Sample Next.js application using Terraform in AWS

Latest Artificial Intelligence

Linear Regression in Artificial Intelligence

Latest Algorithm

Tracking Down the Mystery: Finding the Unique Delivery ID

Elusive Least Occurring Number in an Array

Solving the Height of a Binary Tree Puzzle

Harry Potter Discounts: A Code Challenge Algorithm

Latest Data Structure

Hash Tables Data Structure in TypeScript: A Comprehensive Guide

Exploring Sets Data Structure in TypeScript: A Comprehensive Guide

Exploring Trie Data Structure in TypeScript: Implementation and Applications

Understanding Heaps: A Powerful Data Structure for Priority Queues

About

Latest Testimonials

QA Automation Engineer at Sportsbet

Technical Lead at Officeworks

Senior Frontend Developer at Catch.com.au

Software Engineer at MYOB

Latest Talks

Do You Believe in Magic? Time to Move to Remix.

How to be an effective software engineering leader

How to Learn - How to Teach

Software Architecture Patterns

Latest Projects

MockLand
Mentor

ClubCP
Volunteer

Mecca Brands
Technical Lead

Australia Post
Engineering Lead

I am Gaz

With over a decade of hands-on experience in software engineering, I've honed my skills as a Principal Engineer and Team Leader. My passion lies in architecting scalable solutions and empowering teams to achieve their full potential. Leading by example, I champion a culture of continuous learning and innovation. Whether it's diving into complex code challenges or mentoring junior developers, I thrive on pushing boundaries and driving impactful results. From designing robust software architectures to optimizing performance and ensuring best practices, I'm committed to delivering excellence in every aspect of my work. Let's embark on a journey of technical excellence and growth together!