- Existing Problems in the Market
- Current Technological Challenges
- Harris Kern's Enterprise Computing Institute
Like this article? We recommend
Like this article? We recommend
Like this article? We recommend
Current Technological Challenges
Having outlined some of the business issues, let's look at some of the existing technical challenges in enterprise software development.
One of the challenges that has existed in software development since its inception is how to achieve reuse—using existing deliverables, which can consist of programs, subroutines, requirements, processes, and so on. Achieving reuse would provide many benefits: lower development costs, reduced defects, and shorter time to market. These benefits have been realized by the hardware industry for years, but so far have not been achievable on a large scale in the software industry.
Another ongoing challenge is interoperability; in other words, making two otherwise incompatible systems—due to differences in operating systems, programming languages, database systems, etc.—work together. The majority of enterprise software development is focused on integrating two or more systems to make them interoperate.
Along the way, we'll see how some of these fundamental problems are addressed by the following existing technologies:
Object-oriented technology
Distributed computing
Component-based development
HTML
XML
All of these topics eventually lead up to our primary topic, web services.
NOTE
Another challenge is how to make information accessible to the user via multiple means, such as by wireless access. This topic, called pervasive computing, is beyond the scope of this series.
Object-Oriented Technology (OOT)
In the early days of personal computing (mid-1970s to mid-1980s) and client/server development, object-oriented technology (OOT) was invented to address some of the aforementioned problems.
NOTE
Technically speaking, OOT was invented in the late 1960s with the invention of Simula, but Smalltalk, invented in the mid-1970s, refined many of the ideas of Simula.
Providing a metaphor for creating a mental model of software as discrete objects, OOT advocated creating large (often complex) hierarchies of classes (from which objects are instantiated) and these classes often inherit common functionality and attributes from their parents (known as superclasses). OOT is a set of techniques for performing object-oriented analysis (OOA), object-oriented design (OOD) and object-oriented programming (OOP). Many of the popular languages still in use today are object-oriented languages; examples include Java, C++, and C#.
NOTE
HTML is definitely not object-oriented. Perl may be, depending on how passionate is the person you're talking to.
OOT delivered on the promise of reuse, but primarily at the coding level (OOT purists argue that performing object-oriented analysis correctly also results in business process reuse, but that's largely debatable). However, as it turns out, the code reuse requires a substantial amount of initial investment in initial development (building class libraries, repositories, and so on) and mastery of low-level details. For example, one class can only inherit (reuse the existing functionality) from another class as long as they're both written in the same language—and, in many cases, the same release of the same language! Consequently, reuse in OOT is possible; at most, however, it's limited to a departmental level or divisional level and requires a fairly well-trained IT staff.
NOTE
Few companies have achieved reuse at an enterprise level with OOT.
As we'll see in later articles, web services surpass the primary goal of OOT (large-scale reuse between enterprises), but without the steep learning curve and costly infrastructure.
In the next article, we'll move the discussion to distributed computing, component-based development (CBD), HTML, and XML.