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.
What's inside Morgan Eboussert Wiki
- 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.
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 (
addObserverandremoveObserver) to manage that list. When an event occurs, the subject iterates through the list and calls theonNotifymethod on each observer. - The Observer: A class (e.g.,
Achievements) that implements anonNotifyfunction to receive and dispatch events, such as calling anunlock(achievement)method.
Example Use Case: An 'Observable Physics' system where a
Physicsclass implements theSubjectinterface. Other systems can subscribe to specific physics events, for example:physics.entityFell().addObserver(this).- The Subject: Maintains a list of observers and provides a public API (
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).
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.
Understand React's internal element creation and rendering
React elements are JavaScript objects containing properties liketype,key,ref,props,_owner, and_store. When using JSX, the code is compiled intoReact.createElementcalls. 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);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:
- Concept Paper: A short summary of the game idea.
- 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.
- GDD (Game Design Document): A comprehensive description covering every aspect of the game's design.
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.
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.
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,useReducercombined 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.
- State Access: Ability to read state from any point in the component tree, either via React vanilla tools (
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.
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.
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.