DOCSLIB.ORG

Beginners Guide to Dolphin Smalltalk -.:: GEOCITIES.Ws

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Beginners Guide to Dolphin Smalltalk -.:: GEOCITIES.Ws Beginners Guide to Dolphin Smalltalk Beginner's Guide to Dolphin Smalltalk Welcome to Dolphin Smalltalk for Microsoft Windows 95 and NT. By now, you have probably installed Dolphin onto your computer and are wondering where to go from here. This guide is the place to start. Contents I know you're probably itching to get going, but I'd just like to take time out to tell you about the structure of this guide and the intended audience for the various parts. Chapter 1: Getting Started This chapter will get you started with Dolphin and teach you how to interact (safely) with the system. If you have used Smalltalk before, much of this will be familiar to you so you may just need to skim through this section quickly. The following chapters are a general introduction to the Smalltalk language and, in spirit, are as applicable to any other implementation of Smalltalk as they are to Dolphin. In practice, we'll use a sample application called Playground to illustrate the various topics and currently this is only available in Dolphin Smalltalk. If you are already familiar with the basic Smalltalk language, you may decide to skip over these chapters. Chapter 2: Objects and Messages Chapter 3: Playing with Objects in the Playground Chapter 4: Control Flow Chapter 5: Classes and Methods Chapter 6: Programming in Smalltalk From this point on there are a number of tutorial sessions available to teach you how to use the Model-View-Presenter framework which lies at the heart of building applications in Dolphin. The following chapters are specific to Dolphin Smalltalk. Tutorial 1: Experiments with Simple Windows Tutorial 2: A Scribble Pad Component file:///C|/OADocs/1.htm (1 of 2) [6/2/2000 8:39:12 AM] Beginners Guide to Dolphin Smalltalk Tutorial 3: Etch-A-Sketch Tutorial 4: Creating a Personal Money Application file:///C|/OADocs/1.htm (2 of 2) [6/2/2000 8:39:12 AM] Getting Started Getting Started This chapter gets you started with Dolphin Smalltalk. The installation program will have created a program folder containing a Dolphin icon. Double-click this to start the Dolphin development system. Obtaining Support There may be times when you run across a problem with Dolphin that you can't solve yourself. If so, you can obtain technical support from Object Arts Ltd. by Internet email or by connecting to the special Dolphin newsgroup forum. For more details, please visit the Object Arts Support web page at: http://www.object-arts.com/Support.htm. First Use When you start Dolphin for the first time, you will be presented with two windows: a System Folder window and a Workspace window. The workspace contains a welcome message and some interesting experiments that you can try immediately to get an insight into the interactive nature of the Smalltalk development environment. These experiments consist of executing small pieces of Smalltalk code and displaying the results. Note that the green pieces of text enclosed in quotes are simply comments and not part of the examples themselves. Most of the examples fit on a single line. To execute one (say the first, 3+4) simply place the text cursor anywhere on that line and type Ctrl+D. You'll see the result printed and highlighted at the end of the line. You can then delete the result simply by pressing the Del key and the highlighted text will disappear. file:///C|/OADocs/2.htm (1 of 4) [6/2/2000 8:39:21 AM] Getting Started In some cases, the comment above the example will suggest that you just execute the code without actually displaying a result. You do this by typing Ctrl+E (for Evaluate It) rather than Ctrl+D (for Display It). These commands can also be chosen from the Workspace menu. Simply choose Workspace/Display It or Workspace/Evaluate It as required. For those examples that span several lines you must select and highlight all of the lines before typing Ctrl+D or Ctrl+E. If you are new to Smalltalk, then I don't really expect you to understand how these examples work yet. They are simply there for a bit of amusement and to get you used to using a workspace window. You can close the workspace at anytime and continue with the remainder of this chapter. Opening a new Workspace If you have not already done so, close the example workspace window that you've been using up to now. You should then be left just with the System Folder open. As we've seen, a workspace is a general text window where snippets of Smalltalk code can be edited and executed (in Smalltalk parlance, evaluated). It is one of a number of development tools that Dolphin provides. For the next few chapters we will be using workspaces, almost exclusively, to interact with the system and perform our experiments. At the start of each chapter you'll be asked to open a new workspace in which the work for that chapter will be performed. You can do this by choosing the File/New menu command from any other workspace or Dolphin development tool window. You may also use the New Workspace toolbar button or the Ctrl+N shortcut if you prefer. At the end of each chapter you should probably tidy up by closing the workspace (and any other example windows) that you have been using. This will free up any memory space and leave the system ready for continuing with the subsequent chapters. Exiting Dolphin You can leave Dolphin at any time by choosing File/Exit Dolphin in any of the development tools. Alternatively, you can also ask to quit by closing the System Folder window. As you do so, you will be prompted and asked if you wish to save the image. Under normal circumstances you will opt to do so, since this will save the state of your environment such that it will be fully restored next time you start Dolphin up. Try exiting and re-starting Dolphin now, saving the image in the process. The Image When Dolphin is loaded and running there are many objects in memory that make up the essence of the entire system. I will talk more about what objects are in the next chapter on Objects and Messages. However, for the moment, it is important to know that when you choose to save the Dolphin image you are requesting that all these objects be saved to disk in, what is known as, an image file. This allows the system to be re-started in an identical state to that when the image was saved. When should I save my Image? The image contains not only those objects that you may create yourself but also very many objects that are concerned with the Dolphin development system itself. This is a really flexible system since virtually everything is exposed to you and you can make changes that affect not only the program you may be building but also any of the development tools themselves. This can allow you to tailor the system in ways that are not possible with traditional development environments. However, this flexibility also brings with it certain dangers. You may, by accident, make a change that corrupts your image such that the development tools no longer work. For this reason, it is always important that you have a good saved image to go back to. I'd recommend that you save your image, not only when you exit Dolphin, but also quite often during use. I suggest you do this at least every hour and once at the end of each chapter in this guide. Do take care, though, not to save down an image that you might have corrupted in any way. Let's try a simple example to prove the point. Open up a new workspace window and arrange it appropriately on the screen. Now file:///C|/OADocs/2.htm (2 of 4) [6/2/2000 8:39:21 AM] Getting Started save the image using File/Save Image or the Save Image toolbar button (the one with the camera). This will save your current state to an image file on disk. Now let's do some irreparable damage and recover from it. Enter the following line of code into your workspace and evaluate it with Ctrl+E: Processor := nil. You'll see that the development system will crash. This is not surprising really when you consider that you have just instructed the main processing element to disappear. However, now restart Dolphin and you should get back to the same state you were in when you previously saved the image. Backups Ideally, you should also take backups of your Dolphin image files. If you do so, you must always save the following three files together: ● Image file (Dolphin.img) ● Changes file (Dolphin.chg) ● Sources file (Dolphin.sml) You'll find these files in the directory where you chose to install Dolphin itself. If you need to restore a backup (perhaps because you accidentally do save down a corrupt image at some point) then you must make sure that you restore all three files together. These files are inextricably linked and should not be separated. I tend to take a backup of my Dolphin image files daily. The System Folder The System Folder window has been lurking in the background during all of this and we haven't paid much attention to it. In many ways it is launching point for all the tools in the development system. Let us see how this works.
Load more

