Pattern based software patent

International Journal of Computer Engineering (IJCET), ISSN 0976 – 6367(Print),
International Journal of Computer Engineering and Technology
ISSN 0976 – 6375(Online) Volume 1, Number 1, May - June (2010), © IAEME
and Technology (IJCET), ISSN 0976 – 6367(Print)
ISSN 0976 – 6375(Online) Volume 1
IJCET
Number 1, May - June (2010), pp. 08-17 ©IAEME
© IAEME, http://www.iaeme.com/ijcet.html

PATTERN BASED SOFTWARE PATENT
Sankar Narayanan. S
System Analyst
Anna University of Technology
Coimbatore

ABSTRACT
In the paper proposed that, pattern based software patenting. Open Source
Software development has been constantly growing in importance and expanding in
many Software architectures all over the world. This impressive growth has been
supported by the numerous successes, the high-quality reputation of Open Source
Software -based systems are expectation of cost savings. Today lot of patent is available
embedding are some coding, cryptography, function etc, I proposed the pattern based
software patent., Lot of software are develop include in particular pattern. In the nature of
mind thing of logical function are implement in the particular software development. In
this innovation are frame in particular pattern are adopted then it can be easily drafted
that patent; already or previously lot of patent are particular pattern claim can be used.
These exting pattern claims are applicable or add one of the claims of your innovation.
Pattern based software patent are easily or flexible drafting claim compare than
electronic/mechanical/chemical etc... In this process of patent are every where read and
also anticipate growth of new idea better gateway.
SOFTWARE PATENT
Software patents have raised numerous issues over the nature of patentable
inventions (and the differentiation from unpatentable ideas), since software is closer to a
pure “idea” than any other kind of invention – it is helpful to consider the historic basis of
the patent system as the justification for allowing or disallowing software patents.

8

International Journal of Computer Engineering and Technology (IJCET), ISSN 0976 – 6367(Print),

HISTORY OF SOFTWARE
The claim that the new patent reform package has nothing to do with software
patents is similar to what the Commission said years ago about its "computer-
implemented inventions After a slow beginning in the late 1990s, Free and Open Source
Software (FOSS) has been constantly growing in importance and expanding in many
software architectures all over the world. This impressive growth has been supported by
the numerous successes, the high-quality reputation of FOSS-based systems and, of
course, by the expectation of cost savings. Open Source Software encompasses more than
just the access to source code; Free Software (FS) refers more to the concept of freedom
(liberty) than to the concept of no cost (gratis).
FREE DISTRIBUTION OF COMPONENTS OR AGGREGATE
PROGRAMS
• Source code must be included.
• Derived works must be possible and distributable at least as a patch files.
The strength of software development is the ability to recruit and motivate
communities of competent programmers to develop, debug, and optimize code on a
volunteer basis. Coordination is assumed by a delegate leader who is responsible for the
assessment of the various solutions offered by the programmers and for the integration of
the best code into the next software updates that are rapidly put on-line.
NEED FOR SOFTWARE PATENT
• Huge diversity of software
• High flexibility and scalability of software solutions through source code editing.
• High reliability and high security through source code review and validation
• One-order of magnitude faster release rate
• Rapid development of custom solutions to meet specific requirements through
code reuse and extension.
• Lifetime extension of FOSS-based systems through source code upgrades
• High degree of compliance with open standards leading to more interoperability
between Information systems.

9


FOUR FUNDAMENTAL FREEDOMS
• Freedom to run the program, for any purpose;
• Freedom to study how the program works, and adapt it to your needs;
• Freedom to redistribute copies so you can help others;
• Freedom to improve the program, and release your improvements to the public.
When software is created, it has a level of quality that depends directly on the
programmer’s competence, experience and professional methodology. To increase the
reliability and security of code, it is essential to use some complementary mechanisms
such as peer review, testing, quality audits, alpha and beta versioning etc. open source
software and proprietary software rely essentially on the same processes (probably at
similar levels) during the main development period. However, after the first public
release, open source software offers the very significant advantage of keeping access to
source code. This encourages more peer reviews, testing, and quality audits by a much
larger community of users/developers than what would be possible with proprietary code.
For closed source software, flaws and code defects are often discovered by some
subversive exploits which can lead to some destabilization in large corporations that rely
on patch and repair. On the contrary, confidence in open source software may be built
faster and, potentially, to a higher degree than with a proprietary equivalent . A myriad of
statistics on software vulnerabilities are available and they seem to confirm the general
perception that open source software is often superior to proprietary code. The final
decision was to make the cryptographic algorithms generally available so as to provide
for security assessment and validation by the widest scientific community possible.
Open source software implements open standards and specifications that are
shared among developers during the design, coding and testing processes. This is
generally recognized as a strategic advantage in enforcing interoperability policies
between independently developed systems
Adoption of open source software development methods can have fundamental
and far-reaching consequences on engineering practices, especially if the objective is to
contribute actively to an open source project. It is recommended that experience be
gained with FOSS as a passive user first, then to become progressively more involved by

10


