In
Product and System Design, a platform is a structuring principle or foundation on
top of which a set of independent elements and interfaces can be arranged,
rearranged, and innovated upon (see [1] and
[2]). Shared key components and
assets define the core of the platform and “diversification can be achieved by
building upon and extending capabilities to build new, but related foundations“
[3]. Baldwin et. al. [4] point out that most platform
definitions identify the reuse or sharing of common elements as core
characteristics, and that all platforms are “modularizations of complex systems
in which certain components (the platform itself) remain stable, while others
(the complements) are encouraged to vary in cross-section or over time“ [4]. Well-structured platforms
allow numerous advantages, such as cost saving, increased production
efficiency, ability to evolve and produce variety in large scale (see [5]).
In Computer Science, this term was initially used to define
the computing hardware and later on the operating system (OS) upon which
application programs would run.
Earlier computers had to be designed and built from the
ground up always when new releases were planned. Not infrequently, because of
incompatibility with newer systems, there was a costly process involved in
moving data to different formats. In the early 1960s, IBM created the first
modular computer, the System/360. This model was a landmark in the computer
industry, because it “offered the possibility for other firms to enter and
compete in the computer marketplace, on the basis of providing modules that
would ‘slot in’ or ‘plug in’ IBM System/360 architecture.” [5]
As computer hardware was becoming modular and increasing its
complexity, systems without OSs presented enormous challenges for programmers.
Earlier computers required the full hardware specification to be attached to
the application every time it was executed. Therefore, a program not only would
be suitable for one machine, but also every time someone needed to run the
program, it was necessary the whole process of loading commands specific for
that computer was be necessary. As a way to optimize computer systems, the
industry realized that some fundamental set of instructions that concerned
hardware management could be loaded into the memory and managed separately. The
distinction between applications and OS was then created.
The reuse of code and the modularization of computer systems
brought many advantages to the field especially regarding cost, manageability,
and evolution of complex systems. According to Baldwin et. al., “by promoting
the reuse of core components, such partitioning can reduce the cost of variety
and innovation at the system level. The whole system does not have to be
invented or rebuilt from scratch to generate a new product, accommodate
heterogeneous tastes, or respond to change in the external environment. In this
fashion, the platform system as a whole becomes evolvable: it can adapt at low
cost without losing its identity or continuity design.“ [4].
Developers were freed of rewriting Kernel instructions for
every single application, and could use the OS as a platform upon which several
programs that shared the same specifications could run. Not only that, the same
OS, as was the case of e.g. MS-DOS, could be used across a large variety of
hardware systems from different vendors, provided that those were “IBM
compatible”. As Gawer [5] points out, “in the process
of modularizing the system architecture, the modules are defined and the rules
of interaction between modules are clarified. The interface specifications
formalize, codify, and therefore reveal the rules of interaction between
modules. Once this information is revealed and codified, it becomes easy to
transfer, -- but also becomes hard to protect.” [5] It certainly was hard for IBM
to protect its platform, especially because of the highly innovative ecosystem
it had promoted.
The modularity of computer systems became even more robust
with the advent of Object-Oriented Programming (OOP) and its concepts such as
encapsulation, polymorphism, inheritance, and so on. OOP took the reusability
of software components to a next level. Powerful software development platforms
or frameworks reduced enormously the
complexity and cost of writing code. According to Pree [6], frameworks “mean a real
breakthrough in software reusability: not only single building blocks but whole
software (sub-)systems including their design can be reused.”[6]
The inexpensive and powerful strategies allowed by
frameworks create a rich ecosystem for application development that lead to an
enormous variety and innovation, especially when it is popular and open to a
great number of developers. Rich ecosystems can be observed especially in mobile
platforms such as iOS, Android, Windows Phone, and so on. Both the Apple’s App
Store and the Android Marketplace count already with more than 1 million different
apps[1]
[2].
These considerable numbers of mobile apps were only reached when the leading
companies in the smartphone field decided to partially open their systems to
outside developers who had “skills, capabilities, or an understanding of user
needs that those inside of the firm do not“ [4]. By allowing new
constructions and manipulations of building blocks inside the mobile platforms,
not only the degree of innovation, scalability, and evolvability increased but
also new device releases raised by a factor of five (see [4]).
[1] D., Phillips, Nelson, Sewell, Graham,
Woodward, Joan Griffiths, Technology and organization: essays in honour of
Joan Woodward. Bingley [u.a.: Emerald, 2010.
[2] O. L.
de Weck, E. S. Suh, and D. Chang, “Product family strategy and platform design
optimization,” MIT Working Paper, 2004.
[3] M. H.
Meyer and J. M. Utterback, “The product family and the dynamics of core
capability,” 1992.
[4] C. Y.
Baldwin and C. J. Woodard, “The architecture of platforms: A unified view,” Platf.
Mark. Innov., pp. 19–44, 2009.
[5] A.
Gawer, “Towards a General Theory of Technological Platforms,” in Druid
Summer Conference, 2010.
[6] W.
Pree, “Meta Patterns - A Mean For Capturing the Essentials of Reusable
Object-Oriented Design.”
