From the viewpoint of at least one corporate consumer of computer education, Lisp-based training confers many professional advantages, even if the student never goes on to use Lisp in real life. Among these advantages are a grasp of computer science fundamentals that comes from simply knowing the Lisp language (Whorf was right, in this domain at least) and good software engineering habits (incremental development, abstraction, modularity, object-orientation). These habits are widely believed to be advantages, but Lisp is not widely seen as helping students acquire them. This paper will corroborate the connection between Lispbased training and these good habits. On the other hand, some of these habits may not be good at all (this is one reading of Gabriel's "worse is better" theory). This paper will argue that Lisp-based training is more flexible than training based on popular imperative languages at discouraging the bad in these habits. Then this paper will describe some true drawbacks of Lisp-based training. These drawbacks include stylistic jingoism, excessive delegation of performance issues to the Lisp implementor or to the machine, superstitious avoidance of the more complex (albeit more casually implemented) Lisp facilities, stubborn reluctance to distinguish between compilation, runtime, and delivery environments, and a tendency to make use of Lisp's extensibility to re-invent the wheel merely because the tread size is not quite right. Ironically, Lisp itself contains the cure for the diseases it spreads. This paper concludes by offering, from real-world experience, some suggestions for modification, not abandonment, of Lisp-based training.Why teach computer fundamentals using an arcane, ancient language that has found limited use in the world beyond the ivory tower? Why not use a language that is found everywhere, or build a special pedagogical language from scratch? Arguments about the best way to conduct computer education can go on without end, but unfortunately, Darwin always has the last word. If the Lisp language is too fascinating for its own good, then using it to train computer professionals is illconceived, as ill-conceived as the topheavy tail feathers that make a bird of paradise tip over as soon as it displays them. If, on the other hand, the marketplace rewards elegance, universality, and flexibility, then Lisp can substantially augment a student's fitness to survive when jumping off the ivory tower.
From the viewpoint of at least one corporate consumer of computer education, Lisp-based training confers many professional advantages, even if the student never goes on to use Lisp in real life. Among these advantages are a grasp of computer science fundamentals that comes from simply knowing the Lisp language (Whorf was right, in this domain at least) and good software engineering habits (incremental development, abstraction, modularity, object-orientation). These habits are widely believed to be advantages, but Lisp is not widely seen as helping students acquire them. This paper will corroborate the connection between Lisp-based training and these good habits. On the other hand, some of these habits may not be good at all (this is one reading of Gabriel's "worse is better" theory). This paper will argue that Lisp-based training is more flexible than training based on popular imperative languages at discouraging the bad in these habits. Then this paper will describe some true drawbacks of Lisp-based training. These drawbacks include stylistic jingoism, excessive delegation of performance issues to the Lisp implementor or to the machine, superstitious avoidance of the more complex (albeit more casually implemented) Lisp facilities, stubborn reluctance to distinguish between compilation, runtime, and delivery environments, and a tendency to make use of Lisp's extensibility to re-invent the wheel merely because the tread size is not quite right. Ironically, Lisp itself contains the cure for the diseases it spreads. This paper concludes by offering, from real-world experience, some suggestions for modification, not abandonment, of Lisp-based training.
We examine the integration of Lisp and C in a commercial application, with a view towards the "proper place" of each language in large, practical applications in general. Topics addressed include portability, flexibility, efficiency, compactness, and user base of the two languages. We outline the pivotal role of Lisp-to-C translation tools in integration efforts. An attempt is made to dispel some half-truths about Lisp and inflated claims about C promulgated by interested parties.
scite is a Brooklyn-based organization that helps researchers better discover and understand research articles through Smart Citations–citations that display the context of the citation and describe whether the article provides supporting or contrasting evidence. scite is used by students and researchers from around the world and is funded in part by the National Science Foundation and the National Institute on Drug Abuse of the National Institutes of Health.
customersupport@researchsolutions.com
10624 S. Eastern Ave., Ste. A-614
Henderson, NV 89052, USA
Copyright © 2024 scite LLC. All rights reserved.
Made with 💙 for researchers
Part of the Research Solutions Family.