This HTML5 document contains 132 embedded RDF statements represented using HTML+Microdata notation.

The embedded RDF content will be recognized by any processor of HTML5 Microdata.

Namespace Prefixes

PrefixIRI
dbpedia-dehttp://de.dbpedia.org/resource/
dctermshttp://purl.org/dc/terms/
yago-reshttp://yago-knowledge.org/resource/
dbohttp://dbpedia.org/ontology/
foafhttp://xmlns.com/foaf/0.1/
dbpedia-cahttp://ca.dbpedia.org/resource/
dbpedia-huhttp://hu.dbpedia.org/resource/
dbpedia-eshttp://es.dbpedia.org/resource/
n12https://global.dbpedia.org/id/
dbpedia-behttp://be.dbpedia.org/resource/
yagohttp://dbpedia.org/class/yago/
dbpedia-ruhttp://ru.dbpedia.org/resource/
dbthttp://dbpedia.org/resource/Template:
dbpedia-ukhttp://uk.dbpedia.org/resource/
rdfshttp://www.w3.org/2000/01/rdf-schema#
dbpedia-svhttp://sv.dbpedia.org/resource/
freebasehttp://rdf.freebase.com/ns/
dbpedia-pthttp://pt.dbpedia.org/resource/
rdfhttp://www.w3.org/1999/02/22-rdf-syntax-ns#
owlhttp://www.w3.org/2002/07/owl#
dbpedia-ithttp://it.dbpedia.org/resource/
wikipedia-enhttp://en.wikipedia.org/wiki/
dbpedia-zhhttp://zh.dbpedia.org/resource/
dbpedia-frhttp://fr.dbpedia.org/resource/
dbphttp://dbpedia.org/property/
dbchttp://dbpedia.org/resource/Category:
provhttp://www.w3.org/ns/prov#
xsdhhttp://www.w3.org/2001/XMLSchema#
dbpedia-nlhttp://nl.dbpedia.org/resource/
wikidatahttp://www.wikidata.org/entity/
dbrhttp://dbpedia.org/resource/
dbpedia-jahttp://ja.dbpedia.org/resource/

Statements

