Reduce transparency

From Green software

(Difference between revisions)
Jump to: navigation, search

Green (Talk | contribs)
(New page: An abstraction layer is a way of hiding the implementation details of a particular set of functionality. Abstraction layers make the life of software engineers usually much easier, because...)
Next diff →

Revision as of 21:51, 8 September 2010

An abstraction layer is a way of hiding the implementation details of a particular set of functionality. Abstraction layers make the life of software engineers usually much easier, because they no longer have to bother with details of the underlying system; they are presented with an easier interface. Abstraction layers allow for a system to become transparent. Abstraction layers can be added to comply with non-functional requirements like security, portability, maintainability or interoperability.

Some layers of abstraction keep a system from working efficiently, and make it impossible to introduce efficiency because no details from the underlying system are exposed. As an example of this inefficiency one can think of a neatly organized file system, where in fact all files are scattered all over the physical disk, introducing long seek times and high energy consumption. Removing this layer of abstraction, and instead implementing a monolithic system that works efficiently with both the physical disk and lets a user view the data as files and folders could prove to be much more energy efficient.



Transparent computer systems hide all implementation details through an external interface.

The term is especially popular in the field of distributed systems, where often the distributed nature of a system is hidden from whatever actor is using the interface.

There are many types of transparency:

  • Access transparency - Regardless of how resource access and representation has to be performed on each individual computing entity, the users of a distributed system should always access resources in a single, uniform way.
  • Location transparency - Users of a distributed system should not have to be aware of where a resource is physically located.
  • Migration transparency - Users should not be aware of whether a resource or computing entity possesses the ability to move to a different physical or logical location.
  • Relocation transparency - Should a resource move while in use, this should not be noticeable to the end user.
  • Replication transparency - If a resource is replicated among several locations, it should appear to the user as a single resource.
  • Concurrent transparency - While multiple users may compete for and share a single resource, this should not be apparent to any of them.
  • Failure transparency - Always try to hide any failure and recovery of computing entities and resources.
  • Persistence transparency - Whether a resource lies in volatile or permanent memory should make no difference to the user.
  • Security transparency - Negotiation of cryptographically secure access of resources must require a minimum of user intervention, or users will circumvent the security in preference of productivity.

A commonly known layer of abstraction is found in file systems; thanks to the user-interface, which here servers as the abstraction layer, a user can think of folders and files, where the actual underlying systems is unaware of this hierarchical structure and works in sectors and blocks.

Optimizing for underlying layers

Even with abstraction layers in place, it can sometimes still be possible to influence the underlying layers' efficiency. This can however mostly only be done by accompanying for the underlying layers. Examples of this are flexible timers or batched IO, but even specific code-level improvements to reduce the amounts of jump instructions that have to be executed.


Because of the major positive impact abstraction layers have on non-functional requirements, it is unlikely that they will ever disappear. However to allow for energy efficiency, some additional communication between two layers could be introduced, as this is currently often not possible. Making two layers that are connected through an abstraction layer, work in a more energy efficient way will most likely introduce a significant amount of work for software developers.


As an example of how to improve energy efficiency, removing location transparency can help. Location transparency stops a system from actively choosing a copy of a file that is located geographically close by, that might be fetched at a lower energy cost than a version further away.


See Also


Personal tools