reporting bugs, suggesting new features, and modifying existing code before engaging in
active development within a collaborative project. Figure 2 illustrates the evolution
schema of a FOSS user/developer.
SOFTWARE DEVELOPERS ON LEGAL ISSUES AND WRITING
PATENT APPLICATIONS
Software enables a computer to control information flow a program is both a
written set of instructions, and a series of events occurring in real time .Even the earliest
programmers foresaw the vast potential of software as automated language translators,
large databases of information, optical character recognition and text printing, and
transcription of spoken language; all of these tasks are routinely performed by computers
today; however, the early characterization of computing machinery as a “mechanical
brain” fueled the early view of software as a set of “mental steps,” which had been a basis
for rejecting patentability since the 1800’s of course, even today’s machines are still too
primitive to be compared with “brains,” thereby invalidating the “mental steps” argument
(but this argument is likely to arise again when machines are capable of performing an
equivalent of human thought).
SOFTWARE PATTERN
BUILDING SOFTWARE
SOFTWARE ENGINEERING:
The process of building software involves the same stepwise approach as for
building other kinds of complex structures.
SOFTWARE ENGINEERING MODELS:
Many models of software design exist; this is the basic model approach are
analysis implement in the different problem of solution.
SOFTWARE DESIGN PATTERNS
DESIGN PATTERNS:
As demonstrated by the growing size of Windows with each iteration, software
products are clearly increasing in complexity – to address such complexity, software
engineering borrows a concept from classical architecture: design patterns, the idea that a

11


particular kind of problem can arise in many contexts, and can be solved in the same
ways (though the details vary) – this gives rise to the concept of software reuse – recent
advances in software engineering have identified 50 common design patterns, falling
generally into three categories: creational patterns, structural patterns, and behavioral
patterns
CREATIONAL PATTERNS:
Object-oriented design involves packaging data and code as “objects” that
represent different components of a solution – the different creational patterns define
what kinds of objects are created, who creates them, and when and how they are created.
ABSTRACT FACTORY PATTERN:
The interface generally defines the broad features of a class, but allows each
platform to define the particulars (e.g., a generic “scrollbar” class, implemented
differently by each OS)
BUILDER PATTERN:
The constructor joins together many other objects that relate to each other in a
particular way (e.g., a human language phrase constructor: perhaps different human
languages have different parts of speech, but concepts must still be able to relate to each
other in a phrase)
FACTORY METHOD PATTERN:
The interface doesn’t define a constructor for an abstract class, but merely
contains a stub constructor that can be filled in later for a specific object
PROTOTYPE PATTERN:
A generic template object is developed as a prototype, which may later be cloned
and customized for any specific application – singleton pattern: exactly one instance of
the class must be created and must be globally available
STRUCTURAL PATTERNS:
These design patterns describe how classes might organize and manipulate their
member variables

12


