|
|
| Line 1: |
Line 1: |
| {{about|the programming language|the village in Estonia|Simula, Estonia}}
| | Quartz, being one of the hardest products on the earth is considered as an ideal countertop material for your new kitchen area. The substantial power, sturdiness and attractiveness of this stone make it a topmost preference for each the designers and residence entrepreneurs. Let's have an intriguing discussion on how quartz goes as a result of the system of becoming a countertop immediately after obtaining started off as crystals in the earth. Leading Quartz Slabs Suppliers in Usa supply good quality engineered stone countertops for modern-day house renovation or creating jobs. <br><br>Fundamental Information<br>Quartz has some outstanding kinds that are regarded as semi-precious gemstones. It is the next most usually found mineral on the earth. Quartz varieties a crystalline framework that is frequently hexagonal in shape, and it is thanks to this kind of a structure it is one of the strongest minerals uncovered on earth. Counter tops created of this stone are obtainable in diverse shades, but the most typically used quartz counter tops are ordinarily white. <br>Mining and Manufacturing <br>The quartz countertops visitors are familiar with essentially male-created engineered stone counter tops composed of 90% ground quartz, that is a all-natural challenging mineral, alongside with 8-ten% resins, pigments and polymers. This blend varieties a very rigid granite-like surface area. Quartz is mined on every single populated continent of the world. Having to the quartz involves weighty machinery and explosives in get to crack via any stone blocking entry or any ground. The moment the mineral is uncovered, mining is an easy course of action. Miners can only decide on up unfastened crystals utilizing their fingers and untie fastened crystals with pickaxes and shovels. <br>Grinding<br>The difference among quartz and other stones employed to make countertop materials is that it does not arrive in enormous sheets, and it is particularly due to this explanation a man-created processing is critical to make it into a reliable slab. The crystals are developed to be floor up so as to produce excellent countertops. The physical appearance by and massive is dependent on the ways this mineral is ground. A high-quality grind enables for a additional uniform visual appeal whilst a larger grind allows the counters to have a lot more depth and sparkle. In other words and phrases, a coarsely floor quartz generates a flecked visual appearance, whereas a finely ground quartz makes a smooth look. <br>Mixing with Resin<br>The floor up quartz is mixed with a really little total of resin that assists in creating the countertop surface challenging. A coloring agent is also utilised to the combination. The sum of coloration and resin is only close to 3% of a countertop. Aside from coloring brokers, other components like semi-cherished quartz kinds, smaller flecks of precious metals or recycled glass can also be extra if the customer wishes.<br>Forming slabs<br>The substance is pressed into a mildew and healed in an oven following the mixing is performed. Molding can be custom-made to make it possible for the clientele to ascertain the counter's dimensions and an edging style. Right after curing, the countertop is kept to be hardened and cool. Now, it previously has a glossy complete and only demands to be set up after the fixture holes are manufactured.<br>With a expert installation of your new quartz countertop slabs in your residence, enjoy many content many years of their significant applications.<br>About the Creator Catherine You is a renowned quartz countertop provider who provides shopping for strategies and advice for shoppers seeking to pick large high quality quartz countertop slabs. His short article will enable you know about the different important things linked to quartz mining and processing.<br><br>Here's more info in regards to truyen.meximas.com ([http://truyen.meximas.com/index.php?do=/blog/35721/the-counter-tops-inside-our-homes-ought-to-develop-into-pleasing-very-long-/add-comment/ click through the following internet site]) review our own web page. |
| {{Infobox programming language
| |
| | name = Simula
| |
| | logo =
| |
| | paradigm = [[Object-oriented programming|Object-oriented]]
| |
| | year = 1967
| |
| | designer = [[Ole-Johan Dahl]], [[Kristen Nygaard]]
| |
| | developer =
| |
| | latest_release_version =
| |
| | latest_release_date =
| |
| | latest_test_version =
| |
| | latest_test_date =
| |
| | typing =
| |
| | implementations =
| |
| | dialects =
| |
| | influenced_by = [[ALGOL 60]]
| |
| | influenced = [[List of object-oriented programming languages|Object-oriented programming language]]s
| |
| | operating_system =
| |
| | license =
| |
| | website =
| |
| }}
| |
| '''Simula''' is a name for two [[Simulation language|simulation]] [[programming language]]s, Simula I and Simula 67, developed in the 1960s at the [[Norwegian Computing Center]] in [[Oslo]], by [[Ole-Johan Dahl]] and [[Kristen Nygaard]]. [[syntax (programming languages)|Syntactically]], it is a fairly faithful superset of [[ALGOL 60]].
| |
| <ref name="CommonBase">Ole-Johan Dahl, Bjørn Myhrhaug, and Kristen Nygaard (1970), :[http://www.edelweb.fr/Simula/#7], Common Base Language, Norwegian Computing Center</ref>{{rp|1.3.1}}
| |
| | |
| Simula 67 introduced [[object (computing)|objects]],<ref name="CommonBase"/>{{rp|2, 5.3}} [[class (computer science)|classes]],<ref name="CommonBase"/>{{rp|1.3.3, 2}} [[Inheritance (object-oriented programming)|inheritance]] and [[subclass (computer science)|subclasses]],<ref name="CommonBase"/>{{rp|2.2.1}} [[virtual function|virtual methods]],<ref name="CommonBase"/>{{rp|2.2.3}} [[coroutine]]s,<ref name="CommonBase"/>{{rp|9.2}} [[discrete event simulation]],<ref name="CommonBase"/>{{rp|14.2}} and features [[garbage collection (computer science)|garbage collection]].<ref name="CommonBase"/>{{rp|9.1}} [[Subtyping]] was introduced in Simula derivatives.{{fact|date=December 2013}}
| |
| | |
| Simula is considered the first [[object-oriented programming|object-oriented]] [[programming paradigm|programming]] language. As its name implies, Simula was designed for doing [[simulations]], and the needs of that [[Problem domain|domain]] provided the framework for many of the features of object-oriented languages today.
| |
| | |
| Simula has been used in a wide range of applications such as simulating [[very-large-scale integration|VLSI]] designs, [[process modeling]], [[protocol (computing)|protocols]], [[algorithm]]s, and other applications such as [[typesetting]], [[computer graphics]], and [[education]]. The influence of Simula is often understated, and Simula-type objects are reimplemented in [[C++]], [[Java (programming language)|Java]] and [[C Sharp (programming language)|C#]]. The creator of C++, [[Bjarne Stroustrup]], has acknowledged that Simula 67 was the greatest influence on him to develop C++, to bring the kind of productivity enhancements offered by Simula to the raw computational speed offered by lower level languages like [[BCPL]].
| |
| | |
| == History ==
| |
| | |
| The following account is based on Jan Rune Holmevik's historical essay.<ref>
| |
| {{Cite journal
| |
| | last = Holmevik
| |
| | first = Jan Rune
| |
| | authorlink =
| |
| | title = Compiling Simula: A historical study of technological genesis
| |
| | journal = IEEE Annals of the History of Computing
| |
| | volume = 16
| |
| | issue = 4
| |
| | pages = 25–37
| |
| | publisher =
| |
| | location =
| |
| | year = 1994
| |
| | url = http://www.idi.ntnu.no/grupper/su/publ/simula/holmevik-simula-ieeeannals94.pdf
| |
| | issn =
| |
| | doi = 10.1109/85.329756
| |
| | id =
| |
| | accessdate = 12 May 2010 }}
| |
| </ref><ref> | |
| Jan Rune [http://heim.ifi.uio.no/~cim/sim_history.html], Compiling Simula, Institute for Studies in Research and Higher Education, Oslo, Norway</ref>
| |
| | |
| [[Kristen Nygaard]] started writing computer simulation programs in 1957. Nygaard saw a need for a better way to describe the heterogeneity and the [[instruction (computer science)|operation]] of a [[system]]. To go further with his ideas on a formal [[computer language]] for describing a system, Nygaard realized that he needed someone with more [[computer programming]] skills than he had. [[Ole-Johan Dahl]] joined him on his work January 1962. The decision of linking the language up to [[ALGOL 60]] was made shortly after. By May 1962 the main concepts for a [[simulation]] [[programming language|language]] were set. "SIMULA I" was born, a special purpose [[programming language]] for [[simulation|simulating]] discrete event systems.
| |
| | |
| Kristen Nygaard was invited to [[UNIVAC]] late May 1962 in connection with the marketing of their new [[UNIVAC 1107]] computer. At that visit Nygaard presented the ideas of Simula to [[Bob Bemer|Robert Bemer]], the director of systems programming at [[Univac]]. Bemer was a sworn [[ALGOL]] fan and found the Simula project compelling. Bemer was also chairing a session at the second international conference on information processing hosted by [[International Federation for Information Processing|IFIP]]. He invited Nygaard, who presented the paper "SIMULA -- An Extension of ALGOL to the Description of Discrete-Event Networks".
| |
| | |
| [[Norwegian Computing Center]] got a [[UNIVAC 1107]] August 1963 at a considerable discount, on which Dahl implemented the SIMULA I under contract with UNIVAC. The implementation was based on the UNIVAC [[ALGOL 60]] compiler. SIMULA I was fully operational on the UNIVAC 1107 by January 1965. In the following couple of years Dahl and Nygaard spent a lot of time teaching Simula. Simula spread to several countries around the world and SIMULA I was later implemented on [[Burroughs large systems|Burroughs B5500 computers]] and the Russian [[Ural (computer)|URAL-16 computer]].
| |
| | |
| In 1966 [[C. A. R. Hoare]] introduced the concept of record class construct, which Dahl and Nygaard extended with the concept of prefixing and other features to meet their requirements for a generalized process concept. Dahl and Nygaard presented their paper on [[class (computer science)|Class]] and [[subclass (computer science)|Subclass]] Declarations at the [[International Federation for Information Processing|IFIP]] Working Conference on [[simulation language]]s in [[Oslo]], May 1967. This paper became the first formal definition of Simula 67. In June 1967 a conference was held to standardize the language and initiate a number of implementations. Dahl proposed to unify the [[data type|type]] and the class concept. This led to serious discussions, and the proposal was rejected by the board. SIMULA 67 was formally standardized on the first meeting of the SIMULA Standards Group (SSG) in February 1968.
| |
| | |
| Simula was influential in the development of [[Smalltalk]] and later [[object-oriented programming language]]s. It also helped inspire the [[actor model]] of concurrent computation although Simula only supports [[co-routines]] and not true [[concurrency (computer science)|concurrency]].
| |
| | |
| In the late sixties and the early seventies there were four main implementations of Simula:
| |
| | |
| * [[UNIVAC|UNIVAC 1100]] by [[Norwegian Computing Center|NCC]]
| |
| * [[System/360]] and [[System/370]] by [[Norwegian Computing Center|NCC]]
| |
| * [[CDC 3000]] by [[University of Oslo]]'s Joint Computer Installation at Kjeller
| |
| * [[TOPS-10]] by [[Försvarets forskningsanstalt|Swedish Research Institute for National Defence (FOA)]]
| |
| | |
| These implementations were ported to a wide range of platforms. The [[TOPS-10]] implemented the concept of public, protected, and private member variables and methods, that later was integrated into Simula 87. Simula 87 is the latest standard and is ported to a wide range of platforms. There are mainly three implementations:
| |
| | |
| * Simula AS
| |
| * Lund Simula
| |
| * GNU Cim<ref>[http://www.gnu.org/software/cim/ GNU Cim]</ref>
| |
| | |
| In November 2001 Dahl and Nygaard were awarded the [[IEEE John von Neumann Medal]] by the [[Institute of Electrical and Electronic Engineers]] "For the introduction of the concepts underlying [[object-oriented programming]] through the design and implementation of SIMULA 67". In February 2002 they received the 2001 A. M. [[Turing Award]] by the [[Association for Computing Machinery]] (ACM), with the citation: "For ideas fundamental to the emergence of object oriented programming, through their design of the programming languages Simula I and Simula 67." Unfortunately neither Dahl, nor Nygaard could make it to the ACM Turing Award Lecture,<ref>{{cite web|url=http://www.informatik.uni-trier.de/~ley/db/journals/cacm/turing.html |title=ACM Turing Award Lectures |publisher=Informatik.uni-trier.de |date= |accessdate=2012-01-14}}</ref> scheduled to be delivered at the [[OOPSLA]] 2002 conference in Seattle, as they both died within two months of each other in June and August, respectively.<ref>{{cite web|url=http://www.acm.org/announcements/turing_obit.html |title=ACM Ole-Johan Dahl and Kristen Nygaard - Obituary |publisher=Acm.org |date= |accessdate=2012-01-14}}</ref>
| |
| | |
| [[Simula Research Laboratory]] is a research institute named after the Simula language, and Nygaard held a part-time position there from the opening in 2001.
| |
| | |
| The new Computer Science building at the [[University of Oslo]] is named Ole Johan Dahl's House, after one of the two inventors of Simula. The main auditorium in Ole Johan Dahl's House is named Simula.
| |
| | |
| Simula is still used for various types of university courses, for instance, Jarek Sklenar teaches Simula to students at University of Malta.<ref>{{cite web|url=http://staff.um.edu.mt/jskl1/ |title=Jarek Sklenar Web Page |publisher=Staff.um.edu.mt |date= |accessdate=2012-01-14}}</ref>
| |
| | |
| == Sample code ==
| |
| | |
| === Minimal program ===
| |
| The empty [[computer file]] is the minimal [[computer program|program]] in Simula, measured by the size of the [[source code]].
| |
| It consists of one thing only; a dummy [[statement (programming)|statement]].
| |
| | |
| However, the minimal program is more conveniently represented as an empty block:
| |
| | |
| '''Begin'''
| |
| '''End''';
| |
| | |
| It begins executing and immediately terminates.
| |
| The language does not have any [[return value]] from the program itself.
| |
| | |
| === Classic Hello world ===
| |
| An example of a [[Hello world program]] in Simula:
| |
| | |
| '''Begin'''
| |
| '''OutText''' ("Hello World!");
| |
| '''Outimage''';
| |
| '''End''';
| |
| | |
| Simula is [[case-insensitive]].
| |
| | |
| === Classes, subclasses and virtual methods ===
| |
| | |
| A more realistic example with use of classes<ref name="CommonBase"/>{{rp|1.3.3, 2}}, subclasses<ref name="CommonBase"/>{{rp|2.2.1}} and virtual methods<ref name="CommonBase"/>{{rp|2.2.3}}:
| |
| | |
| '''Begin'''
| |
| '''Class''' Glyph;
| |
| '''Virtual''': '''Procedure''' print '''Is''' '''Procedure''' print;
| |
| '''Begin'''
| |
| '''End''';
| |
|
| |
| Glyph '''Class''' Char (c);
| |
| '''Character''' c;
| |
| '''Begin'''
| |
| '''Procedure''' print;
| |
| OutChar(c);
| |
| '''End''';
| |
|
| |
| Glyph '''Class''' Line (elements);
| |
| '''Ref''' (Glyph) '''Array''' elements;
| |
| '''Begin'''
| |
| '''Procedure''' print;
| |
| '''Begin'''
| |
| '''Integer''' i;
| |
| '''For''' i:= 1 '''Step''' 1 '''Until''' UpperBound (elements, 1) '''Do'''
| |
| elements (i).print;
| |
| OutImage;
| |
| '''End''';
| |
| '''End''';
| |
|
| |
| '''Ref''' (Glyph) rg;
| |
| '''Ref''' (Glyph) '''Array''' rgs (1 : 4);
| |
|
| |
| ''! Main program;''
| |
| rgs (1):- '''New''' Char ('A');
| |
| rgs (2):- '''New''' Char ('b');
| |
| rgs (3):- '''New''' Char ('b');
| |
| rgs (4):- '''New''' Char ('a');
| |
| rg:- '''New''' Line (rgs);
| |
| rg.print;
| |
| '''End''';
| |
| | |
| The above example has one [[super class]] (Glyph) with two [[subclass (computer science)|subclasses]] (Char and Line).
| |
| There is one [[virtual method]] with two [[implementation]]s.
| |
| The execution starts by executing the main program.
| |
| Simula does not have the concept of [[abstract class]]es since classes with [[pure virtual method]]s can be [[instantiation (computer science)|instantiated]]. This means that in the above example all classes can be instantiated. Calling a [[pure virtual method]] will however produce a [[run-time error]].
| |
| | |
| === Call by name ===
| |
| | |
| Simula supports [[call by name]]<ref name="CommonBase"/>{{rp|8.2.3}} so the [[Jensen's Device]] can easily be implemented.
| |
| However, the default transmission mode for simple parameter is [[call by value]], contrary to [[ALGOL]] which used [[call by name]].
| |
| The source code for the [[Jensen's Device]] must therefore specify [[call by name]] for the parameters when compiled by a Simula compiler.
| |
| | |
| Another much simpler example is the [[arithmetic function#Summation functions|summation function <math> \sum </math>]] which can be implemented as follows:
| |
| | |
| '''Real''' '''Procedure''' Sigma (k, m, n, u);
| |
| '''Name''' k, u;
| |
| '''Integer''' k, m, n; '''Real''' u;
| |
| '''Begin'''
| |
| '''Real''' s;
| |
| k:= m;
| |
| '''While''' k <= n '''Do''' '''Begin''' s:= s + u; k:= k + 1; '''End''';
| |
| Sigma:= s;
| |
| '''End''';
| |
| | |
| The above code uses [[call by name]] for the controlling variable (k) and the expression (u).
| |
| This allows the controlling variable to be used in the expression.
| |
| | |
| Note that the Simula standard allows for certain restrictions on the controlling variable
| |
| in a [[for loop]]. The above code therefore uses a while loop for maximum portability.
| |
| | |
| The following:
| |
| | |
| <math> Z = \sum_{i=1}^{100}{1 \over (i + a)^2}</math> | |
| | |
| can then be implemented as follows:
| |
| | |
| Z:= Sigma (i, 1, 100, 1 / (i + a) ** 2);
| |
| | |
| === Simulation ===
| |
| | |
| Simula includes a [[simulation]]<ref name="CommonBase"/>{{rp|14.2}} package for doing [[discrete event simulation]]s. This simulation package is based on Simula's [[object oriented]] features and its [[coroutine]]<ref name="CommonBase"/>{{rp|9.2}} concept.
| |
| | |
| Sam, Sally, and Andy are shopping for clothes. They have to share one fitting room. Each one of them is browsing the store for about 12 minutes and then uses the fitting room exclusively for about three minutes, each following a normal distribution. A simulation of their fitting room experience is as follows:
| |
| | |
| Simulation '''Begin'''
| |
| '''Class''' FittingRoom; '''Begin'''
| |
| '''Ref''' (Head) door;
| |
| '''Boolean''' inUse;
| |
| '''Procedure''' request; '''Begin'''
| |
| '''If''' inUse '''Then''' '''Begin'''
| |
| Wait (door);
| |
| door.First.Out;
| |
| '''End''';
| |
| inUse:= '''True''';
| |
| '''End''';
| |
| '''Procedure''' leave; '''Begin'''
| |
| inUse:= '''False''';
| |
| '''Activate''' door.First;
| |
| '''End''';
| |
| door:- '''New''' Head;
| |
| '''End''';
| |
|
| |
| '''Procedure''' report (message); '''Text''' message; '''Begin'''
| |
| OutFix (Time, 2, 0); OutText (": " & message); OutImage;
| |
| '''End''';
| |
|
| |
| Process '''Class''' Person (pname); '''Text''' pname; '''Begin'''
| |
| '''While''' '''True''' '''Do''' '''Begin'''
| |
| Hold (Normal (12, 4, u));
| |
| report (pname & " is requesting the fitting room");
| |
| fittingroom1.request;
| |
| report (pname & " has entered the fitting room");
| |
| Hold (Normal (3, 1, u));
| |
| fittingroom1.leave;
| |
| report (pname & " has left the fitting room");
| |
| '''End''';
| |
| '''End''';
| |
|
| |
| '''Integer''' u;
| |
| '''Ref''' (FittingRoom) fittingRoom1;
| |
|
| |
| fittingRoom1:- '''New''' FittingRoom;
| |
| '''Activate''' '''New''' Person ("Sam");
| |
| '''Activate''' '''New''' Person ("Sally");
| |
| '''Activate''' '''New''' Person ("Andy");
| |
| Hold (100);
| |
| '''End''';
| |
| | |
| The main block is prefixed with <code>Simulation</code> for enabling simulation. The simulation package can be used on any block and simulations can even be nested when simulating someone doing simulations.
| |
| | |
| The fitting room object uses a queue (<code>door</code>) for getting access to the fitting room. When someone requests the fitting room and it's in use they must wait in this queue (<code>Wait (door)</code>). When someone leaves the fitting room the first one (if any) is released from the queue (<code>'''Activate''' door.first</code>) and accordingly removed from the door queue (<code>door.First.Out</code>).
| |
| | |
| Person is a subclass of Process and its activity is described using hold (time for browsing the store and time spent in the fitting room) and calls methods in the fitting room object for requesting and leaving the fitting room.
| |
| | |
| The main program creates all the objects and activates all the person objects to put them into the event queue. The main program holds for 100 minutes of simulated time before the program terminates.
| |
| | |
| == See also ==
| |
| * [[BETA (programming language)|BETA]], a modern successor to Simula
| |
| | |
| == Notes ==
| |
| {{Reflist|2}}
| |
| | |
| == Sources ==
| |
| * [http://www.edelweb.fr/Simula/ IBM System 360/370 Compiler and Historical Documentation] The Simula Standard and other historical documentation by Peter Sylvester
| |
| | |
| ==Further reading== | |
| * {{Citation
| |
| | last = Pooley
| |
| | first = Rob
| |
| | title = An Introduction to Programming in Simula
| |
| | url = http://www.macs.hw.ac.uk/~rjp/bookhtml/
| |
| | publisher=Alfred Waller Ltd
| |
| | year=1987
| |
| | isbn=0632016116
| |
| }}
| |
| | |
| == External links ==
| |
| * {{Citation
| |
| | contribution = SIMULA - SIMUlation LAnguage
| |
| | contribution-url = http://hopl.murdoch.edu.au/showlanguage.prx?exp=170
| |
| | title = The Encyclopedia of Computer Languages
| |
| | url = http://hopl.murdoch.edu.au/
| |
| }}
| |
| * {{Citation
| |
| | contribution = The SIMULA Compilerator
| |
| | contribution-url = http://vintagebigblue.org/Compilerator/SIMULA/simulaCompile.php
| |
| | title = An online SIMULA compiler for small experiments
| |
| | url = http://vintagebigblue.org/
| |
| }} - with source code example
| |
| * {{Citation
| |
| | contribution = Simon 75 - GPSS based Simula dialect
| |
| | contribution-url = http://hopl.murdoch.edu.au/showlanguage2.prx?exp=6562
| |
| | title = The Encyclopedia of Computer Languages
| |
| | url = http://hopl.murdoch.edu.au/
| |
| }} - with some notes on Demos by Graham Birtwistle
| |
| * {{Citation
| |
| | last = Sklenar
| |
| | first = J.
| |
| | publisher = University of Malta
| |
| | title = Introduction to OOP in Simula
| |
| | url = http://staff.um.edu.mt/jskl1/talk.html
| |
| }} - based on the 1997 seminar "30 Years of Object Oriented Programming (OOP)"
| |
| * {{Citation
| |
| | last = Vaucher
| |
| | first = Jean G.
| |
| | publisher = Université de Montréal
| |
| | title = DIRO Simula home
| |
| | url = http://www.iro.umontreal.ca/~simula/
| |
| }} - includes tutorials, documentation, and links in English and in French
| |
| | |
| [[Category:ALGOL 60 dialect]]
| |
| [[Category:Class-based programming languages]]
| |
| [[Category:Simulation programming languages]]
| |
| [[Category:Programming languages created in the 1960s]]
| |