
	Where results make sense

Topic: Separation of concerns

Related Topics

Programming paradigm

Subroutine

AspectJ

Gregor Kiczales

Business logic

Xerox PARC

Business intelligence

	Multi-Dimensional Separation of Concerns
		Separation of concerns is at the core of software engineering in general, and of object-oriented software development in particular.
		To benefit fully from separation of concerns, one must have the right modularization at the right time: the concerns that are separated must match the concerns one needs to deal with.
		Separation according to these concerns simultaneously; i.e., a developer is not forced to choose a small number (usually one) of "dominant" dimensions of concern according to which to decompose a system at the expense of others.
	www.research.ibm.com /hyperspace/MDSOC.htm (444 words)

	DivorceNet - New Jersey Separation Agreements (Site not responding. Last check: 2007-10-13)
		To address these concerns the courts developed a legal proceeding called a “divorce from bed and board.” In this type of proceeding, the parties are economically divorced but are still legally married.
		It is a contract that outlines the terms of the couple’s separation, and it generally resolves all issues relating to child custody, child support, alimony, division of property, and apportionment of debt.
		An unconscionable separation agreement is one that no man or woman in his or her right senses would make, and which no fair or honest person would accept.
	www.divorcenet.com /states/new_jersey/new_jersey_separation_agreements (2184 words)

	Multi-Dimensional Separation of Concerns: Software Engineering using Hyperspaces
		Separation of concerns is a concept that is at the core of software engineering.
		Concerns are the primary motivation for organizing and decomposing software into manageable and comprehensible parts.
		The First Workshop on Multi-dimensional Separation of Concerns in Object-Oriented Systems was held at OOPSLA'99 in November, 1999.
	www.research.ibm.com /hyperspace (655 words)

	Separation of concerns - Wikipedia, the free encyclopedia
		SoC is a long standing idea that simply means a large problem is easier to manage if it can be broken down into pieces; particularly so if the solutions to the sub-problems can be combined to form a solution to the large problem.
		Separation of concerns is an important design principle in many other areas as well, such as urban planning, architecture and information design.
		The term separation of concerns was probably coined by Edsger W. Dijkstra in his paper On the role of scientific thought.
	en.wikipedia.org /wiki/Separation_of_concerns (660 words)

	Separation of Concerns
		Separation of concerns is a basic engineering principle that is also at the core of object-oriented analysis and design methods in the context of the Unified Modeling Language (UML).
		Separation of concerns is at the core of software engineering, and has been for decades.
		Despite the well-known benefits of separation of concerns, and despite the presence of mechanisms to achieve separation of concerns in all modern software formalisms, software artifacts continue to exhibit properties associated with poor separation of concerns.
	www2.umassd.edu /SWSoC/papers.html (8431 words)

	Separation of Concerns
		This principle states that a given problem involves different kinds of concerns, which should be identified and separated to cope with complexity, and to achieve the required engineering quality factors such as robustness, adaptability, maintainability, and reusability.
		Despite a common agreement on the necessity of the application of the separation of concerns principle, there is not a well-established understanding of the notion of concern.
		For example, in object-oriented methods the separated concerns are modeled as objects and classes, which are generally derived from the entities in the requirement specification and use cases.
	trese.cs.utwente.nl /taosad/separation_of_concerns.htm (785 words)

	Separation of Concerns
		Separation of concerns is the ability to identify, encapsulate, and manipulate those parts of software that are relevant to a particular concept, goal, purpose, or issue.
		Separation of concerns asks us to state explicitly what concerns exist for a particular application.
		This may be due to concerns varying over time and being context-sensitive--different development activities, stages of the software lifecycle, developers, and roles often involve concerns of dramatically different kinds.
	www2.umassd.edu /swsoc/soc.html (576 words)

	Alexandr Savinov's Concept-Oriented Blog (Site not responding. Last check: 2007-10-13)
		Separation of Concerns When people are writing on next generation programming paradigms they usually use the two words separation of concerns as the main criterion of correctness.
		In other words, if I declare that my approach allows for efficient separation of concerns then there is much higher probability to be accepted.
		In this situation the term separation of concerns is used mostly for advertizing (just like the term democracy or fight with terrorism in politics).
	jroller.com /page/savinov?entry=separation_of_concerns (241 words)

	Separation of concerns
		Separating them out allows parallel development with reduced buffering and shorter schedules.
		Rules represent business policies such as "You must be 18 years of age to contract for a service plan" and "New service plans include a 2 year commitment with penalties for early cancellation".
		Keeping them separate from the rest of a system is more effective.
	www.agilemanagement.net /Articles/Weblog/Separationofconcerns.html (359 words)

	E.W. Dijkstra Archive: On the role of scientific thought (EWD447)
		Another separation of concerns that is very commonly neglected is the one between correctness and desirability of a software system.
		Business data processing systems are sufficiently complicated to require such a separation of concerns and the suggestion that in that part of the computing world "scientific thought is a non-applicable luxury" puts the cart before the horse: the mess they are in has been caused by too much unscientific thought.
		It also separates a fraction of the human abilities from the rest; again, we have to do so, because the maintenance of our non-trivial abilities requires that they are exercised daily and a day --regretfully enough-- has only 24 hours.
	www.cs.utexas.edu /users/EWD/transcriptions/EWD04xx/EWD447.html (2999 words)

	ASeC worksop (Site not responding. Last check: 2007-10-13)
		This is an exciting and active research area, with the potential to deliver far more flexible and effective separation of concerns.
		Separation of concerns is at the core of software development.
		Separation of concerns depends on having the right modularization at the right time: the concerns that are separated must match the concerns one needs to deal with.
	ecoop2001.inf.elte.hu /workshop/ASeC-ws.html (883 words)

	Separation of concerns (Site not responding. Last check: 2007-10-13)
		It is valuable to separate the domains of concern for a large-scale system via well-positioned, clean, interfaces.
		Separating style from content is like the training wedge in skiing, practiced in the first lessons, abandoned with a little skill.
		We do not have a page-layout language that is separate from mark-up, and separate from the sequencing and nesting of the elements of the document.
	www.barry.pearson.name /articles/content_presentation (1463 words)

	Demonstrations, D3 (Site not responding. Last check: 2007-10-13)
		To benefit from separation of concerns, one must have the right software modularization at the right time: the concerns that are separated must match the concerns one needs to deal with.
		Multi-dimensional separation of concerns is a new approach that supports clean separation of multiple, potentially overlapping concerns simultaneously, with on-demand remodularization.
		Hyper/J is a compositor tool, which provides the ability to identify concerns in existing or new Java code, to specify modules in terms of those concerns, and to synthesize systems and components by integrating those modules.
	ecoop2001.inf.elte.hu /demo/D3.html (539 words)

	ECOOP 2001 - Advanced Separation of Concerns
		Last year's ECOOP workshop titled "Aspects and Dimensions of Concerns" was considered very succesful by many people, not only because of the interest in the topic, but also since it managed to create a setting where people could really work together on example problems and requirements for this field.
		Separation of concerns can provide many well-known and crucial benefits, but only if the concerns that are separated and modularized match those one needs to deal with, which can be of dramatically different kinds in different development contexts, and which evolve over time.
		The exact focus is yet to be determined, but we envision a followup on last years workshop results, such as the identification of the requirements and design space of solution approaches.
	trese.cs.utwente.nl /oldhtml/Workshops/ecoop01asoc (410 words)

	Separation of Concerns and Genericity (Site not responding. Last check: 2007-10-13)
		The approach we use to design a generic architecture is based on the separation of concerns principle [Hest 81].
		Of course, this goal is tempered somewhat by both the difficulty in achieving such minimality, and by the inefficiencies sometimes caused by this separation.
		For example, the concerns of syntax and semantic analysis in a compiler can be combined for efficiency, but this optimization is difficult to do by the compiler once these concerns have been separated.
	www.umcs.maine.edu /~larry/latour/GEN/geneng-b/node5.html (229 words)

	Introducing Apache Cocoon
		SoC is something that you've always been aware of: not everybody performs the same job with the same ability.
		It can be observed that separating people with common skills in different working groups increases productivity and reduces management costs, but only if the groups do not overlap and have clear "contracts" that define their operability and their concerns.
		Cocoon is engineered to provide you a way to isolate these four concern areas using just those 5 contracts, removing the contract between style and logic that has been bugging web site development since the beginning of the Web.
	cocoon.apache.org /2.1/introduction.html (1648 words)

	Java.net - the Source for Java(tm) Technology Collaboration
		An interesting separation of concerns is becoming possible by the use of BPEL.
		In effect, Figure 4 illustrates a means of separating the dual concerns of expressing business logic and the associated software-based services.
		The notion of separating business logic from presentation logic is well established in technologies such as J2EE.
	today.java.net /lpt/a/265 (2160 words)

	Style sheet (web development) - Wikipedia, the free encyclopedia
		This design approach is identified as a "separation" because it largely supersedes the antecedent methodology in which a page's markup defined both style and structure.
		The philosophy underlying this methodology is a specific case of separation of concerns.
		Separation of style and content has many benefits, but has only become practical in recent years due to improvements in popular web browsers' CSS implementations.
	en.wikipedia.org /wiki/Separation_of_style_and_content (1147 words)

	Aspect-Oriented Programming and Adaptive Programming
		So, clean separation of concerns was the interest of my research group, even before AOP existed as such.
		This report identified the general theme of concerns that had scattered and tangled implementations and proposed this as an important problem in software design/implementation.
		Separation of structure and behavior was introduced in an OOPSLA '91 tutorial and in a IFIP World Congress '92 paper.
	www.ccs.neu.edu /home/lieber/connection-to-aop.html (1145 words)

	N Degrees of Separation: Multi-Dimensional Separation of Concerns - Tarr, Ossher, Harrison (ResearchIndex)
		N Degrees of Separation: Multi-Dimensional Separation of Concerns - Tarr, Ossher, Harrison (ResearchIndex)
		N Degrees of Separation: Multi-Dimensional Separation of Concerns (1999)
		P Tarr, H Ossher, W Harrison and SM Sutton, Jr., "N degrees of Separation: Multidimensional separation of concerns," Proc.
	citeseer.ist.psu.edu /tarr99degrees.html (555 words)

	SAC 2006 Track on Programming for Separation of Concerns
		Once the development phase is over, these systems are often hard to reuse and evolve because their concerns are intertwined and making apparently small changes force programmers to modify many parts.
		Separation of concerns (SoC) techniques such as computational reflection, aspect-oriented programming and subject-oriented programming have been successfully employed to produce systems whose concerns are well separated, thereby facilitating reuse and evolution of system components or systems as a whole.
		The Programming for Separation of Concerns (PSC) track at the 2006 Symposium on Applied Computing aims to bring together researchers to share experiences in using SoC techniques, and explore the practical problems of existing tools, environments, etc. The track will address questions like: Can performance degradation be limited?
	www.dmi.unict.it /~tramonta/PSC06 (457 words)

	Web Content Management Benefits - Separation of Concerns \| liveSTORYBOARD CMS
		Separation of Concerns plays an important role in Web Content Management.
		The "Separation of Concerns" concept originates from the world of Software Engineering, it's a good metaphor and highly applicable to web development and Content Management.
		In Software Engineering, "Separation of Concerns" is the process of breaking down a program into distinct components that perform distinct tasks.
	www.livestoryboard.com /Benefits/CMS-separation-of-concerns.html (472 words)

	InfoQ: The Lost Art of Separating Concerns
		The practice of "separating concerns" is a critically important tool for software architects, as it helps us introduce loose coupling where we need it in the systems we design.
		If we are attempting to separate concern A from concern B, then we are seeking a design that provides that variations in A do not induce or require a corresponding change in B (and usually, the converse).
		The litmus test for whether concerns were separated, was whether one could be varied without affecting the other.
	www.infoq.com /articles/separation-of-concerns (6625 words)

	I want my AOP!, Part 1 - Java World
		A concern is a particular goal, concept, or area of interest.
		Using current programming methodologies, crosscutting concerns span over multiple modules, resulting in systems that are harder to design, understand, implement, and evolve.
		The converse of this fact may be equally true: we allowed the existence of ever more complex systems because these techniques permitted us to deal with that complexity.
	www.javaworld.com /javaworld/jw-01-2002/jw-0118-aspect.html (672 words)

	java.net: Separation of Concerns and BPEL
		SOC can be addressed by tools if appropriate care is taken to separate the model according to business structure and ownership.
		Publishing frameworks (e..g Cocoon) are able to access XML, RDB and OO components, and provide consistent SOC, view and security at the presentation layer.
		My concern with BPEL is that users able to affect change will lead to an unexeptable level of exception handling, and down right error.
	today.java.net /pub/a/today/2006/02/14/separation-of-concerns-and-bpel.html (3658 words)

	Separation Of Concerns
		One should ask - is this something I should be concerned about, and can I do anything to deal with the concern.
		One in action dealing with a concern is doing something to reduce the number of concerns involved in a local situation or scene.
		There is rarely perfect grouping and perfect separation.
	c2.com /cgi/wiki?SeparationOfConcerns (812 words)

	Andy Wardley: A Clear Separation of Concerns
		These chunks of markup can be separated into reusable components that allow you to build your web site up rather like a jigsaw puzzle.
		Once again, a clear separation of concerns is important.
		I hope this article has given you some insight into why achieving a clear separation of concerns is about much more than keeping up with the latest fad.
	wardley.org /computers/web/separation.html (2143 words)

	Separation of Concerns - Lopes, Hursch (ResearchIndex)
		Abstract: This paper identifies and analyzes the emergence of a new paradigm in software engineering, called separation of concerns, which tries to formally separate the basic algorithm from special purpose concerns such as synchronization, real-time constraints, and location control.
		This separation allows for the locality of different kinds of information in the programs, making them easier to write, understand, reuse, and modify.
		...interwining of different concerns: the execution of an object s method is suspended to verify constraints, to achieve synchronization, etc.
	citeseer.ist.psu.edu /lopes95separation.html (706 words)

	ONJava.com -- Separation of Concerns in Web Service Implementations
		Separation of concerns is a core principle of Service-Oriented Architectures.
		Using the Spring Framework and principles of Aspect Oriented Programming (AOP), we can drive the separation of concerns down into the implementation of services.
		In the spirit of separation of concerns, we've come up with a design that allows us to split this up.
	www.onjava.com /pub/a/onjava/2006/09/06/separation-of-concerns-in-web-services.html (1184 words)

Try your search on: Qwika (all wikis)