Skip to main content Accessibility help
×
  1. Home
  2. Browse subjects
  3. Computer Science
  4. Programming Languages and Applied Logic
  5. Content listing

Refine search

Refine search

Access:
Content type:
Publication date:
Apply   From and To filters
Subject: Show more
Journals Show more
Publishers: Show more
Societies Show more
Series: Show more
Collections: Show more

Actions for selected content:

Select all | Deselect all
  • View selected items
  • Export citations
  • Download PDF (zip)
  • Save to Kindle
  • Save to Dropbox
  • Save to Google Drive

Save Search

You can save your searches here and later view and run them again in "My saved searches".

Please provide a title, maximum of 40 characters.
Cancel
×

5913 results in Programming Languages and Applied Logic

Page 222 of 296

  • Preface

  • Paul Hudak, Yale University, Connecticut
  • Book:
    The Haskell School of Expression
    Published online:
    28 May 2018
    Print publication:
    28 February 2000, pp xiii-xviii

  • Summary

    The first high-level languages developed for general purpose programming were Fortran (Backus, 1978) and Lisp (McCarthy, 1978), developed in the late 1950s by John Backus and John McCarthy, respectively. From Fortran grew many of today's modern imperative languages, most of which did not improve significantly on the fundamental ideas found in the language Algol (de Morgan, Hill and Wichmann, 1976), which shortly followed Fortran. The Lisp family was less fecund, perhaps because it was so far ahead of its time, but was the seed for the family of functional languages about which this textbook was written. The most radical in this class of languages is probably Haskell, originally designed in the late 1980s (Hudak, Wadler, 1988) based on, at that point, a good ten years of experience designing and implementing similar languages, most notably a series of languages developed by David Turner in the late 1970s and early 1980s (Turner, 1976; 1985). Although research continues on the design of Haskell, the version used in this textbook, Haskell 98 (Augustsson, et al., 1999), is the latest and most stable version of the language and its libraries.

    Haskell was named after the logician Haskell B. Curry who, along with Alonzo Church, established the theoretical foundations of functional programming back when computers themselves were only a gleam in researchers' eyes. A curious historical fact is that Haskell Curry's father, Samuel Silas Curry, helped to found and direct a school in Boston called the School of Expression. Because pure functional programming centers around the notion of an expression, I thought that The Haskell School of Expression would be a good title for this book.

    A Brief Account of Language Success Stories

    It's hard to predict just how it is that a language becomes popular. Fortran became popular because it was the first high-level language and a welcome alternative to assembly language, and ultimately because it was a good vehicle for coding numerical algorithms in the domain of scientific computing.

  • 20 - Functional Music Composition

  • Paul Hudak, Yale University, Connecticut
  • Book:
    The Haskell School of Expression
    Published online:
    28 May 2018
    Print publication:
    28 February 2000, pp 287-303

  • Summary

    In this chapter I will describe a module for expressing musical structures in the same high-level, declarative style of functional programming that we have been using for graphics, animation, and other applications. These musical structures consist of primitive entities (such as notes and rests), operations to transform musical structures (such as transpose and tempo-scaling), and operations to combine musical structures to form more complex ones (such as concurrent and sequential composition). From these simple roots, much richer musical ideas can be easily developed.

    For convenience, and in the style of Chapters 15 and 19 (where I defined the languages FAL and IRL, respectively), I will refer to the ideas described in this chapter as MDL, for music description language. MDL is a simplified version of a more complete computer music library called Haskore. In Chapter 21a module will be developed for interpreting an MDL program as an abstract performance, and in Chapter 22 these performances will be converted into MIDI files, which are a standard way of interchanging electronic music and can be played on any PC with a standard sound card.

    DETAILS

    If you load the Haskell code for Chapter 22 into Hugs you will be able to play any of the examples presented in this chapter by typing either:

    testWin95 m

    testNT m

    testLinux m

    depending on what kind of computer you are using. This command will convert m (of type Music to be defined shortly) into a MIDI file, and then automatically invoke the default MIDI file player on your PC so that you can hear the result.

    module Music where

    The Musk Data Type

    I will assume that you are familiar with very basic musical concepts such as notes, rests, scales, and chords. Nothing more will be needed to understand what is going on, but of course the richer your musical background, the more applications of the ideas will be apparent to you.

  • Chapter 4 - B-to-B e-Application Models

  • Faisal Hoque
  • Book:
    e-Enterprise
    Published online:
    20 May 2010
    Print publication:
    28 February 2000, pp 89-136

  • Summary

    No man is an Island, entire of itself; every man is a piece of the Continent, a part of the main.

    —John Donne, Devotions

    Today, B-to-C business models seem to command more attention and generate more interest than do B-to-B business models. This is because relationships between consumers and e-Tailers are by nature less involved and customized than those between enterprises in B-to-B relationships. B-to-B commerce is dominated by long-term, symbiotic buyer-supplier-business partner relationships where stakeholders collectively work for common interests such as lower costs and improved product and service offerings.

    The astounding success on Wall Street of Amazon.com, eBay, and Priceline.com provides strong evidence that B-to-C commerce has already arrived. We've just begun, however, to explore and exploit B-to-B business models. Due to the enormous volume of spending in the B-to-B sector (companies such as General Electric and General Motors each spend over a couple billion dollars per year), the next generation of.com success stories will be dominated by B-to-B product and service providers.

    Adam Brandenburger and Barry Nalebuff explore this symbiosis in their popular book Co-opetition. In the book, they introduce the concept of the “Value Net” in which customers and suppliers are both symmetrical, equal partners in creating value for the firm while competitors and “complementors” act as mirror images of one another. The Internet and its capacity for connecting organizations provides exciting new opportunities to explore and exploit the symmetries between customers and suppliers.

  • 13 - A Module of Simple Animations

  • Paul Hudak, Yale University, Connecticut
  • Book:
    The Haskell School of Expression
    Published online:
    28 May 2018
    Print publication:
    28 February 2000, pp 163-186

  • Summary

    In previous chapters you learned how to draw simple geometric shapes in a graphics window. Although you also learned how to manipulate these pictures somewhat using the mouse, they were otherwise static. In this chapter I will explain how to make these pictures dynamic; that is, how to program animations. In doing so you will learn several new ideas, such as how to use timers and how to use polymorphism and type classes in unique ways.

    module Animation where

    import Shape

    import Draw

    import Picture

    import SOEGraphics hiding (Region)

    import qualified SOEGraphics as G (Region)

    import Win32Misc (timeGetTime)

    import Word (word32ToInt)

    What is an Animation?

    An animation is a continuous, time-varying image. However, the animations that you see in the movies, on TV, or on your computer screen only seem to be moving continuously. In reality they are created by a sequence of static images - called frames that are displayed in such rapid succession that they appear to be continuous to the human eye. The rate at which this phenomenon occurs is somewhere between 20 and 30 times per second, depending on lighting conditions and other factors. I will use the rate of 30 times per second, or 30 Hertz, abbreviated 30 Hz. Televisions, computers, and motion pictures all use this fundamental physiological phenomenon to give the illusion of continuous movement.

    So the question is, how do we program an animation? The only graphics 10 operation that we have discussed so far is drawInWindow, but note that drawing things using this operation is accumulative. That is, we never erase anything, nor even do so much as clear the screen. Even the user interaction given in Chapter 10 does not clear the screen; each successive rendition of the stack of regions is drawn right over the previous rendition. This works because each new picture completely hides the old one.

    This will not work, however, if we are drawing a person walking across the screen, or a ball bouncing in a box.

  • 18 - Higher-Order Types

  • Paul Hudak, Yale University, Connecticut
  • Book:
    The Haskell School of Expression
    Published online:
    28 May 2018
    Print publication:
    28 February 2000, pp 249-264

  • Summary

    All of the types considered thus far have been first order. For example, the type constructor Tree has always been paired with an argument, as in Tree Int (a tree containing Int values) or Tree a (representing the family of trees containing a values). But Tree by itself is a type constructor: something that takes a type as an argument and returns a type as a result. There are no values in Haskell that have this type, but such “higher-order” types can be used in class declarations in useful ways, as we shall see in this chapter.

    The Functor Class

    To begin, consider the following Functor class defined in the Standard Prelude:

    class Functor f where

    fmap :: (a → b) → f a → f b

    DETAILS

    Type applications are written in the same manner as function applications, and are also left associative: The type T a b is equivalent to ((T a) b).

    There is something new here. The type variable f is applied to other types, as in f a and f b. Thus, we would expect f to be a type such as Tree, which can be applied to an argument. Indeed, a suitable instance of Functor for type Tree would be:

    instance Functor Tree where

    fmap f (Leaf x) = Leaf (f x)

    fmap f (Branch t1 t2) = Branch (fmap f t1) (fmap f t2)

    Recall that in Section 7.2 we defined a function mapTree that behaved just as the above fmap method, so we could have instead written:

    “instance Functor Tree where

    fmap = mapTree

    Such an instance declaration declares that Tree, rather than Tree a, is an instance of Functor.

    Note that in Haskell we write Tree Int for trees of integers, and we say that Tree is a type constructor. And we write [Int] for lists of integers. However, what is the type constructor for lists? Because of Haskell's special syntax for the list data type, there is also a special syntax for its type constructor, namely [].

  • Chapter 2 - e-Application Models

  • Faisal Hoque
  • Book:
    e-Enterprise
    Published online:
    20 May 2010
    Print publication:
    28 February 2000, pp 23-56

  • Summary

    NET FOR BUSINESS?

    Not only has the basis of computing changed, the basis of competition has changed too.

    —Andrew S. Grove, Chairman, Intel

    Let's start out by taking a moment to ask—and answer—the most obvious of “e” questions: why do companies that are already successful at selling their products via the more traditional distribution channels (retail locations, catalogs, television, and even the telephone) feel the need to sell their wares online? In short, what is the appeal of the Net?

    First and foremost, the Net enables businesses to interact personally and directly with customers without incurring the overhead costs of building a larger sales force, opening new retail locations, or hiring and training new customer service representatives.

    At first glance, this seems a bit absurd. How does the World Wide Web—largely just a repository of text and images—increase personal interaction? The answer lies in the capability of computers to gather, store, and transmit mountains of data in the blink of an eye. By always utilizing this information in real time, enterprises can focus on building personalized, long-term relationships with each and every customer, such as was done before the days of strip malls, superstores, and direct-mail catalogs. In many ways, this is a better way to do business. Let's pick a simple example to illustrate.

    Say you want to read A Tale of Two Cities. Today, you'd probably just head down to the local branch of a national bookselling chain and buy a copy.

  • 14 - Programming With Streams

  • Paul Hudak, Yale University, Connecticut
  • Book:
    The Haskell School of Expression
    Published online:
    28 May 2018
    Print publication:
    28 February 2000, pp 187-207

  • Summary

    Recall that in Chapter 6 we used an infinite list to simulate a mathematical sequence used in the calculation or the perimeter of an ellipse. When a list is used in a context where it will always he infinite, it is commonly called a stream, Many problems can be elegantly, concisely, and efficiently expressed using streams, which we will explore in this chapter. With the power of streams there are also inherent dangers, which we will also explore. In the next chapter we will use streams in a central way in the implementation of a language for expressing reactive animations.

    Lazy Evaluation

    Because streams are never finite, it would seem natural to define a special polymorphic data type for them, such as:

    data Stream a = a : Stream a

    Although we could certainly do this, it is more convenient to use Haskell lists to “simulate” streams by just never using the empty list constructor []. The main advantage of this approach is that we can then reuse many polymorphic functions already defined on lists rather than redefining them on a new data type.

    In Chapter 6 we used list comprehensions to create the infinite list [2, 2.], but is there a more fundamental way to create this list? Here is one way:

    twos = 2 : twos

    Let's compute this value by calculation:

    twos

    ⇒ 2 : twos

    ⇒ 2 : 2 : twos

    ⇒ 2 : 2 : 2 : twos

    …

    There is, of course, no end to this calculation, An important distinction exists, however, between this calculation and ones that we have labeled as “infinite loops” and given the value ⊥ in previous chapters: this calculation is producing useful information, namely the successive elements of a list. Its value is an infinite list, or stream, A stream contains an infinite amount of information, whereas ⊥ contains no information whatsoever.

    DETAILS

    Try running this example, in Hugs, if you type twos to the evaluation prompt, it will go into an infinite loop printing 2's.

    Now consider the expression head twos.

  • Chapter 8 - e-Enterprise Technology Components

  • Faisal Hoque
  • Book:
    e-Enterprise
    Published online:
    20 May 2010
    Print publication:
    28 February 2000, pp 231-260

  • Summary

    Our goal is not to be a visionary, but to get people to take advantage of what technology is available today.

    —Scott McNealy, Chairman & CEO, Sun Microsystems

    We want everybody who works on the Internet to think of Internet Explorer technologies as a platform that they can build on, a platform that they can take advantage of.

    —Bill Gates, Chairman & CEO, Microsoft

    If you listen to Scott and Bill, all you have to do is to choose between Sun and Microsoft to define your e-Enterprise software infrastructure. I wish the answer was that simple. Au contraire, thanks to the IT industry, choices are unlimited and go far beyond Sun, Microsoft, and Oracle. As a matter of fact, choosing the right implementation strategy from the vast architectural and vendor options is becoming increasingly difficult.

    In Chapter 6, I have outlined a high-level, logical technology architecture that contains high levels of abstractions such as e-Application Rules, e-Application Distribution/Integration, e-Data, and e-Networks. In Chapter 7, you learned the driving business components that primarily define the reusable e-Application Rules. In this final chapter, I will introduce some of the emerging technology components that should be utilized to implement these higher-level abstraction layers from a pure technology perspective.

    Although this chapter discusses a few selected emerging technologies, it is not intended to be a recipe for physical implementation. Rather, it is intended to explore important standard technologies that should be understood, considered, independently verified, and validated for each e-Initiative.

  • 9 - More About Higher-Order Functions

  • Paul Hudak, Yale University, Connecticut
  • Book:
    The Haskell School of Expression
    Published online:
    28 May 2018
    Print publication:
    28 February 2000, pp 105-113

  • Summary

    You have now seen several examples where functions are passed as arguments to other functions, such as with fold and map. In this chapter, I will show several examples where functions are also returned as values. This will lead to several techniques for improving definitions that we have already written - techniques that we will use often in the remainder of the text.

    Currying

    The first improvement relates to the notation we have used to write function applications, such as simple x y z. Although I have noted the similarity of this to the mathematical notation simple(x, y, z), in fact, there is an important difference, namely that simple x y z is actually equivalent to (((simple x) y) z). In other words, function application is left associative, taking one argument at a time.

    Let's look at the expression (((simple x) y) z) a bit closer: There is an application of simple to x, the result of which is applied to y; so (simple x) must be a function! The result of this application, ((simple x) y), is then applied to z, so ((simple x) y) must also be a function!

    Because each of these intermediate applications yields a function, it seems perfectly reasonable to define a function such as:

    multSumByFive = simple 5

    What is simple 5? From the above argument, we know that it must be a function. And from the definition of simple in Section 1.1, we might guess that this function takes two arguments, and returns 5 times their sum.

    Indeed, we can calculate this result as follows:

    multSumByFive a b

    ⇒ (simple 5) a b

    ⇒ simple 5 a b

    ⇒ 5 * (a + b)

  • 23 - A Tour of the Preludelist Module

  • Paul Hudak, Yale University, Connecticut
  • Book:
    The Haskell School of Expression
    Published online:
    28 May 2018
    Print publication:
    28 February 2000, pp 321-331

  • Summary

    The use of lists is particularly common when programming in Haskell, and thus, not surprisingly, there are many predefined polymorphic functions for lists. The list data type itself, plus some of the most useful functions on it, are contained in the Standard Prelude's PreludeList module, which I will cover in detail in this chapter. There is also a Standard Library module called List that has additional useful functions. It is a good idea to become familiar with both modules.

    Although this chapter may feel like a long list of “Haskell features,” the functions described here capture many common patterns of list usage that have been discovered by functional programmers over many years of trials and tribulations. In many ways higher-order declarative programming with lists takes the place of lower-level imperative control structures in more conventional languages. By becoming familiar with these list functions you will be able to more quickly and confidently develop your own applications using lists. Furthermore, if all of us do this, we will have a common vocabulary with which to understand each others' programs. Finally, by reading through the code in this module you will develop a good feel for how to write proper function definitions in Haskell.

    It is not necessary for you to understand the details of every function, but you should try to get a sense for what is available so that you can return later when your programming needs demand it. In the long run, you are well-advised to read the rest of the Standard Prelude as well as the various Standard Libraries, to discover a host of other functions and data types that you might someday find useful in your own work.

    The PreludeList Module

    To get a feel for the PreludeList module, let's first look at its module declaration:

    module PreludeList (

    map, (++), filter, concat,

    head, last, tail, init, null, length, (!!),

    foldl, foldl1, scanl, scanl1, foldr, foldr1, scanr, scanr1,

    iterate, repeat, replicate, cycle,

    take, drop, splitAt, takeWhile, dropWhile, span, break,

    lines, words, unlines, unwords, reverse, and, or,

    any, all, elem, notElem, lookup,

  • 21 - Interpreting Functional Music

  • Paul Hudak, Yale University, Connecticut
  • Book:
    The Haskell School of Expression
    Published online:
    28 May 2018
    Print publication:
    28 February 2000, pp 304-312

  • Summary

    In Chapter 20 I defined a language called MDL for describing musical structures. The question now is, how do we actually interpret the structures; that is, how do we turn them into real music? (This is analogous to the question of how to draw a Shape or Region value in a graphics window.) The approach I will take will be to convert a Music value into a Standard MIDI File, which can then be played on your computer using any standard media player. I will do this, however, in three steps:

  • 1. First I will convert a Music value into a value of type Performance, which is an abstract notion of what the music means.

  • 2. Then I will convert this into a value of type MidiFile, a data type imported from the Haskore library, which represents the structure of a Standard MIDI File.

  • 3. Finally, I will use the outputMidiFile function, also imported from the Haskore library, to write this MidiFile value to an actual file.

    • Dividing the problem into separate steps like this allows us to separate two concerns: interpreting Music values as music, and the details of rendering that music as a MIDI file. It also facilitates readability by having a cleaner structuring of the code, aids debugging by allowing us to look at each intermediate result, and makes it easier to later add an interface to some computer music platform other than MIDI (there are several).

    In this chapter I will describe only the first step above; steps two and three are described in the next (Chapter 22). Also in this chapter I will discuss how the abstract notion of a performance can be used to uncover algebraic properties of musical structures.

  • 2 - A Module of Shapes: Part I

  • Paul Hudak, Yale University, Connecticut
  • Book:
    The Haskell School of Expression
    Published online:
    28 May 2018
    Print publication:
    28 February 2000, pp 21-34

  • Summary

    In the previous chapter you learned quite a few techniques for problem solving via calculation in Haskell It's time now to apply these ideas to a larger example, which will require learning even more problem-solving skills and Haskell language features.

    Our job will be to design a simple module of geometric shapes, that is, a collection of functions and data types for computing with geometric shapes such as circles, squares, triangles, and others. Users of this module will be able to create new instances of geometric shapes and compute their areas. You will learn lots of new things in building this module, including how to design your own data types. Then in Chapter 4 we will extend this functionality with the ability to draw geometric shapes, and in Chapter 6 compute their perimeters.

    In the description above I refer to the end product as a module, through which a user has access to certain well-defined functionalities. A module can be seen as a way to conveniently wrap up an application in such a way that only the functionality intended for the end-user is visible; everything else needed to implement the system is effectively hidden.

    In Haskell we can create a module named Shape in the following way:

    module Shape (…) where

    …body-of-module…

    The “(…)” after the name Shape will ultimately be a list of names of the functions and data types that the end-user is intended to use, and is sometimes called the interface to a module. At the end of this chapter we will fill in the details of the interface once we know what they should be. The …body-of-module… is of course where we will place all the code developed in this chapter.

    DETAILS

    Module names must always be capitalized (just like type names).

    A user of our shape module can later import it into a module that he or she is constructing, by writing:

    import Shape

    Indeed, we will do exactly this in later chapters where new modules will be created in which users will be able to draw shapes, compute their perimeters, combine them into larger “regions,” color them, scale them, and place them on a “virtual desktop.”

  • Chapter 1 - From Net Commerce to e-Enterprise

  • Faisal Hoque
  • Book:
    e-Enterprise
    Published online:
    20 May 2010
    Print publication:
    28 February 2000, pp 3-20

  • Summary

    I don't think there's been anything more important or more widespread.… Where does the Internet rank in priority? It's No. 1, 2, 3, and 4.

    —Jack Welch, Chairman & CEO, General Electric

    When Jack Welch makes the Net his top business priority you can be sure that the Internet and Net-based business have taken the critical step from possibility into reality. In fact, General Electric and countless other Global 2000 companies are quickly investigating and applying the newest Internet technologies. These companies seek to gain and retain competitive advantages in new and evolving markets through highly adaptive Net-based enterprises. Everywhere you turn, both the mainstream and business news media are focused on the Net Revolution. Both alluring and critical reports about the Web, the Information Superhighway, and Internet ventures abound.

    The Net is the backbone for the new digital economy that is radically changing business models around the globe. These new business models have become differentiators that redefine market winners and losers. No one is safe from the changing tide. Past critics of the Internet have said that it's a gadget for hobbyists and computer geeks—not a valuable tool for business. It's all hype, they said. As evidence they pointed to the astronomic market capitalization of so-called Internet stocks. They said that conventional enterprises are safe from these over-publicized startups. Put simply, they were wrong then, and they're wrong now. As Business Week says “You are Merrill Lynch when Schwab.com comes along.

  • 10 - Drawing Regions

  • Paul Hudak, Yale University, Connecticut
  • Book:
    The Haskell School of Expression
    Published online:
    28 May 2018
    Print publication:
    28 February 2000, pp 114-130

  • Summary

    In Chapters 2 and 8 we defined modules for geometric shapes and regions, respectively. We will now build a third layer onto this structure: a module that provides the ability to color regions and to place them on a “virtual desktop” in a graphics window. These colored regions will be called pictures. Once placed, you will be able to “click” on a picture using the mouse, which will cause that picture to rise to the surface of the desktop (i.e., any objects partially occluding it will be pushed beneath it). As usual, I will begin the discussion by providing the module interface:

    module Picture (Picture (Region, Over, EmptyPic),

    Color (Black, Blue, Green, Cyan, Red, Magenta, Yellow, White),

    regionToGRegion, shapeToGRegion,

    drawRegionlnWindow, drawPic, draw, spaceClose,

    module Region

    ) where

    import Draw

    import Region

    import SOEGraphics hiding (Region)

    import qualified SOEGraphics as G (Region)

    DETAILS

    The last two lines above look strange, and arise because both the Region module and the SOEGraphics module define a data type called Region, so importing them both into the same module causes a name clash, which Haskell (quite sensibly) does not. allow. In order to use them both, I first import afl of the SOEGraphics module except for Region; that's what the next to the last line does. Then I import SOEGraphks as a qualified module, at the same time renaming if to G, and furthermore I only import Region from it, All of this is achieved by the last line above, The end result is that in the Picture module, the Region data type defined in SOEGraphics has the name G.Region, whereas the one from module Region is just called Region. (If I had omitted “as G” from the last line above, then the new Region type would be referred to as SOEGraphics. Region.)

    Note that the Region module is imported and exported; and recall that the Region module includes the Shape module.

Page 222 of 296