Mindulle Garden

Search

SearchSearch
        • DQL list query
        • DQL table query
        • AI-01-BasicSetup
        • AI-02-Title
        • AI-03-Topic
        • AI-04-Index
        • AI-05-Tag
        • AI-06-Summary
        • AI-07-Custom-Prompt
                • constructing-sequence-diagrams
                • high-level-sequence-diagrams
                • sequence-diagrams
                • sequence-diagrams-for-scenarios-of-business-use-cases
                • activity-diagram
                • class-diagram
                • constructing-class-diagrams
                • constructing-package-diagrams
                • package-diagram
                • constructing-statechart-diagrams
                • statechart-diagram
                • the-elements-of-the-view
                • the-life-of-an-object
                  • use-case-diagram
                • constructing-the-external-view
                • query-events-and-mutation-events
                • the-user-view-or-i-dont-care-how-it-works-as-long-as-it-works
                • use-case-sequence-diagram
                • communication-diagram
                • constructing-communication-diagrams
                • constructing-sequence-diagrams
                • elements-of-the-view
                • seeing-what-happens-inside-the-it-system
                • sequence-diagram
                • class-diagram
                • constructing-class-diagrams
                • elements-of-the-view
                • generalization-specialization-and-inheritance
                • objects-and-classes
                • static-and-dynamic-business-rules
                • activity-diagrams
                • constructing-diagrams-in-the-process-view
                • elements-of-the-view
                • sequence-diagram
                • the-business-system-model-as-foundation
                • class-diagram
                • constructing-class-diagrams
                • elements-of-the-view
                • transformation-of-uml-messages-into-various-stan
                • transforming-data-from-the-it-system-to-the-mess
            • Non-functional requirement
            • Goodharts-Law
            • Hofstadters-Law
            • Parkinsons-Law
            • Putts-Law
            • The-Hype-Cycle--Amaras-Law
            • Business Model Canvas
            • Call to Action
            • Cheating
            • Deploy Social Proof
            • Incremental A, B Testing
            • Lean Canvas
            • Dunbars-Number
            • Occams-Razor
            • The-Dilbert-Principle
            • The-Pareto-Principle-The-8020-Rule
            • The-Peter-Principle
            • Amdahls-Law
            • Galls-Law
            • Metcalfes-Law
            • Moores-Law
            • Reeds-Law
            • The-Law-of-Conservation-of-Complexity-Teslers-Law
            • The-Law-of-Leaky-Abstractions
            • Premature-Optimization-Effect
            • SOLID
            • The-Dependency-Inversion-Principle
            • The-DRY-Principle
            • The-Interface-Segregation-Principle
            • The-KISS-principle
            • The-Liskov-Substitution-Principle
            • The-OpenClosed-Principle
            • The-Robustness-Principle-Postels-Law
            • The-Single-Responsibility-Principle
            • YAGNI
            • 01. Define your brand identity
            • 02. Seek inspiration
            • 03. Determine logo style
            • 04. Choose a type
            • 05. Decide on a color scheme
            • 06. Pick a font
            • 07. Outline a logo shape
            • 08. Create a logo
            • 09. Refine the results
            • 10. Make a final decision
            • 11. Put your logo to work
            • How to design a logo
          • What is a combination mark logo
          • What is a lettermark logo
          • What is a logo
          • What is a mascot logo
          • What is a pictorial mark logo
          • What is a wordmark logo
          • What is an abstract mark logo
            • Black and white logos
            • Blue logos
            • Gray logos
            • Green logos
            • Orange logos
            • Pink logos
            • Purple logos
            • Red logos
            • Yellow logos
            • Abstract logo
            • Combination
            • Dynamic
            • Emblems
            • Geometric shapes in more detail
            • Letterform
            • Logo symbol
            • Wordmark
          • Best logo design tools
          • Best practices for logo design
          • FAQ
          • How to design a logo with AI
          • How to trademark your logo
          • What makes a good logo
          • Bear
            • File Input
            • Number Input
            • Rating
            • Search
            • Slider
            • @TABLE_OF_CONTENT
            • BASIS_01_laws
            • BASIS_02_process
            • BASIS_02_process-gist
            • BASIS_03_information_architecture
            • LAYOUT_01_artboard_and_margin
            • LAYOUT_02_grid_BASIS_
            • LAYOUT_03_set_grid_layout
            • LAYOUT_04_grouping
            • LAYOUT_05_sorting
            • LAYOUT_06_contrast
              • Peak-End_Rule
              • Serial_Position_Effect
              • Von_Restorff_Effect
              • Zeigarnik_Effect
              • Law_of_Common_Region
              • Law_of_Prägnanz
              • Law_of_Proximity
              • Law_of_Similarity
              • Law_of_Uniform_Connectedness
              • Aesthetic-Usability_Effect
              • Fitts’s_Law
              • Goal-Gradient_Effect
              • Hick’s_Law
              • Jakob’s_Law
              • Miller’s_Law
              • Parkinson’s_Law
            • Doherty_Threshold
            • Occam’s_Razor
            • Pareto_Principle
            • Postel’s_Law
            • Tesler’s_Law
            • 404 Page
            • About Page
            • Article Page
            • Blog Page
            • Cart Page
            • Contacts Page
            • Feed Page
            • Home Page
            • Landing Page
            • Menu Page
            • Portfolio Page
            • Product Page
            • Registration Page
            • Search Page
            • Services Page
            • Statistics Page
              • Are references copied in JavaScript
              • Can we change the state of the component directly
              • Can you use hooks in Server Components
              • Why you shouldn't use `index` as a key in React lists and iterators
              • React
                • How to debug JavaScript code
                • How to handle error in async-await
                • How to handle error in Promise
              • Can you merge multiple arrays in JavaScript
              • Does `forEach()` method return a new array
              • Does `map()` method mutate the original array
              • How to accept variable number of arguments in a JavaScript function
              • How to create a new Element in DOM
              • How to create Infinite Loop in JavaScript
              • How to define multiline strings in JavaScript
              • How to enable strict mode in JavaScript
              • How to get viewport dimensions in JavaScript
              • How to handle event bubbling in JavaScript
              • How to implement your own Custom Event in JavaScript
              • How to make an Object immutable in JavaScript
              • How to measure dimensions of an Element
              • How to parse JSON in JavaScript
              • How to remove an Element from DOM
              • How to run a piece of code after a specific time interval
              • How to run a piece of code only once after a specific time
              • How to scroll to the top of the page using JavaScript
              • How to select DOM elements using `querySelector()` and `querySelectorAll()`
              • How to use `do...while` loop in JavaScript
              • How to use `filter()` method
              • How to use `finally` block in Promise
              • How to use `reduce()` method
              • How you can find unique values in an array
              • What are the different ways to declare a variable in JavaScript
              • How to access environment variables in Node.js
              • How to create a web server in Node.js
              • How to load environment variables from a `.env` file in Node.js
              • How to read a file in Node.js
              • How to take user input from the command line in Node.js
              • What is the `os` module
              • How to create a Custom hook in React
              • How to render a list in React
              • How to render HTML in React
              • What are different options to style a React component
              • composing-methods
              • dealing-with-generalization
              • moving-features-between-objects
              • organizing-data
              • simplifying-conditional-expressions
              • simplifying-method-calls
              • Clean code
              • How to refactor
              • Technical debt
              • When to refactor
            • Catalog of Refactoring
            • Cheat Sheet
                • celebrate-success
                • change-functioning
                • merge-approved-code
                • monitor-performance
                • address-feedback-received
                • implement-changes-explanations
                • run-tests-ensure-passing
                • seek-team-members-feedback
                • submit-re-review
                • update-review-changes-docs
                • address-author-concerns
                • author-feedback-welcomed
                • re-run-tests-verify
                • resolve-conflicts-timely
                • review-updated-code
                • verify-changes-addressed
                • adhere-guidelines
                • changes-ready
                • open-mind-author
                • potential-issues-review
                • proper-description-pr
                • self-review
                • tested-in-dev
                • architecture-understanding
                • collaborate-reviewer-author
                • determine-review-level
                • learn-context-reqs
                • list-review-risks-issues
                • open-mind-reviewer
                • prepare-list
                • quality-code-overall
                • review-docs-design
                • clear-feedback
                • code-guide-best-practices-adherence
                • continuous-improvement-over-perfection
                • nitpick-comments
                • pair-programming-reviews
                • positive-feedback-criticism
                • potential-issues-reviewer
                • prioritize-feedback
                • professional-feedback
                • review-docs-updated
                • review-tests
                • short-term-long-term-considerations
                • team-wide-style-followed
                • complex-tasks-breakage
                • consistency-everywhere
                • document-new-feature
                • failing-text-bug
                • follow-guidelines
                • impact-of-change
                • note-questions-for-review
                • update-docs-changes
                • write-automated-tests
                • adequate-review-time
                • code-review-purpose
                • conflict-resolution
                • cross-functional-knowledge
                • definition-of-done
                • document-new-feature
                • encourage-participation
                • knowledge-sharing
                • monitor-reviews
                • no-one-way-process
                • recognition-rewards
                • seek-feedback
                • set-clear-expectations
                • style-guide-preferences
                • trends-issues-finding
                • use-automation
            • API Semantics
            • Code Style
            • Documentations
            • Implementation Semantics
            • Tests
            • bloaters
            • change-preventers
            • couplers
            • dispensables
            • oo-abusers
            • other
                • anti-patterns
                • command-line
                • http-server
                • io
                • json
                • time
                • websockets
                • arrays-and-slices
                • concurrency
                • context
                • dependency-injection
                • generics
                • hello-world
                • install-go
                • integers
                • iteration
                • maps
                • math
                • mocking
                • pointers-and-errors
                • reading-files
                • reflection
                • revisiting-arrays-and-slices-with-generics
                • roman-numerals
                • select
                • structs-methods-and-interfaces
                • sync
                • template
                • intro-to-acceptance-tests
                • scaling-acceptance-tests
                • working-without-mocks
                • context-aware-reader
                • error-types
                • http-handlers-revisited
                • os-exec
                • why-unit-test
                • 0 Design for lean testing
                • 1-1 Include 3 parts in each test name
                • 1-2 Structure tests by the AAA pattern
                • 1-3 Describe expectations in a product language use BDD-style assertions
                • 1-4 Stick to black-box testing Test only public methods
                • 1-5 Choose the right test doubles Avoid mocks in favor of stubs and spies
                • 1-6 Dont foo use realistic input data
                • 1-7 Test many input combinations using Property-based testing
                • 1-8 If needed use only short inline snapshots
                • 1-9 Copy code but only whats neccessary
                • 1-10 Dont catch errors expect them
                • 1-11 Tag your tests
                • 1-12 Categorize tests under at least 2 levels
                • 1-13 Other generic good testing hygiene
                • 2-1 Enrich your testing portfolio Look beyond unit tests and the pyramid
                • 2-2 Component testing might be your best affair
                • 2-3 Ensure new releases dont break the API using contract tests
                • 2-4 Test your middlewares in isolation
                • 2-5 Measure and refactor using static analysis tools
                • 2-6 Check your readiness for Node-related chaos
                • 2-7 Avoid global test fixtures and seeds add data per-test
                • 2-8 Choose a clear data clean-up strategy After-all recommended or after-each
                • 2-9 Isolate the component from the world using HTTP interceptor
                • 2-10 Test the response schema mostly when there are auto-generated fields
                • 2-11 Check integrations corner cases and chaos
                • 2-12 Test the five potential outcomes
                • 3-1 Separate UI from functionality
                • 3-2 Query HTML elements based on attributes that are unlikely to change
                • 3-3 Whenever possible test with a realistic and fully rendered component
                • 3-4 Dont sleep use frameworks built-in support for async events. Also try to speed things up
                • 3-5 Watch how the content is served over the network
                • 3-6 Stub flaky and slow resources like backend APIs
                • 3-7 Have very few end-to-end tests that spans the whole system
                • 3-8 Speed-up E2E tests by reusing login credentials
                • 3-9 Have one E2E smoke test that just travels across the site map
                • 3-10 Expose the tests as a live collaborative document
                • 3-11 Detect visual issues with automated tools
                • 4-1 Get enough coverage for being confident 80 seems to be the lucky number
                • 4-2 Inspect coverage reports to detect untested areas and other oddities
                • 4-3 Measure logical coverage using mutation testing
                • 4-4 Preventing test code issues with Test linters
                • 5-1 Enrich your linters and abort builds that have linting issues
                • 5-2 Shorten the feedback loop with local developer-CI
                • 5-3 Perform e2e testing over a true production-mirror
                • 5-4 Parallelize test execution
                • 5-5 Stay away from legal issues using license and plagiarism check
                • 5-6 Constantly inspect for vulnerable dependencies
                • 5-7 Automate dependency updates
                • 5-8 Other non-Node related CI tips
                • 5-9 Build matrix Run the same CI steps using multiple Node versions
                • readme
            • ployglot (computing)
            • Seeding (computing)
                • Asynchronous vs Synchronous code
                • Is Java and JavaScript the same
                • What is the difference between `Map` and `WeakMap` in JavaScript
                • What is the difference between `null` and `undefined`
                • What is the difference between `var`, `let`, and `const` in JavaScript
                • What is the purpose of the `async-await` in JavaScript
              • Garbage collection in JavaScript
              • What are Explicit binding in JavaScript
              • What are Heap and Stack in JavaScript
              • What are Scopes in JavaScript
              • What is a closure in JavaScript
              • What is a JavaScript promise
              • What is callback hell in JavaScript
              • What is DOM
              • What is Event Capturing in JavaScript
              • What is Event Loop in JavaScript
              • What is Hoisting in JavaScript
              • What is Inheritance in JavaScript
              • What is JavaScript
              • What is Prototype Chain in JavaScript
              • What is Type Casting
                • CommonJS and ESM
                • What is the difference between Node.js and AJAX
                • What is the difference between Node.js and JavaScript
                • What is the purpose of `fs` module
                • What is the purpose of `path` module
              • What are Event Emitters in Node.js
              • What are modules in Node.js
              • What are streams in Node.js
              • What is `npm`
              • What is `npx`
              • What is Clustering in Node.js
              • What is Event Loop in Node.js
              • What is Node.js
              • What is REPL in Node.js
              • What is the full form of `npm`
                • class components and function components
                • controlled and uncontrolled components
                • Server Components differ from Client Components
                • state and props
                • stateful and stateless components
                • The difference between react and react-dom
                • purpose of key attribute
                • purpose of the useEffect hook
                • Suspense
              • component's lifecycle
              • Concurrent React (Concurrent Mode)
              • Context
              • Features of React
              • Fragments
              • Higher-Order Components (HOCs)
              • Hydration
              • Pure Components
              • Reconciliation
              • ref forwarding
              • Refs
              • Server Components
              • Synthetic Events
              • What is a React
            • Block statement
            • artifact (software development)
            • Feature flag
            • Generic function
            • Variadic function
                • Difference between `appendChild()` and `insertBefore()`
                • Difference between `defer` and `async` attributes in JavaScript
                • Difference between `Promise.all()` and `Promise.allSettled()`
                • Explain `alert()`, `prompt()`, and `confirm()` methods in JavaScript
                • What is the difference between `map()` and `forEach()` methods
                • What is the difference between `map()` and `reduce()` methods
              • Switch case statement in JavaScript
              • Uses of `break` and `continue` statements in JavaScript
              • What are Labelled Statements in JavaScript
              • What are the Logical Operators in JavaScript
              • What is `preventDefault()` method in JavaScript
              • What is Comma Operator in JavaScript
              • What is IIFE in JavaScript
              • What is Increment operator in JavaScript
              • What is Map in JavaScript
              • What is Nullish Coalescing Operator
              • What is Set in JavaScript
              • What is ternary operator in JavaScript
              • What is the difference between `==` and `===`
              • What is the spread operator in JavaScript
                • What is difference between `fork` and `spawn` methods of `child_process` module
                • What is the difference between `process.cwd()` and `__dirname`
                • What is the difference between `process.nextTick()` and `setImmediate()`
              • Different exit codes in Node.js
              • What is `__filename`
              • What is `process.argv`
              • What is `process.cwd()`
              • What is `process.exit()`
              • What is `setInterval()`
              • What is `setTimeout()`
              • What is the `global` object in Node.js
                • purpose of `flushSync`
                • purpose of the `useContext` hook
                • purpose of the `useMemo` hook
              • Comment
              • Error boundaries
              • Hooks
              • JSX
              • Portals
              • Strict Mode
              • use client and use server directives
              • useTransition hook
            • Shebang (Unix)
          • artifact
          • polyglot
            • Protocol Buffers
                • chain-of-responsibility
                • command
                • iterator
                • mediator
                • memento
                • observer
                • state
                • strategy
                • template-method
                • visitor
                • abstract-factory
                • builder
                • factory-method
                • prototype
                • singleton
                • adapter
                • bridge
                • composite
                • decorator
                • facade
                • flyweight
                • proxy
              • behavioral-patterns
              • catalog
              • creational-patterns
              • structural-patterns
              • classification
              • criticism
              • history
              • what-is-pattern
              • why-learn-patterns
              • compound-pattern
              • hoc-pattern
              • hooks-pattern
              • presentational-container-pattern
              • render-props-pattern
              • command-pattern
              • factory-pattern
              • flyweight-pattern
              • mediator-pattern
              • mixin-pattern
              • module-pattern
              • observer-pattern
              • prototype-pattern
              • provider-pattern
              • proxy-pattern
              • singleton-pattern
              • static-import
            • Trunk Based Development
            • Brooks-Law
            • Conways-Law
            • Cunninghams-Law
            • Hutbers-Law
            • Hyrums-Law-The-Law-of-Implicit-Interfaces
            • Kernighans-Law
            • The-Law-of-Triviality
            • Wadlers-Law
            • Wheatons-Law
            • The-Fallacies-of-Distributed-Computing
            • The-Spotify-Model
            • The-Unix-Philosophy
              • ApendixA_Essential_Functions_Support
              • ApendixB_Algebraic_Structures_Support
              • ApendixC_Pointfree_Utilities
              • CH_01_What_Ever_Are_We_Doing
              • CH_02_First_Class_Functions
              • CH_03_Pure_Happiness_with_Pure_Functions
              • CH_04_Currying
              • CH_05_Coding_by_Composing
              • CH_06_Example_Application
              • CH_07_Hindley-Milner_and_Me
              • CH_08_Tupperware
              • CH_09_Monadic_Onions
              • CH_10_Applicative_Functors
              • CH_11_Transform_Again,_Naturally
              • CH_12_Traversing_the_Stone
              • CH_13_Monoids_bring_it_all_together
              • How do you investigate a slow React app and identify performance bottlenecks
              • How to lazy load components in React
              • What could be the reasons for un-necessary re-renders in React
              • bundle-splitting
              • compression
              • dynamic-import
              • import-on-interaction
              • import-on-visibility
              • loading-sequence
              • prefetch
              • preload
              • prpl
              • third-party
              • tree-shaking
              • virtual-lists
              • client-side-rendering
              • incremental-static-rendering
              • progressive-hydration
              • react-selective-hydration
              • react-server-components
              • server-side-rendering
              • static-rendering
              • streaming-ssr
              • islands-architecture
              • rendering-patterns
              • view-transitions
              • Does Arrow functions have their own `this`
              • How does Event Loop work in JavaScript
              • Is it possible to run 2 lines of code at the same time in JavaScript
              • Is it possible to run JavaScript outside the browser
              • Is JavaScript a compiled or interpreted language
              • Can you access the DOM in Node.js
              • How can memory leaks happen in Node.js
              • How Node.js handle errors
              • What is the order priority of `process.nextTick`, `Promise`, `setTimeout`, and `setImmediate`
              • How do React Server Components handle data fetching
              • How does React handle prop drilling, and what are the downsides of excessive prop drilling
              • How React Virtual DOM works
              • How to render React components as static HTML string
              • React Fiber
              • What is the difference between Real DOM and Virtual DOM
          • 1. Tech Writing for Accessibility
          • 2-1. Tech Writing for Accessibility self-study
          • 2-2. Design inclusive writing
          • 2-3. Write helpful alt text
          • 2-4. Use sufficient contrast
          • 2-5. Choose inclusive language
          • 2-6. Add accessible visuals to writing
          • 2-7. Edit for accessibility
          • 2-8. Conclusion
          • 1-1. Introduction
          • 1-2. General error handling rules
          • 2-1. Identify the error's cause
          • 2-2. Identify the user's invalid inputs
          • 2-3. Specify requirements and constraints
          • 3-1. Explain how to fix the problem
          • 3-2. Provide examples
          • 4-1. Be concise
          • 4-2. Avoid double negatives
          • 4-3. Write for the target audience
          • 4-4. Use terminology consistently
          • 4-5 Format error message
          • 4-6. Set the right tone
          • 5-1. Want to play a game
          • 5-2. Summary
          • 5-3. Additional guidelines for back-end engineers
          • 1. Introduction
          • 2. Just enough grammar (optional)
          • 3. Words
          • 4. Active Voice
          • 5. Clear Sentences
          • 6. Short Sentence
          • 7. Lists and tables
          • 8. Paragraphs
          • 9. Audience
          • 10. Documents
          • 11. Punctuation (Optional)
          • 12. Markdown (Optional)
          • 13. Summary
          • 1. Introduction
          • 2. Self-editing
          • 3. Organizing large docs
          • 4. illustrating
          • 5. Creating sample code
          • 6. Summary
Home

❯

Develop

❯

_commons

❯

tree

❯

Principle

❯

The-Spotify-Model

The-Spotify-Model

May 02, 2025, 1 min read

스포티파이 모델 §

The Spotify Model on Spotify Labs

스포티파이 모델은 ‘스포티파이’에 의해 유명해진 팀과 조직 구조에 대한 접근법이다. 이 모델에서 팀은 기술보단 기능을 중심으로 구성된다.

스포티파이 모델은 부족, 길드, 지부와 같은 그들 조직 구조의 요소 또한 유명하게 만들었다.

Spotify Tribe Engineering Model (이미지 출처: https://medium.com/@media_75624/exploring-key-elements-of-spotifys-agile-scaling-model-471d2a23d7ea)

Graph View

Backlinks

  • Conways-Law

Created with Quartz v4.1.1, © 2025

  • GitHub