Subject Item
dbr:Design_Patterns
dbo:wikiPageWikiLink
dbr:GRASP_(object-oriented_design)
Subject Item
dbr:Interface_segregation_principle
dbo:wikiPageWikiLink
dbr:GRASP_(object-oriented_design)
Subject Item
dbr:Object-oriented_design
dbo:wikiPageWikiLink
dbr:GRASP_(object-oriented_design)
Subject Item
dbr:Object-oriented_programming
dbo:wikiPageWikiLink
dbr:GRASP_(object-oriented_design)
Subject Item
dbr:GRASP_(object-oriented_design)
rdf:type
owl:Thing yago:Abstraction100002137 yago:Form105930736 yago:Content105809192 yago:WikicatSoftwareDesignPatterns yago:WikicatProgrammingPrinciples yago:Idea105833840 yago:Cognition100023271 yago:Principle105913538 yago:Generalization105913275 yago:PsychologicalFeature100023100 yago:Structure105726345
rdfs:label
GRASP GRASP GRASP (disseny orientat a objectes) GRASP (object-oriented design) GRASP GRASP (物件導向設計) GRASP Grasp GRASP GRASP (padrão orientado a objetos) GRASP GRASP GRASP (programmation)
rdfs:comment
General Responsibility Assignment Software Patterns (or Principles), abbreviated GRASP, is a set of "nine fundamental principles in object design and responsibility assignment" first published by Craig Larman in his 1997 book Applying UML and Patterns. Larman states that "the critical design tool for software development is a mind well educated in design principles. It is not UML or any other technology." Thus, the GRASP principles are really a mental toolset, a learning aid to help in the design of object-oriented software. Grasp står för General responsibility assignment software patterns, och är ett antal mönster som används inom objektorientering för att placera ansvaret för ett programs funktioner i rätt klass eller objekt. Exempel på mönster som används inom Grasp är Information expert, Creator, Controller, Low coupling, High cohesion, Polymorphism, Pure fabrication, Indirection och Don't talk to strangers. GRASP (англ. general responsibility assignment software patterns — общие шаблоны распределения ответственностей; также существует английское слово "grasp" — «контроль, хватка») — шаблоны, используемые в объектно-ориентированном проектировании для решения общих задач по назначению ответственностей классам и объектам. General responsibility assignment software patterns (ou principles), abreviado GRASP, consiste em diretrizes para atribuir responsabilidade a classes e objetos em projeto orientado a objetos. Os diferentes padrões e princípios utilizados no GRASP são: controller (controlador), creator (criador), indirection (indireção), information expert (especialista na informação), alta coesão, baixo acoplamento, polimorfismo, pure fabrication (fabricação/invenção pura) e protected variations (variações protegidas). Todos esses padrões respondem a algum problema, e esses problemas são comuns a quase todos os projetos de desenvolvimento de software. Essas técnicas não foram inventadas a fim de criar novas formas de trabalho, mas para melhor documentar e padronizar os antigos e amplamente praticados princ L'acrònim GRASP, en l'àmbit de la programació orientada a objectes, correspon a General Responsibility Assignment Software Patterns (Patrons Generals de Software per a l'Assignació de Responsabilitats) El terme patrons GRASP, més que a patrons pròpiament dits, fa referència a una sèrie de bones pràctiques i principis fonamentals a l'hora d'assignar responsabilitats als diferents objectes i classes. En diseño orientado a objetos, GRASP son patrones generales de software para asignación de responsabilidades, es el acrónimo de "GRASP (object-oriented design General Responsibility Assignment Software Patterns)". Aunque se considera que más que patrones propiamente dichos, son una serie de "buenas prácticas" de aplicación recomendable en el diseño de software. GRASP (General Responsibility Assignment Software Patterns) bezeichnet in der Softwaretechnik eine Menge von Entwurfsmustern, mit denen die Zuständigkeit bestimmter Klassen objektorientierter Systeme festgelegt wird. Sie beschreiben also allgemein, welche Klassen und Objekte wofür zuständig sein sollten.Alle diese Regeln sind schon lange bekannt, sie wurden von Craig Larman einfach systematisch beschrieben. Dies erleichtert die Kommunikation zwischen Softwareentwicklern und erleichtert Einsteigern das Entwickeln eines Bewusstseins für guten bzw. schlechten Code. GRASPとは、General Responsibility Assignment Software PatternあるいはPrinciple（汎用的責任性割り当てパターン/原則）の頭字語であり、オブジェクト指向設計に向けた九つの原則セットまたはパターンセットである。計算機科学者の1997年著作「実践UMLパターン -Applying UML and Patterns-」で初めて紹介されている。 「ソフトウェア開発において決定的な設計ツールになるのは、設計の原則の中で磨き上げられたメンタルであって、UMLやその他のテクノロジーではない」がラーマンの主張であり、GRASPとはオブジェクト指向開発を助けるためのメンタルツール（mental tool）であると定義している[1]。 General responsibility assignment software patterns (ou principles), abrégé en GRASP, se composent de lignes directrices pour l'attribution de la responsabilité des classes et des objets en conception orientée objet. D'après Craig Larman, « le meilleur outil de conception pour le développement de logiciels est un esprit bien éduqué sur les principes de conception. Ce n'est pas UML ou toute autre technologie ». Ainsi, GRASP est surtout une boîte à outils mentale, une aide à la conception de logiciels orientés objets. GRASP (англ. General Responsibility Assignment Software Patterns) — набір патернів (шаблонів, принципів), що дозволяють вирішувати проблеми розподілу обов'язків між різними класами. За своєю суттю, цей набір патернів більш абстрактний, ніж загально відомий каталог шаблонів від «Банди чотирьох» (GOF-шаблони). До складу шаблонів GRASP входить 9 шаблонів: * Information Expert * Creator * Low Coupling * High Cohesion * Controller * Polymorphism * Pure Fabrication * Indirection * Protected Variations GRASP (General Responsibility Assignment Software Patterns) è una collezione di pattern, usata nella progettazione object-oriented, che fornisce delle linee guida per l'assegnazione di responsabilità alle classi e agli oggetti. Come dichiarato da Craig Larman nella prefazione del suo libro Applying UML and Patterns, GRASP è una sorta di strumento "mentale", un aiuto didattico per la progettazione del software orientato agli oggetti. GRASP is een Engels acroniem dat staat voor Generalized Responsibility Assignment Software Patterns/Principles. Het bestaat uit 9 richtlijnen die kunnen worden gebruikt om in objectgeoriënteerde systemen verantwoordelijkheden toe te kennen aan klassen of objecten. Elke richtlijn behandelt een combinatie van een veelvoorkomend probleem en een algemeen toepasbare oplossing voor dat probleem met betrekking tot het ontwerp van softwaresystemen. De 9 richtlijnen zijn: GRASP是通用职责分配软件模式（General Responsibility Assignment Software Patterns）的簡稱，是物件導向設計和职责分配中的九個基本原則，最早是在1997年的Applying UML and Patterns書中提到。 GRASP中提到的模式和原則包括有控制器（controller）、創建者（creator）、中介（indirection）、資訊專家（information expert）、低耦合性（low coupling）、高內聚性（high cohesion）、多态（polymorphism）、保護變化（protected variations）和純虛構（pure Fabrication）。這些模式都是針對软件开发上的一些問題進行解決。發明這些技巧不是為了要創造新的工作方式，而是為在物件導向設計上，舊的，經過測試的程序设计方式建立文檔並且標準化。 克雷·拉蒙提到：「軟體開發最關鍵的設計工具不是UML或其他的技術，是明瞭設計原則的心智。」。因此，GRASP原則是心理層面的工具集，在物件導向軟體設計學習上的輔助工具。
rdfs:seeAlso
dbr:Open dbr:Closed_principle dbr:Information_hiding dbr:Factory_pattern dbr:Service_(systems_architecture)
dcterms:subject
dbc:Programming_principles dbc:Software_design
dbo:wikiPageID
4907231
dbo:wikiPageRevisionID
1100772161
dbo:wikiPageWikiLink
dbr:Layer_(object-oriented_design) dbr:Interface_(computer_science) dbr:Use_case dbr:User_Interface dbr:Cohesion_(computer_science) dbc:Programming_principles dbr:Unified_Modeling_Language dbr:Software dbr:Coupling_(computer_science) dbc:Software_design dbr:Facade_pattern dbr:Computer_programming dbr:Design_pattern_(computer_science) dbr:Design_Patterns_(book) dbr:Software_development dbr:SOLID_(object-oriented_design) dbr:Domain-driven_design dbr:Object-oriented_design dbr:Anemic_domain_model dbr:Command_pattern dbr:Polymorphism_(object-oriented_programming) dbr:Polymorphism_(computer_science) dbr:Factory_pattern dbr:Domain_layer dbr:Craig_Larman
owl:sameAs
dbpedia-fr:GRASP_(programmation) dbpedia-sv:Grasp dbpedia-it:GRASP n12:ViuX dbpedia-nl:GRASP dbpedia-ja:GRASP yago-res:GRASP_(object-oriented_design) dbpedia-pt:GRASP_(padrão_orientado_a_objetos) dbpedia-ru:GRASP dbpedia-uk:GRASP wikidata:Q1486676 dbpedia-hu:Általános_felelősség dbpedia-zh:GRASP_(物件導向設計) dbpedia-de:GRASP dbpedia-be:GRASP freebase:m.0ctl_3 dbpedia-ca:GRASP_(disseny_orientat_a_objectes) dbpedia-es:GRASP
dbp:wikiPageUsesTemplate
dbt:See_also dbt:Main dbt:More_footnotes dbt:Rp dbt:Primary dbt:Short_description dbt:Cn
dbo:abstract
GRASP (General Responsibility Assignment Software Patterns) è una collezione di pattern, usata nella progettazione object-oriented, che fornisce delle linee guida per l'assegnazione di responsabilità alle classi e agli oggetti. GRASP comprende principalmente i seguenti pattern: Information Expert, Creator, Controller, Low Coupling, High Cohesion, Polymorphism, Pure Fabrication, Indirection, Protected Variations. Tutti questi pattern rispondono ad alcune problematiche del software, nella maggior parte dei casi relativi a progetti di sviluppo software; pertanto, non servono per creare nuove informazioni, ma per migliorare la documentazione del software e standardizzare i vecchi modelli di programmazione. Come dichiarato da Craig Larman nella prefazione del suo libro Applying UML and Patterns, GRASP è una sorta di strumento "mentale", un aiuto didattico per la progettazione del software orientato agli oggetti. General responsibility assignment software patterns (ou principles), abrégé en GRASP, se composent de lignes directrices pour l'attribution de la responsabilité des classes et des objets en conception orientée objet. Les différents modèles et principes utilisés par les GRASP sont : le contrôleur, le créateur, l'indirection, le spécialiste de l'information, la cohésion forte, le couplage faible, le polymorphisme, les variations protégées, et l'invention pure. Tous ces modèles répondent à certains problèmes récurrents du développement logiciel. Ils n'ont pas été conçus pour créer une nouvelle façon de travailler, mais pour mieux documenter et normaliser l'existant à l'aide de principes de programmation éprouvés en conception orientée objet. D'après Craig Larman, « le meilleur outil de conception pour le développement de logiciels est un esprit bien éduqué sur les principes de conception. Ce n'est pas UML ou toute autre technologie ». Ainsi, GRASP est surtout une boîte à outils mentale, une aide à la conception de logiciels orientés objets. GRASPとは、General Responsibility Assignment Software PatternあるいはPrinciple（汎用的責任性割り当てパターン/原則）の頭字語であり、オブジェクト指向設計に向けた九つの原則セットまたはパターンセットである。計算機科学者の1997年著作「実践UMLパターン -Applying UML and Patterns-」で初めて紹介されている。 「ソフトウェア開発において決定的な設計ツールになるのは、設計の原則の中で磨き上げられたメンタルであって、UMLやその他のテクノロジーではない」がラーマンの主張であり、GRASPとはオブジェクト指向開発を助けるためのメンタルツール（mental tool）であると定義している[1]。 GRASP是通用职责分配软件模式（General Responsibility Assignment Software Patterns）的簡稱，是物件導向設計和职责分配中的九個基本原則，最早是在1997年的Applying UML and Patterns書中提到。 GRASP中提到的模式和原則包括有控制器（controller）、創建者（creator）、中介（indirection）、資訊專家（information expert）、低耦合性（low coupling）、高內聚性（high cohesion）、多态（polymorphism）、保護變化（protected variations）和純虛構（pure Fabrication）。這些模式都是針對软件开发上的一些問題進行解決。發明這些技巧不是為了要創造新的工作方式，而是為在物件導向設計上，舊的，經過測試的程序设计方式建立文檔並且標準化。 克雷·拉蒙提到：「軟體開發最關鍵的設計工具不是UML或其他的技術，是明瞭設計原則的心智。」。因此，GRASP原則是心理層面的工具集，在物件導向軟體設計學習上的輔助工具。 GRASP (англ. general responsibility assignment software patterns — общие шаблоны распределения ответственностей; также существует английское слово "grasp" — «контроль, хватка») — шаблоны, используемые в объектно-ориентированном проектировании для решения общих задач по назначению ответственностей классам и объектам. В книге Крэга Лармана «Применение UML и шаблонов проектирования» описано 9 таких шаблонов: каждый помогает решить некоторую проблему, возникающую как в объектно-ориентированном анализе, так и в практически любом проекте по разработке программного обеспечения. Таким образом, шаблоны «G.R.A.S.P.» — хорошо документированные, стандартизированные и проверенные временем принципы объектно-ориентированного анализа, а не попытка привнести что-то принципиально новое. L'acrònim GRASP, en l'àmbit de la programació orientada a objectes, correspon a General Responsibility Assignment Software Patterns (Patrons Generals de Software per a l'Assignació de Responsabilitats) El terme patrons GRASP, més que a patrons pròpiament dits, fa referència a una sèrie de bones pràctiques i principis fonamentals a l'hora d'assignar responsabilitats als diferents objectes i classes. Els patrons GRASP intenten solucionar problemes recurrents a gairebé tots els projectes de desenvolupament de software. Aquestes tècniques no s'inventen per tal de crear nous mètodes de treball si no per documentar i estandarditzar principis llargament testejats i funcionals. General responsibility assignment software patterns (ou principles), abreviado GRASP, consiste em diretrizes para atribuir responsabilidade a classes e objetos em projeto orientado a objetos. Os diferentes padrões e princípios utilizados no GRASP são: controller (controlador), creator (criador), indirection (indireção), information expert (especialista na informação), alta coesão, baixo acoplamento, polimorfismo, pure fabrication (fabricação/invenção pura) e protected variations (variações protegidas). Todos esses padrões respondem a algum problema, e esses problemas são comuns a quase todos os projetos de desenvolvimento de software. Essas técnicas não foram inventadas a fim de criar novas formas de trabalho, mas para melhor documentar e padronizar os antigos e amplamente praticados princípios de programação em padrões orientado a objetos. Craig Larman, cientista da computação, afirma que "a ferramenta crucial de projeto para desenvolvimento de software é uma mente bem educada em princípios de projeto. Não é UML ou qualquer outra tecnologia". Assim, GRASP é realmente um conjunto de ferramentas mentais, um auxílio de aprendizagem para ajudar no projeto de software orientado a objetos. GRASP is een Engels acroniem dat staat voor Generalized Responsibility Assignment Software Patterns/Principles. Het bestaat uit 9 richtlijnen die kunnen worden gebruikt om in objectgeoriënteerde systemen verantwoordelijkheden toe te kennen aan klassen of objecten. Elke richtlijn behandelt een combinatie van een veelvoorkomend probleem en een algemeen toepasbare oplossing voor dat probleem met betrekking tot het ontwerp van softwaresystemen. Voor de laatste letter van acroniem GRASP wordt zowel Patterns (patronen) als Principles (richtlijnen) gebruikt. De benaming 'richtlijn' moet benadrukken dat het hier gaat om een hoger abstractieniveau dan een ontwerppatroon zoals beschreven door de "Gang of Four (GOF)". Bovendien geeft de term 'richtlijn' aan dat het om een advies gaat. Tijdens het ontwerpproces zal namelijk soms een afweging gemaakt moeten worden tussen meerdere richtlijnen. De GOF Patterns zijn ontwerpregels. Het gaat hier niet om een vrijblijvende keuze. De praktijk heeft uitgewezen dat het zo moet.Maar, uiteraard is uiteindelijk het mechanisme belangrijker dan de benaming. De 9 richtlijnen zijn: 1. * Creator 2. * Information Expert 3. * Low Coupling 4. * High Cohesion 5. * Controller 6. * Polymorphism 7. * Pure Fabrication 8. * Indirection 9. * Protected Variations General Responsibility Assignment Software Patterns (or Principles), abbreviated GRASP, is a set of "nine fundamental principles in object design and responsibility assignment" first published by Craig Larman in his 1997 book Applying UML and Patterns. The different patterns and principles used in GRASP are controller, creator, indirection, information expert, low coupling, high cohesion, polymorphism, protected variations, and pure fabrication. All these patterns solve some software problem common to many software development projects. These techniques have not been invented to create new ways of working, but to better document and standardize old, tried-and-tested programming principles in object-oriented design. Larman states that "the critical design tool for software development is a mind well educated in design principles. It is not UML or any other technology." Thus, the GRASP principles are really a mental toolset, a learning aid to help in the design of object-oriented software. En diseño orientado a objetos, GRASP son patrones generales de software para asignación de responsabilidades, es el acrónimo de "GRASP (object-oriented design General Responsibility Assignment Software Patterns)". Aunque se considera que más que patrones propiamente dichos, son una serie de "buenas prácticas" de aplicación recomendable en el diseño de software. Grasp står för General responsibility assignment software patterns, och är ett antal mönster som används inom objektorientering för att placera ansvaret för ett programs funktioner i rätt klass eller objekt. Exempel på mönster som används inom Grasp är Information expert, Creator, Controller, Low coupling, High cohesion, Polymorphism, Pure fabrication, Indirection och Don't talk to strangers. GRASP (General Responsibility Assignment Software Patterns) bezeichnet in der Softwaretechnik eine Menge von Entwurfsmustern, mit denen die Zuständigkeit bestimmter Klassen objektorientierter Systeme festgelegt wird. Sie beschreiben also allgemein, welche Klassen und Objekte wofür zuständig sein sollten.Alle diese Regeln sind schon lange bekannt, sie wurden von Craig Larman einfach systematisch beschrieben. Dies erleichtert die Kommunikation zwischen Softwareentwicklern und erleichtert Einsteigern das Entwickeln eines Bewusstseins für guten bzw. schlechten Code. GRASP (англ. General Responsibility Assignment Software Patterns) — набір патернів (шаблонів, принципів), що дозволяють вирішувати проблеми розподілу обов'язків між різними класами. За своєю суттю, цей набір патернів більш абстрактний, ніж загально відомий каталог шаблонів від «Банди чотирьох» (GOF-шаблони). До складу шаблонів GRASP входить 9 шаблонів: * Information Expert * Creator * Low Coupling * High Cohesion * Controller * Polymorphism * Pure Fabrication * Indirection * Protected Variations Відомо дев'ять GRASP шаблонів, спочатку описаних у книзі Крейга Ларман «Застосування UML і шаблонів проектування». На відміну від звичних читачеві патернів з Банди Чотирьох, GRASP патерни не мають вираженої структури, чіткої області застосування і конкретної розв'язуваної проблеми, а лише являють собою узагальнені підходи / рекомендації / принципи, використовувані при проектуванні дизайну системи. «Applying UML and Patterns — An Introduction to Object-Oriented Analysis and Design and Iterative Development»
prov:wasDerivedFrom
wikipedia-en:GRASP_(object-oriented_design)?oldid=1100772161&ns=0
dbo:wikiPageLength
10950
foaf:isPrimaryTopicOf
wikipedia-en:GRASP_(object-oriented_design)
Subject Item
dbr:Anemic_domain_model
dbo:wikiPageWikiLink
dbr:GRASP_(object-oriented_design)
Subject Item
dbr:Grasp_(disambiguation)
dbo:wikiPageWikiLink
dbr:GRASP_(object-oriented_design)
dbo:wikiPageDisambiguates
dbr:GRASP_(object-oriented_design)
Subject Item
dbr:Craig_Larman
dbo:wikiPageWikiLink
dbr:GRASP_(object-oriented_design)
Subject Item
dbr:Multitier_architecture
dbo:wikiPageWikiLink
dbr:GRASP_(object-oriented_design)
Subject Item
dbr:Template_method_pattern
dbo:wikiPageWikiLink
dbr:GRASP_(object-oriented_design)
Subject Item
dbr:Software_design_pattern
dbo:wikiPageWikiLink
dbr:GRASP_(object-oriented_design)
Subject Item
dbr:Single-responsibility_principle
dbo:wikiPageWikiLink
dbr:GRASP_(object-oriented_design)
Subject Item
dbr:List_of_software_development_philosophies
dbo:wikiPageWikiLink
dbr:GRASP_(object-oriented_design)
Subject Item
dbr:SOLID
dbo:wikiPageWikiLink
dbr:GRASP_(object-oriented_design)
Subject Item
dbr:GRASP_(Object_Oriented_Design)
dbo:wikiPageWikiLink
dbr:GRASP_(object-oriented_design)
dbo:wikiPageRedirects
dbr:GRASP_(object-oriented_design)
Subject Item
dbr:Information_expert
dbo:wikiPageWikiLink
dbr:GRASP_(object-oriented_design)
dbo:wikiPageRedirects
dbr:GRASP_(object-oriented_design)
Subject Item
wikipedia-en:GRASP_(object-oriented_design)
foaf:primaryTopic
dbr:GRASP_(object-oriented_design)