Recommended publications
  • Hopscotch: Towards User Interface Composition Vassili Bykov Cadence Design Systems, 2655 Seely Ave, San Jose, CA 95134
    Hopscotch: Towards User Interface Composition Vassili Bykov Cadence Design Systems, 2655 Seely Ave, San Jose, CA 95134 Abstract Hopscotch is the application framework and development environment of Newspeak, a new programming language and platform inspired by Smalltalk, Self and Beta. Hopscotch avoids a number of design limitations and shortcomings of traditional UIs and UI frameworks by favoring an interaction model and implementing a framework architecture that enable composition of interfaces. This paper discusses the deficiencies of the traditional approach, provides an overview of the Hopscotch alternative and analyses how it improves upon the status quo. 1. Introduction Hopscotch are attributable to its revised interaction and navigation model as much as to the underlying Newspeak [1] is a programming language and framework architecture. For this reason, this paper platform being developed by a team led by Gilad pays equal attention to the compositional frame- Bracha at Cadence Design Systems, Inc. The sys- work architecture and to the changes in the inter- tem is currently hosted inside Squeak [2], a descen- action model of Hopscotch compared to more tradi- dent of Smalltalk-80 [3]. Smalltalk, along with Self tional development environments. [4] and Beta [5], is also among the most important influences on the design of the Newspeak language. 2. Traditional Interface Construction This paper focuses on Hopscotch, the applica- tion framework of Newspeak and the Newspeak The art of devising forms to be filled in depends IDE implemented concurrently with the frame- on three elements: obscurity, lack of space, and work. The framework and the IDE allow easy nav- the heaviest penalties for failure.
    [Show full text]
  • Smalltalk Tutorial for Java Programmers!
    SmallTalk Tutorial for Java Programmers! SmallTalk Tutorial for Java Programmers! Giovanni Giorgi <[email protected]> Jan 2002 A small paper to teach yourself the incredible Smalltalk language! It's so easy, it's so fun! 1. Introduction ● 1.1 Revision history ● 1.2 Conventions used in this paper ● 1.3 Distribution Policy ● 1.4 Why Smalltalk? ● 1.5 Background Required 2. Why Smalltalk is so strange? (or a brief history of Smalltalk) ● 2.1 Download Right Now! ● 2.2 Hello world in Smalltalk ● 2.3 Big Numbers ● 2.4 Code Blocks ● 2.5 The while loop 3. Main Differences between Java and Smalltalk http://daitanmarks.sourceforge.net/or/squeak/squeak_tutorial.html (1 of 2) [1/7/2002 20:44:13] SmallTalk Tutorial for Java Programmers! ● 3.1 Java Versus Smalltalk ● 3.2 Types? No thank you!! ● 3.3 The Squeak base library compared with Java ● 3.4 The Smalltalk Code database ● 3.5 Multiple-Inheritance 4. Ending Words ● 4.1 Going on ● 4.2 Commercial and free products list ● 4.3 References http://daitanmarks.sourceforge.net/or/squeak/squeak_tutorial.html (2 of 2) [1/7/2002 20:44:13] SmallTalk Tutorial for Java Programmers!: Introduction 1. Introduction This paper will teach you the basics of Smalltalk80 language. This tutorial suites the needs of C and Java programmers. But the tutorial can be understanded by everyone knowing a bit of C and/or OOP concepts, as we'll see. Because I will refer a lot to other books and use a lot of technical terms, I'll try to enjoy you while reading.
    [Show full text]
  • This Is the Author's Version of a Work Accepted for Publication by Elsevier
    NOTICE: This is the author’s version of a work accepted for publication by Elsevier. Changes resulting from the publishing process, including peer review, editing, corrections, structural formatting and other quality control mechanisms, may not be reflected in this document. A definitive version was subsequently published in the Journal of Systems and Software, Volume 86, Issue 2, pp. 278-301, February 2013. Efficient Support of Dynamic Inheritance for Class- and Prototype-based Languages Jose Manuel Redondo, Francisco Ortin University of Oviedo, Computer Science Department, Calvo Sotelo s/n, 33007, Oviedo, Spain Abstract Dynamically typed languages are becoming increasingly popular for different software devel- opment scenarios where runtime adaptability is important. Therefore, existing class-based plat- forms such as Java and .NET have been gradually incorporating dynamic features to support the execution of these languages. The implementations of dynamic languages on these platforms com- monly generate an extra layer of software over the virtual machine, which reproduces the reflective prototype-based object model provided by most dynamic languages. Simulating this model fre- quently involves a runtime performance penalty, and makes the interoperation between class- and prototype-based languages difficult. Instead of simulating the reflective model of dynamic languages, our approach has been to extend the object-model of an efficient class-based virtual machine with prototype-based seman- tics, so that it can directly support both kinds of languages. Consequently, we obtain the runtime performance improvement of using the virtual machine JIT compiler, while a direct interoperation between languages compiled to our platform is also possible. In this paper, we formalize dynamic inheritance for both class- and prototype-based languages, and implement it as an extension of an efficient virtual machine that performs JIT compilation.
    [Show full text]
  • Lumi`Ere: a Novel Framework for Rendering 3D Graphics in Smalltalk
    banner above paper title Lumiere` : a Novel Framework for Rendering 3D graphics in Smalltalk Fernando Olivero, Michele Lanza, Romain Robbes REVEAL@ Faculty of Informatics - University of Lugano, Switzerland ffernando.olivero,michele.lanza,[email protected] Abstract One of the cornerstones of Lumiere` is to hinge on the metaphor To render 3D graphics there is a number of different frameworks of a stage. We believe this helps to make the framework and its written in Smalltalk. While most of them provide powerful facil- usage more intuitive, as metaphors are powerful tools to assist ities, many of them are outdated, abandoned, undocumented or the usage of abstract concepts: If a framework is built around an heavyweight. intuitive metaphor which maps abstracts concepts to real-world In this paper we present Lumiere` , a novel lightweight frame- objects, programmers can obtain an immediate mental model of work for rendering 3D graphics using OpenGL based on a stage the framework’s domain model, thus easing the understanding and metaphor. Lumiere` is implemented using the Pharo IDE. In its cur- usage of the framework. rent state it supports basic and composite shapes to populate 3D To apply this concept to 3D graphics, Lumiere` ’s stage metaphor scenes, features a camera, and a lighting model. implies that all graphics are produced by cameras taking pictures We illustrate the usage of Lumiere` with Gaucho, an environ- of 3D shapes lit by the lights of the stage. A stage provides the ment for visual programming we are currently building. setting for taking pictures of a composition of visual objects we call micro-worlds.
    [Show full text]
  • A Browser for Incremental Programming
    Portland State University PDXScholar Computer Science Faculty Publications and Presentations Computer Science 9-2003 A Browser for Incremental Programming Andrew P. Black Portland State University, [email protected] Follow this and additional works at: https://pdxscholar.library.pdx.edu/compsci_fac Part of the Programming Languages and Compilers Commons, and the Software Engineering Commons Let us know how access to this document benefits ou.y Citation Details Schärli, Nathanael, and Andrew P. Black. "A browser for incremental programming." Computer Languages, Systems & Structures 30.1 (2004): 79-95. This Post-Print is brought to you for free and open access. It has been accepted for inclusion in Computer Science Faculty Publications and Presentations by an authorized administrator of PDXScholar. Please contact us if we can make this document more accessible: [email protected]. A Browser for Incremental Programming Nathanael Scharli¨ a,∗ Andrew P. Black b aSoftware Composition Group, University of Bern, Switzerland bOGI School of Science & Engineering, Oregon Health & Science University, USA Abstract Much of the elegance and power of Smalltalk comes from its programming environment and tools. First introduced more than 20 years ago, the Smalltalk browser enables programmers to “home in” on particular methods using a hierarchy of manually-defined classifications. By its nature, this clas- sification scheme says a lot about the desired state of the code, but little about the actual state of the code as it is being developed. We have extended the Smalltalk browser with dynamically computed virtual categories that dramatically improve the browser’s support for incremental programming. We illustrate these improvements by example, and describe the algorithms used to compute the virtual categories efficiently.
    [Show full text]
  • COSC345 Week 21 Notes
    COSC345 Week 21 Notes There are handouts about the spiral model: a copy of Boehm’s paper, and the Wikipedia page about it. “Prototyping is about risk reduction: if you don’t have a question, you don’t need a prototype” is the heart of it. The edition of Pressman I intended is the old one listed in the Bibliography. The section about “Developers and Users are different” is really quite impor- tant. It might even deserve to be in a lecture of its own, though not necessarily in this paper. I once had a student (who became a highly paid consultant in the UK) who was into Neuro-Linguistic Programming; it seems they not only clas- sify people’s thinking styles as (Visual/Auditory/Tactile)×(Digital/Analogue) but have techniques for determining which someone is. It’s quite interesting to get someone to describe something abstract and note what kinds of metaphors they use; the point is that people use different ones. There are the classic Four Temperaments (Choleric, Melancholic, Phlegmatic, and Sanguine) and the mod- ern refinement of it, the Enneagram. People always seem to be fascinated to be told about themselves, so getting the members of the class to do some kind of quick personality test and then collecting the results anonymously and tab- ulating them might be a fun way to make the point that people really do think differently. Here’s one: http://similarminds.com/test.html Of course, it’s not just developers and users who differ. Users differ from each other. The point is to remind students that they cannot expect other people to think exactly like them and to enjoy exactly what they enjoy.
    [Show full text]
  • Reading Smalltalk
    How to Read Smalltalk JAS Research CS OO Languages Smalltalk readingSmalltalk Reading Smalltalk My presentation is based on the way I tackle any language: 1. Examine the character set and tokens 2. Examine the reserved words 3. Examine each unique syntactic form 4. Examine each unique semantic form 5. Examine the libraries So here goes... 1. Character set and tokens Standard character set, with twelve special characters: #:^.'|";()[] The tokens are: {identifier} {number} {string} {comment} {binaryOperator} {keyword} {specialToken} Identifiers are the same as you'd expect, except that we use capitalLettersLikeThis, rather_than_underscores. Numbers are also as you'd expect. 'Strings' 'are enclosed in single quotes' "Comments" "are enclosed in double quotes" Binary operators are composed of one or two characters. The characters which can form a {binaryOperator} vary a little bit between implementations, but for the purpose of reading Smalltalk, you can assume that any non-alphaNumeric character which is not in the above list of {special characters} forms a {binaryOperator}. For example, + is a {binaryOperator}. ++ is a {binary operator}. ?* is a {binaryOperator}. -> is a {binaryOperator}. A keyword: is just an identifier with a colon on the end of it, e.g. anyIdentifierLikeThis: is a {keyword}. In Smalltalk, a keyword is only special in the sense that it forms a "keyword message". It is a distict kind of token (different from an identifier or a string) but it's meaning as an individual token is not special. Some languages have {keywords} like BEGIN and END with builtin special meanings. {Keyword} in Smalltalk is not this sort of thing, it's strictly a syntactic form.
    [Show full text]
  • Towards Version Control in Object-Based Systems
    Towards Version Control in Object-based Systems Jakob Reschke, Marcel Taeumel, Tobias Pape, Fabio Niephaus, Robert Hirschfeld Technische Berichte Nr. 121 des Hasso-Plattner-Instituts für Digital Engineering an der Universität Potsdam ISBN 978-3-86956-430-2 ISSN 1613-5652 Technische Berichte des Hasso-Plattner-Instituts für Digital Engineering an der Universität Potsdam Technische Berichte des Hasso-Plattner-Instituts für Digital Engineering an der Universität Potsdam | 121 Jakob Reschke | Marcel Taeumel | Tobias Pape | Fabio Niephaus | Robert Hirschfeld Towards Version Control in Object-based Systems Universitätsverlag Potsdam Bibliografische Information der Deutschen Nationalbibliothek Die Deutsche Nationalbibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie; detaillierte bibliografische Daten sind im Internet über http://dnb.dnb.de/ abrufbar. Universitätsverlag Potsdam 2018 http://verlag.ub.uni-potsdam.de/ Am Neuen Palais 10, 14469 Potsdam Tel.: +49 (0)331 977 2533 / Fax: 2292 E-Mail: [email protected] Die Schriftenreihe Technische Berichte des Hasso-Plattner-Instituts für Digital Engineering an der Universität Potsdam wird herausgegeben von den Professoren des Hasso-Plattner-Instituts für Digital Engineering an der Universität Potsdam. ISSN (print) 1613-5652 ISSN (online) 2191-1665 Das Manuskript ist urheberrechtlich geschützt. Druck: docupoint GmbH Magdeburg ISBN 978-3-86956-430-2 Zugleich online veröffentlicht auf dem Publikationsserver der Universität Potsdam: URN urn:nbn:de:kobv:517-opus4-410812 http://nbn-resolving.de/urn:nbn:de:kobv:517-opus4-410812 Version control is a widely used practice among software developers. It reduces the risk of changing their software and allows them to manage different configurations and to collaborate with others more efficiently. This is amplified by code sharing platforms such as GitHub or Bitbucket.
    [Show full text]
  • The Best of Comp.Lang.Smalltalk: Two New Smalltalks
    The Best of comp.lang.smalltalk Alan Knight Two New Smalltalks malltalk is a very loose term. While there are some still won’t run as quickly as compiled code (you have to clear, defining characteristics, there are also many spend CPU cycles to translate, and you can’t afford to think Svariations as well. This is important because software too hard about optimization). Finally, it requires a VM to development is a large field, with different solutions do the translating, which makes it more difficult to create appropriate to different problems. This article will discuss standalone executables, DLLs, and callback functions. some of these possible variations, with reference to two Smalltalk MT is fully compiled, and has “an optimizing promising new implementations. compiler that generates fast, compact code.” Full compi- The first of these new implementations is Object lation should give significantly better performance than Connect’s “Smalltalk MT,” a high-performance imple- existing implementations, and the absence of a VM allows mentation for Windows NT 4.0, with full compilation and simple programs to be very small indeed. MT claims to be true multithreading. The second is Intuitive Systems’ able to make DLLs (which, to my knowledge, no existing “Dolphin Smalltalk,” which boasts a low cost and a very Smalltalk can do), and to fit a trivial windows application low memory footprint. into a 100K executable (their runtime-support DLL adds Neither one has been officially released yet, but free only 52K). prerelease copies are available for download from their Dolphin Smalltalk is bytecode interpreted. I would Web sites (see contact information at the end).
    [Show full text]
  • Why Smalltalk James Robertson Independent Consultant Smalltalk Evangelist
    Why Smalltalk James Robertson Independent Consultant Smalltalk Evangelist http://www.jarober.com Friday, December 9, 2011 Origins • Xerox PARC • Where all the other good stuff came from • Designed to be easy to learn Friday, December 9, 2011 Origins • Message Passing: You tell objects what to do • Easy to read syntax: More like human language • Complexity in the library, not in the language Friday, December 9, 2011 What’s Cool About It? Friday, December 9, 2011 Maturity • Smalltalk has been in widespread use since the mid ‘80s • Multiple implementations • Commercial • Open Source • It’s influence is felt beyond the Smalltalk community Friday, December 9, 2011 Influences • Sun almost picked Smalltalk • ParcPlace was too greedy for license fees • Instead, Oak became Java, with major influences from Smalltalk Friday, December 9, 2011 Influences • Java • Class Based • Single Inheritance • VM/byte code system • Portability Friday, December 9, 2011 Influences • Erlang • Joe Armstrong originally wanted to use Smalltalk • At the time, it was not ready for what he needed, and the vendors were slow to respond • Developed the concurrency model for Erlang around message passing • Erlang itself has gone on to influence concurrency models in language design Friday, December 9, 2011 Influences • Dart • Developed by Gilad Bracha and Lars Bok • Both have delivered Smalltalk derived systems (Newspeak, OOVM) Friday, December 9, 2011 Influences • Dart • Class Based • Single Inheritance • Optional Typing (Dynamic) • Supports Named Parameters (readability) • Built
    [Show full text]
  • Dynamic Language Embedding
    Dynamic Language Embedding With Homogeneous Tool Support Inauguraldissertation der Philosophisch-naturwissenschaftlichen Fakultät der Universität Bern | downloaded: 27.9.2021 vorgelegt von Lukas Renggli von Entlebuch Leiter der Arbeit: Prof. Dr. O. Nierstrasz Institut für Informatik und angewandte Mathematik https://doi.org/10.7892/boris.104713 source: This dissertation is available as a free download from scg.unibe.ch. Copyright © 2010 Lukas Renggli, www.lukas-renggli.ch. The contents of this dissertation are protected under Creative Commons Attribution-ShareAlike 3.0 Unported license. For any reuse or distribution, you must make clear to others the license terms of this work. The best way to do this is with a link to creativecommons.org/licenses/by-sa/3.0/. First Edition, October, 2010. Cover art by Martin Renggli. Acknowledgements First of all, I would like to express my gratitude to Oscar Nierstrasz for giving me the opportunity to work at the Software Composition Group. I thank him for his advice and support throughout the years. I would like to thank Ralf Lämmel for writing the Koreferat and for accepting to be on the PhD committee. I enjoyed the good discussions we had when we met in Bern, Koblenz and at various language engineering conferences. I thank Matthias Zwicker for accepting to chair the examination. I am grateful to Stéphane Ducasse for his enthusiasm and the numerous invitations to join him at his research group in Annecy and later in Lille. I might not have taken the path of pursuing a PhD without the encouragements of him. I also thank Tudor Gîrba for the inspiring discussions and for providing many of the ideas that have influenced this work.
    [Show full text]
  • HTML5 Parser
    HTML5 Parser Dissertation submitted to the University of Manchester for the degree of Master of Science in the Faculty of Computer Science. 2013 Mohammad Al Houssami School of Computer Science The Author Mohammad Al Houssami has a Bachelors Degree in Computer Science from the American University of Beirut in June 2012 and currently pursuing a degree in Advanced Computer Science with concentration on Software Engineering. Apart from the current work done on both project and research no previous work was done. The bachelor’s degree acquired did not include any projects or research to be done. Knowledge in the field of HTML in general and HTML5 specifically was very basic before the project. Parsing markup was introduced during the semi-structured data and the Web. 2 Abstract As HTML5’s key feature is the detailed algorithm designed to parse any arbitrary content, the project is about producing an independent implementation for the HTML5 parsing algorithm. The project is built for the Smalltalk community which does not have its own native parser. The implementation also has a testing suite that can be used to check if things are broken or to continue the development on the project. As a final step, the project offers feedback to the standardization groups. The paper includes a brief history of HTML and parsing. A part of the paper is dedicated for the language before going into the details of the implementation and the challenges faced. A simple guide to continue the implementation is also provided in the paper for individuals aiming to complete the parser.
    [Show full text]