ADAPTER PATTERN:
one object encapsulates another object and translates calls between an interface
and the encapsulated object
BRIDGE PATTERN:
This pattern intermediates between an object and its abstraction, allowing each to
vary independently
COMPOSITE PATTERN:
A collection object binds together one or several primitives, and can be nested
within another collection object in a hierarchical fashion
DECORATOR PATTERN:
A wrapper object that adds a feature to the encapsulated object (a way to add
features to the encapsulated class on an as-needed basis, without having to
modify/expand the class definition)
FAÇADE PATTERN:
A unified interface that can present a set of dissimilar objects in a similar manner
(e.g., the windowing interface for most GUIs presents all applications with a common set
of features, such as scrollbars
FLYWEIGHT PATTERN:
In a scenario where many objects will encapsulate one of a few kinds of objects as
a descriptor, this pattern involves hosting a complete set of these objects in a specific
location, and allowing all encapsulating objects to point to the most applicable one (rather
than multiply instantiating each one)
PROXY PATTERN:
One object stands in as a stub for a much more resource-intensive object until the
latter is needed
BEHAVIORAL PATTERNS:
These patterns describe how objects interact with each other
CHAIN OF RESPONSIBILITY PATTERN:
A data object is serially offered to a set of handler objects to see if any of them
want to process it

13


COMMAND PATTERN OR TRANSACTION PATTERN:
An object is responsible for performing some action, but the details of that action
won’t be known until later, when a set of preconditions.
COMPLETE INTERPRETER PATTERN:
Objects are defined and arranged as grammar rules for parsing a complex
language
ITERATOR PATTERN:
A class for traversing the elements of a specified collection type in a particular
manner, so that the collection class itself doesn’t need to offer a number of traversal
methods and keep track of an internal pointer
MEDIATOR PATTERN:
One object serves as the interface between two other objects
MEMENTO PATTERN:
One object represents the internal state of another object at a specific point in
time; useful for storing an object state in case a backup is needed
OBSERVER PATTERN:
One object creates a representation of another object, and changes the
presentation as the state of the observed object is updated
STATE PATTERN:
An object alters its behavior as its internal state changes (e..g, the functionality of
a computer might change depending on its power source and power management
settings)
STRATEGY PATTERN:
A group of objects that each represent a different way to solve a problem (e.g., an
assortment of objects that each encapsulate a different sorting algorithms); clients may
choose whichever solution strategy they wish
TEMPLATE METHOD PATTERN:
A higher level of abstraction of the strategy pattern, where the solutions define the
rough characteristics of a solution method, and allow the client to specify further details
later

14


VISITOR PATTERN:
The opposite of encapsulation, this pattern involves storing a set of objects apart
from other objects that operate on and maintain them; this requires exposing the internal
state of each object set to the visitor objects
CLASSIFICATION OF SOFTWARE PATENTS
SOFTWARE PATENT CLASSIFICATION:
Initially, all software patents were relegated to class 364 subclasses 100 and 400-
800 were heavily subdivided, so most software patents were placed in subclasses 200,
300, and 900, which grew unchecked – instead of further subdividing these classes, the
patent office assigned keywords to certain subclasses but were merely tagged into
“pseudo subclasses” – also, the USPTO published “digests” or “art collections” listing all
of the patents in a particular field – in November 1991, the magnitude of the problem
compelled the USPTO to transfer all patents from 200, 300, and 900 into subclasses of
new class 395 (“Information Processing System Organization”), with major groups of
subclasses dedicated to display processing and artificial intelligence – the process of
further subdividing class 395 has been incessant, and will probably remain continuous in
order to keep up with the rate of issuing software patents
MECHANICS OF DRAFTING THE SPECIFICATION
Title of invention
Brief summary of the invention
Brief description of the drawings
Detailed description
Claims
Abstract of the disclosure
Drawings
CLAIM-DRAFTING PROCESS
CLAIM DRAFTING:
Most patent attorneys begin the patent drafting process with the claims, which
will define the boundary line and bounds of the invention, and hence its scope and
position within the context of the prior art – some suggest that drafting the description

15


helps prepare the context for the claims, but this also raises the potential need to revise
the description if the claims are not drafted as expected – it may be helpful to sketch out
the claims first, perhaps even as a series of drawings of the components, in order to
isolate the invention as a minimal set of components
FINDING THE INVENTION:
Of course, drafting a patent application requires the applicant to describe the
boundary line and bounds of the invention – different business models will be more or
less facilitated by protecting different aspects of the same invention, so first strive to
understand the invention in its preferred embodiment next, identify claim elements
essential to the invention next, draft claim language for each element finally, add
connective language to join the elements into a claimed invention
AIDES TO PATENT CLAIM DRAFTING:
Drawing diagrams may help put the invention in context – the inventor’s
drawings may be particularly useful, and for software patents, the source code may
suggest an approach for identifying the elements and organizing them into components –
the set of claims should include broad, intermediate, and narrow claims, which broadens
the arsenal of weapons that can be used to ensnare an infringer (the most useful claim is
the one that claims the invention just broadly enough to ensnare a competitor, but not any
more broadly, as this might invite an invalidity attack) – when the claims are fully
drafted, it is important to test them by applying them to the claimed invention, by trying
to design around them with various modifications, and by applying them to the prior art
to ensure that they recite novel and non-obvious subject matter – problems discovered
through claim testing are helpful for refining the claims into a more easily prosecuted and
allowable set.
CLAIM DRAFTING FOR ITERATIVE PROCESSES: This claim style can
closely follow the source code style: “A method comprising: … while x, iteratively
performing.

16


CLAIM DRAFTING FOR LOGICAL CONTROL PROCESSES: This
claim style also closely follows the source code: “A method comprising: … if X is less
than Y, then performing.
CONCLUSION
Open source software refers to computer software that users are free to run, copy,
distribute, study, change and improve on. Anyone can take the programs, understand how
they work, use them and redistribute copies without asking for permission. The “open”
concept allows further customization of the software to users needs. The well-known
Linux operating system is an example of FOSS software. Software patents inhibit the
development and use of open source software. The nature of open source software is that
many different bodies, agencies and companies help out for the development of software
that would meet their respective needs. Nobody will be willing to pay licensing fees as
required by patents and this will inhibit the development of open source software.
Many software industries are encouraging its developers to branch out globally
both in software products and services; we need to ensure that sufficient protection is
available for commercialization of software.
REFERENCES
• Gregory A. Stobbs, Second Edition Software Patents
• THE DISPUTED QUALITY OF SOFTWARE PATENTS- JOHN R. ALLISON

RONALD J. MANN∗

• International open source network -P E T E R J. Q U I N N; Nah Soo Hoe
• Stallman, Richard (2003). Basic Idea Behind Open Source. Paper. Open Source
Organization
• Evans, David S. and Reddy, Bernard (2003). Government Preferences for
Promoting Open-Sources Software: A Solution in search for a problem.
(Technical Report 9 Mich. Telecomm. Tech. L. Rev. 313 (2003)). National
Economics Research Associates.
• Driver, M. (2001). The Future of Open-Source Software. (Technical Report SPA-
13-7536). Gartner.

17

Pattern based software patent

More Related Content

What's hot

Similar to Pattern based software patent

More from IAEME Publication

Pattern based software patent