Morgan Eboussert Wiki

website·Indexed 29 days ago

https://wiki.morganeboussert.com/

A personal knowledge base covering front-end development, UX/UI design, and product management. Topics include CSS performance and responsiveness, JavaScript architecture, React Native, NextJS, Godot, and UX research methods such as design thinking, cognitive biases, and eco-conception.

Tokens
35.6K
Snippets
62
Records
256
Agent score
50%

What's inside Morgan Eboussert Wiki

  1. Overview of Next.js Framework Features

    Next.js is a React framework that manages UI, routing, and data fetching, while providing built-in tooling for minification, building, and compilation. It includes native support for Sass. A core feature is pre-rendering, where HTML pages are generated in advance rather than being rendered exclusively on the client side via JavaScript. Pre-rendering occurs in two forms: Static Generation and Server-Side Rendering.
  2. Implement the Observer pattern for game event systems

    The Observer pattern allows a 'Subject' to notify one or more 'Observers' about events without knowing the specific classes of those observers. This is useful for decoupling game systems, such as triggering achievements when specific gameplay events occur.

    Key Components:

    • The Subject: Maintains a list of observers and provides a public API (addObserver and removeObserver) to manage that list. When an event occurs, the subject iterates through the list and calls the onNotify method on each observer.
    • The Observer: A class (e.g., Achievements) that implements an onNotify function to receive and dispatch events, such as calling an unlock(achievement) method.

    Example Use Case: An 'Observable Physics' system where a Physics class implements the Subject interface. Other systems can subscribe to specific physics events, for example: physics.entityFell().addObserver(this).

  3. Compare Qualitative and Quantitative UX Research

    UX Research uses a combination of qualitative and quantitative methodologies to understand user needs, behaviors, emotions, motivations, and frictions. Combining both is known as triangulation, which allows researchers to view the same subject from different perspectives. Typically, qualitative research is conducted first to gain initial insights and inform the questions for quantitative studies.

    Quantitative Research:

    • Goal: Identify generalities, trends, or problems at scale; measures 'how many' without explaining 'why'.
    • Methods: Surveys, A/B testing (or A/B/n testing), Analytics (e.g., Google Analytics), and early-design testing (tree sorting, first-click testing).
    • Scale: Usually involves a large number of participants (> 30/40).
    • Data: Quantifiable results via closed questions.

    Qualitative Research:

    • Goal: Explore 'why' in depth; observes attitudes, behaviors, and experiences.
    • Methods: Open-ended questions, interviews, individual user discussions, and usability tests.
    • Scale: Usually involves a small number of participants (< 10).
  4. Frontend architecture general principles

    To maintain a scalable and testable frontend application, follow these core architectural guidelines:

    • Layered Separation: Divide the application into distinct layers: Domain, Infrastructure, and UI.
    • Decouple Business Logic: Remove business logic from UI components and move it into separate controllers or services. This simplifies unit testing by removing dependencies on the UI framework.
    • Dependency Injection: Avoid importing stores or services directly into controllers. Instead, inject them via the constructor to enable easier mocking during unit tests.
    • Prioritize Decoupling over DRY: In some cases, it is better to have decoupled code than to strictly follow the DRY (Don't Repeat Yourself) principle if the code is likely to diverge over time.
    • Single Responsibility Principle (SRP): Ensure each class or module has only one reason to change.
  5. Understand React's internal element creation and rendering

    React elements are JavaScript objects containing properties like type, key, ref, props, _owner, and _store. When using JSX, the code is compiled into React.createElement calls. To display these elements in the browser, a root is created from an HTML element, and the React element is passed to the render function, which converts it into an HTML node.
    // 1. Create a React element
    const reactElement = React.createElement('p', { maProp: 'hello' }, 'My added content');
    
    // 2. Define the app root
    const root = createRoot(document.getElementById('root'));
    
    // 3. Render the element to the DOM
    root.render(reactElement);
  6. Structure game design documentation levels

    Effective game design follows an iterative process of creating a playable build as quickly as possible and refining it. Documentation should be structured into three progressive levels of detail:

    1. Concept Paper: A short summary of the game idea.
    2. The Treatment: A 10-20 page document that includes competitive research and a description of how the game improves upon or differs from existing titles.
    3. GDD (Game Design Document): A comprehensive description covering every aspect of the game's design.
  7. Effective technical reading and research habits

    To improve technical proficiency, focus on these reading strategies:

    • Source Code Analysis: Clone major open-source repositories to understand their inner workings. Specifically, look for implementations of Hexagonal Architecture, Domain-Driven Design (DDD), and Clean Architecture on GitHub.
    • Curation: Use RSS feeds for blogs and read technical books.
    • Network Following: Follow influential developers and explore the 'graph' by following the people those experts follow.
  8. Define and categorize UX content

    UX content encompasses all words, images, ideas, and videos appearing across different product stages. It is divided into four primary categories:

    • Commercial: Advertisements, articles, emails, product pages, and social posts.
    • Onboarding: Tutorials and getting started guides.
    • Usage: Alerts, titles, buttons, descriptions, and contextual help.
    • Support: Error messages and alerts.

    Effective UX Writing balances a consistent, recognizable voice with usability to ensure the product is easy to use, even for beginners.

  9. Understand the goals of global state management in React

    Global state management is used to solve several architectural challenges in React applications:

    • State Access: Ability to read state from any point in the component tree, either via React vanilla tools (useState, useRef, useReducer combined with Context API) or via external singleton state modules.
    • State Updates: Providing a consistent mechanism to update stored state.
    • Rendering Optimization: Implementing mechanisms to prevent unnecessary re-renders.
    • Memory Management: Managing memory usage. Using React's lifecycle for stores allows automatic garbage collection upon component unmounting, whereas external libraries like Redux may require manual cleanup to avoid memory leaks due to persistent references.
    • Data Serialization: Handling the serialization of state data.
  10. Apply SOLID principles for frontend design

    Use the SOLID principles to ensure a robust and maintainable architecture:

    • S (Single Responsibility): A class should have one, and only one, reason to change.
    • O (Open/Closed): Software entities should be open for extension, but closed for modification.
    • L (Liskov Substitution): Subtypes must be substitutable for their base types.
    • I (Interface Segregation): Clients should not be forced to depend on interfaces they do not use; split large interfaces into smaller, specific ones.
    • D (Dependency Inversion): Depend on abstractions, not on concretions.
  11. Implement Component Architecture and Design Systems

    Effective front-end development requires a structured approach to UI components:

    • Component Decomposition: Distinguish between UI components and business logic components. Use methodologies like Brad Frost's Atomic Design (Atoms, Molecules, Organisms).
    • Design Systems: Understand the role of design tokens and reusable component libraries.
    • Architecture: Explore front-end design patterns and architectures such as Hexagonal or Clean Architecture.
  12. Define product purpose using the Golden Circle framework

    The Golden Circle framework (by Simon Sinek) helps define a product's core purpose by answering three fundamental questions:

    • What: What the organization offers (the product/service).
    • How: How the product differentiates itself from competitors.
    • Why: Why the product exists, including its values and ultimate goal.