In mathematics and theoretical physics, resummation is a procedure to obtain a finite result from a divergent sum (series) of functions. Resummation involves a definition of another (convergent) function in which the individual terms defining the original function are rescaled, and an integral transformation of this new function in order to obtain the original function. Borel resummation is probably the most well-known example.
In many legal systems, once a company becomes insolvent, the directors have to take particular care. Under UK law, trading while insolvent can trigger several provisions under the Insolvency Act 1986 which may have the effect of making directors of a company personally liable to contribute to the assets of a company.
The relevant provisions of the Insolvency Act 1986 include:
Under wrongful trading legislation in the UK, if the company continues to trade while it is insolvent the directors of the company may become personally liable to contribute to the company’s assets and help meet the deficit to unsecured creditors if the company’s financial position is made worse by the directors continuing to trade instead of putting the company immediately into liquidation.
In most legal systems, the liability in respect of other transactions only extends for a certain period of time prior to the company going into liquidation. In the UK, directors are exposed in respect of transaction at an undervalue, preferences, and extortionate credit transactions if the transaction occurred: a) while the company was insolvent; and b) within 2 years before the onset of liquidation if the transaction was with a connected person, and 6 months if the transaction was with an unconnected person.
Directors who continue to trade while insolvent may face disqualification under the Company Directors Disqualification Act 1986. Under the provision of this act, when a company goes into liquidation, the liquidator must make a report to the Disqualification Unit of the Department of Trade and Industry on the conduct of all directors. If the liquidator has come across conduct which makes the director unfit to be involved in the management of a company in the future (which things would include trading while insolvent) the DTI will apply to the Court for an order disqualifying the director or directors from acting as a company director for a certain period.
Many other countries have similar laws, often referred to as ‘insolvent trading’ or wrongful trading.
Algoma was a provincial electoral district in northern Ontario, Canada that elected one member to the Legislative Assembly of Ontario. It existed from 1867 to 1884, 1902 to 1934 and from 1967 to 1999. In 1999, the riding was abolished into Algoma—Manitoulin.
This riding elected the following members of the Legislative Assembly of Ontario:
In computer science, in the field of databases, Write-Read Conflict, also known as reading uncommitted data, is a computational anomaly associated with interleaved execution of transactions.
Given a schedule D
T1 & T2 \\
R(A) & \\
W(A) & \\
& R(A) \\ & W(A)\\ & R(B) \\ & W(B) \\ & Com. \\
R(B) & \\
W(B) & \\
Com. & \end{bmatrix}</math>
T2 could read a database object A, modified by T1 which hasn’t committed. This is a dirty read.
T1 may write some value into A which makes the database inconsistent. It is possible that interleaved execution can expose this inconsistency and lead to inconsistent final database state, violating ACID rules.
Strict 2PL overcomes this inconsistency by locking T2 out from performing a Read/Write on A. Note however that Strict 2PL can have a number of drawbacks, such as the possibility of deadlocks.
Molecular computers are massively parallel computers taking advantage of the computational power of molecules (specifically biological).
Molectronics specifically refers to the sub-field of physics which addresses the computational potential of atomic arrangements.
Goring Lock is a lock and weir situated on the River Thames at the Goring Gap in England. The lock is located between the twin villages of Goring-On-Thames, Oxfordshire, and Streatley, Berkshire, and is adjacent to Goring and Streatley Bridge. The lock is owned and managed by the Environment Agency.
The lock is situated almost under the bridge and is easily accessible from both Goring and Streatley
The reach is only just over half a mile long. The Thames Path crosses the bridge to Streatley and continues on the western bank to Cleeve Lock.
‘Chisholm High School (Founded in 1973) is the second largest high school in Enid, Oklahoma and is located in the northern part of the city.
With a student body of approximately 300 students in grades 9-12, Chisholm offeres a variety of normal and AP academic courses.
Chisholm also offers a variety of sports including football, basketball, baseball, softball, track and field, cross country, bowling, and cheerleading.
Chisholm holds a state championship banner for 1989 in Track and Field. The school’s predecessor “Carrier High School” holds a banner in Girls Basketball from 1970.
The school board members are:
The Priciple of the middle school is Shane Dent
Scot Trower is not the princeiple.
In business and contract law, a future-forward agreement (FFA) is a form of forward rate agreement in which party A agrees to lend party B the m1 amount of money, at future time t1. In return, B will pay to A a larger monetary amount m2 at time t2 > t1.
The name “future-forward agreement” derives from the fact that both issuing and repayment of the loan take place in the future. A regular forward rate agreement lends the money at once.
A quoted forward rate is associated with every future-forward agreement. This can be thought of as the interest rate earned by party A for lending the money to B.
John goes to his bank today. He agrees to take out a loan of $10,000 from the bank in one year’s time, and will pay back the loan with $10,800 in two years’ time. The forward rate would be ($10,800/$10,000)-1=8%.
A cyclin-dependent kinase complex (abbreviated cdkc, also called cyclin-CDK) is a protein complex formed by the association of cyclin with cyclin-dependent kinase. These complexes are able to phosphorylate other compounds under consumption of ATP, and are thereby involved in the regulation of the cell cycle. Depending on the type of cyclin attached to CDK, it has a different function. These serve as markers in each phase which are integral for the correct sequence of events, as well as facilitating the transition to the next phase.
There are three classes of cdkc depending on the phase of the cell cycle.
In computer science, corecursion is a type of operation that is dual to recursion. Corecursion is typically used (in conjunction with lazy evaluation) to generate infinite data structures.
The rule for primitive corecursion on codata is the dual to that for primitive recursion on data. Instead of descending on the argument, we ascend on the result. Notice that corecursion creates (potentially infinite) codata, whereas ordinary recursion analyses (necessarily finite) data. Ordinary recursion is not applicable to the codata because it might not terminate. Conversely, corecursion is not applicable if the result type is data, because data must be finite.
Here is an example in Haskell. The following definition produces the list of Fibonacci numbers in linear time:
fibs = 0 : 1 : zipWith (+) fibs (tail fibs)
The infinite list is produced by corecursion — the latter values of the list are computed on demand starting from the initial two items 0 and 1. This kind of definition is possible only because of lazy evaluation, which allows algorithms on parts of codata to terminate; such techniques are an important part of Haskell programming.
A Credit Memo (short for “credit memorandum”) is a commercial document issued by a seller to a buyer, indicating the products, quantities and agreed prices for products or services that the seller provided the buyer with, but the buyer returned or did not receive. It may also be issued in the case of damaged goods, errors or allowances. A Credit Memo can reduce or eliminate the amount that the buyer has to pay the seller in respect of the original invoice issued earlier.
The Credit Memo usually contains: PO #, Date, Billing Address, Shipping Address, Terms of Payment, List of products with quantites and prices. Usually it also references the original Invoice and sometimes it states the reason for issue.
Credit Memos are often called Credit Notes or just Credits.
The seller usually issues a Credit Memo for the same or lower amount than the invoice, and then repays the money to the buyer or sets it off against a balance due from other transactions.
The term may also refer to the document provided by a bank to a depositor to indicate that the depositor’s balance is being increased because of some event other than a deposit, such as the collection by the bank of the depositor’s note receivable.
In computing, code momentum is the situation where large amounts of code dependency are repeated in programming code creating a stubborn dependency. That is a sort of momentum. The more things are done one way, the more definitely you’re headed in that direction, and the harder it is to change course. Some claim that minimizing dependencies limits momentum and makes it easier to change course.
Code momentum is alleged to be an example of an anti-pattern.
However, coding to an API with multiple implementations to choose from is not necessarily harmful. For example, JDBC is the de-facto standard for communicating with relational databases in Java (when not using object-relational mapping). Although using JDBC creates a dependency on JDBC, that is not necessarily a big deal - as opposed to using some non-standard, vendor-specific extensions or SQL syntax, which does create a dependency on one database and makes it harder to shift.
Moreover, trying to reduce external dependencies too much may result in Not invented here syndrome, which can be counterproductive.
Adapt to adapt for an anti code momentum checklist.
“Days Go By” is a song by the band Dirty Vegas from their eponymous album. The song became a radio hit in 2002 and received the Grammy Award for Best Dance Recording. “Days Go By” received significant public exposure in a commercial for a Mistubishi car that year as a 2003 model. The music video for the song is unusual in that it largely consists of two dancers representing one character performing a routine of popping, locking, the robot and breakdancing in front of a restaurant in East Los Angeles, California. The video was also filmed there. The young dancer in the video is Garland Spencer.
ISAM stands for Indexed Sequential Access Method, a method for storing data for fast retrieval. ISAM was originally developed by IBM for mainframe computers and today forms the basic data store of almost all databases, both relational and otherwise.
In an ISAM system, data is organized into records which are composed of fixed length fields. Records are stored sequentially, originally to speed access on a tape system. A secondary set of hash tables known as indexes contain “pointers” into the tables, allowing individual records to be retrieved without having to search the entire data set. This is a departure from the contemporary navigational databases, in which the pointers to other data were stored inside the records themselves. The key improvement in ISAM is that the indexes are small and can be searched quickly, allowing the database to then access only the records it needs. Additionally modifications to the data do not require changes to other data, only the table and indexes in question.
Relational databases can be easily built on an ISAM framework with the addition of logic to maintain the validity of the links between the tables. Typically the field being used as the link, the foreign key, will be indexed for quick lookup. While this is slower than simply storing the pointer to the related data directly in the records, it also means that changes to the physical layout of the data do not require any updating of the pointers — the entry will still be valid.
ISAM is very simple to understand and implement, as it primarily consists of direct, sequential access to a database file. It is also very inexpensive. The tradeoff is that each client machine must manage its own connection to each file it accesses. This, in turn, leads to the possibility of conflicting inserts into those files, leading to an inconsistent database state. This is typically solved with the addition of a client-server framework which marshals client requests and maintains ordering. This is the basic concept behind a DBMS (Database Management System), which is a client layer over the underlying data store.
ISAM was replaced at IBM with a methodology called VSAM (Virtual Storage Access Method). Still later, IBM developed DB2, which, as of 2004, IBM promotes as their primary database management system. VSAM is the physical access method used in DB2.
MySQL implements and extends ISAM as MyISAM.
The RMS file system included with the OpenVMS operating system is one example of an ISAM file system. Borland Paradox is another.
Readspel is a new script or writing system invented by Kingsley Read. It is based on the Roman alphabet, but with new meanings for the letters, so that each symbol represents a distinct phoneme in the English language, and, more importantly, each phoneme in English can be represented with only one symbol. This allows English to be written with the following advantages:
The adoption of Readspel would constitute a spelling reform.
The Assyrian king Ashurbanipal claimed that he had been to Mount Nisir and saw the boat of Utnapishtim. His army and he then took artifacts from the boat and put them in his museum of ancient artifacts. However, this museum has long since been destroyed so archaeology doesn’t know how much truth there is in the story. Mount Nisir is supposedly in modern-day Iran.
The word nişir (spelled with a dot under the s) may have come from the Akkadian word nişirtu which, with reference to localities, had the “connotation of hidden, inaccessible, secluded” and also meant arcane and secret.Brinkman and others (editors), The Assyrian Dictionary, University of Chicago (1980), vol Š-2, page 22, upper left column. In other words, nişir could be descriptive, in addition to being a proper name. The partly translated sentence in line 141a of the Gilgamesh flood myth is “KUR-ú KUR ni-şir held tight the boat.” The first KUR is followed by a phonetic complement -ú which indicates that KUR-ú is to be read in Akkadian as šadú (hill). The second KUR without the complement is read mātu (country). Since šadú (sha-doo) can mean mountain as well as hill, and scholars were familiar with the expression Mount Ararat, it has become customary to translate “KUR-ú KUR ni-şir” as Mount Nisir or Mount Nimush.
This noun phrase was probably derived from an earlier Sumerian edition and was first written in clay about 2600 BC when the only written language was the Sumerian language. Therefore, we should read KUR as a Sumerian word, not as Akkadian. In Sumerian, KUR did not mean mountain. The Sumerian word for mountain was HURSAG. In Sumerian, KUR meant land, or hill, or country, especially a foreign country. Hence the sentence “KUR-ú KUR ni-şir held tight the boat” should be read as “A mound in an inaccessible country held the boat tight.”Robert M. Best, Noah’s Ark and the Ziusudra Epic (1999), page 277. A sand bar in a marsh would qualify.
Gilgamesh flood myth
In computer science, conservative two-phase locking (C2PL) is a locking method used in DBMS and relational databases.
Conservative 2PL prevents deadlocks.
The difference between 2PL and C2PL is that C2PL’s transactions obtain all the locks they need before the transactions begin. This is to ensure that a transaction that already holds some locks will not block waiting for other locks.
In heavy lock contention, C2PL reduces the time locks are held on average, relative to 2PL and Strict 2PL, because transactions that hold locks are never blocked.
In light lock contention, C2PL holds more locks than is necessary, because it is hard to tell what locks will be needed in the future, thus leads to higher overhead.
Also, a transaction will not even obtain any locks if it cannot obtain all the locks it needs in its initial request. Furthermore, each transaction needs to declare its read and write set (data items to be read/written during transaction), which is not always possible. Because of these limitations, C2PL is not used very frequently.
An Av drive is a hard disk drive which is designed specifically for audio and video purposes. They were used in the late 1990s for sustained media transfers: they delayed thermal recalibration so it would not interfeer with the transfer.
They are now obsolete, as normal hard drives are designed to handle realtime media through servo calibration to monitor head alignment and through the use of larger memory buffers.
In special relativity, the energy-momentum relation is a relation between the energy, momentum and the mass of a body:
where c is the speed of light, <math>E \;</math> is total energy, <math>m \;</math> is invariant mass, and <math>p\;</math> is momentum.
For a body in its rest frame, the momentum is zero, so the equation simplifies to
If the object is massless then the energy momentum relation reduces to
as is the case for a photon.
In natural units the energy-momentum relation can be expressed as
where <math>\omega \;</math> is angular frequency, <math>m \;</math> is rest mass and <math>k \;</math> is wave number.
In Minkowski space, energy and momentum (the latter multiplied by a factor of c) can be seen as two components of a Minkowski four-vector. The norm of this vector is equal to the square of the rest mass of the body, which is a Lorentz invariant quantity and hence is independent of the frame of reference.
When working in units where c = 1, known as the natural unit system, the energy-momentum equation reduces to
In particle physics, energy is typically given in units of electron volts (eV), momentum in units of eV/c, and mass in units of eV/c2. In electromagnetism, and because of relativistic invariance, it is useful to have the electric field E and the magnetic field B in the same unit (gauss), using the cgs (gaussian) system of units, where energy is given in units of erg, momentum in g.cm/s and mass in grams.
Energy may also in theory be expressed in units of grams, though in practice it requires a large amount of energy to be equivalent to masses in this range. For example, the first atomic bomb liberated about 1 gram of heat, and the largest thermonuclear bombs have generated a kilogram or more of heat. Energies of thermonuclear bombs are usually given in tens of kilotons and megatons referring to the energy liberated by exploding that amount of trinitrotoluene (TNT).
A chargeback occurs when a consumer requests a refund from their credit card company. The merchant is billed by its merchant bank, which has been billed initially by the card issuer. This may happen for a number of reasons, but is most often the result of fraud.
There are many different reasons why a merchant might receive a chargeback. Most are initiated by the cardholder, who may contact his card issuing bank regarding an inconsistency in his monthly credit card statement. This begins the dispute process that may eventually lead to a chargeback, and a reinstatement of credit to the cardholder’s account.
One of the most common reasons for a chargeback is known as a fraudulent transaction. A credit card is used without the consent or proper authorization of the card holder. In most cases, a merchant is responsible for charges fraudulently imposed on a customer.
Chargebacks are often the result of a customer dispute over credit. This type of chargeback is usually described as credit not processed. A customer may have returned merchandise to a merchant in return for credit, but credit was never posted to the account. In this example, the merchant is responsible for issuing credit to its customer, and would be charged back.
Other types of chargebacks are related to technical problems between the merchant and the issuing bank, whereby a customer was charged twice for a single transaction (duplicate processing) or other various mistakes. Yet other chargebacks are related to the authorization process of a credit card transaction, for example, if a transaction is declined by its issuing bank and the account is still charged.
Another reason for chargebacks are when a customer does not receive the item they paid for. In this case, a chargeback is initiated and the payment to the merchant is reversed.
List of reasons for a chargeback:
A merchant is billed for chargebacks as they occur, along with other fees and settlements associated with credit card acceptance. Because a merchant may be charged back in error, and because chargebacks may often involve complicated customer disputes, a chargeback may be appealed by the merchant. This process varies by credit card. If the chargeback is found to have been in error, a merchant will be granted a reversal.
Thieves occasionally abuse the chargeback system. For example, in a “Friendly Fraud”, an unscrupulous customer will make a purchase over the Internet with his own credit card and then issue a chargeback once the product or service is received. In such cases merchants can have difficulty recovering payment.
Chargeback processing (handling) is complex as a result of frequent rule changes by the major credit card companies (MasterCard, Visa, American Express, etc.). There is an emerging market for business software that simplifies the chargeback process as well as separate chargeback processing services.
A combination tone, also called a sum tone or a difference tone, can be any of at least three similar psychoacoustic phenomena. When two tones are played simultaneously, a listener can sometimes perceive an additional tone whose frequency is a sum or difference of the two frequencies. The discovery of one of these phenomena is credited to the violinist Giuseppe Tartini, and so the tones are also called Tartini tones.
One way a difference tone can be heard is when two tones with fairly complete sets of harmonics make a just fifth. This can be explained as an example of the missing fundamental phenomena (Beament 2001). If <math>f</math> is the missing fundamental frequency, then <math>2f</math> would be the frequency of the lower tone, and its harmonics would be <math>4f, 6f, 8f,</math> etc. Since a fifth corresponds to a frequency ratio of 2:3, the higher tone and its harmonics would then be <math>3f, 6f, 9f,</math> etc. When both tones are sounded, there are components with frequencies of <math>2f, 3f, 4f, 6f, 8f, 9f,</math> etc. The missing fundamental is heard because so many of these components refer to it.
The specific phenomenon that Tartini discovered was physical. Sum and difference tones are thought to be caused sometimes by the non-linearity of the inner ear. This causes intermodulation distortion of the various frequencies which enter the ear. They are combined linearly, generating relatively faint components with frequencies equal to the sums and differences of whole multiples of the original frequencies. Any components which are heard are usually lower, with the most commonly heard frequency being just the difference tone, <math>f_2-f_1</math>, though this may be a consequence of the other phenomena. Although much less common, the following frequencies may also be heard:
Beament, James. How We Hear Music, The Boydell Press, 2001. ISBN 0-85115-813-7
Component Object Model (COM) is a platform for software componentry introduced by Microsoft in 1993. It is used to enable interprocess communication and dynamic object creation in any programming language that supports the technology. The term COM is often used in the software development world as an umbrella term that encompasses the OLE, OLE Automation, ActiveX, [[#COM+|COM+]] and DCOM technologies. Although COM was introduced in 1993, Microsoft did not begin emphasizing the name COM until 1997.
The essence of COM is a language-neutral way of implementing objects such that they can be used in environments different from the one they were created in, even across machine boundaries. For well-authored components, COM allows reuse of objects with no knowledge of their internal implementation because it forces component implementers to provide well-defined interfaces that are separate from the implementation. The different allocation semantics of languages are accommodated by making objects responsible for their own creation and destruction through reference-counting. Casting between different interfaces of an object is achieved through the QueryInterface() function. The preferred method of inheritance within COM is the creation of sub-objects to which method calls are delegated.
Although it has been implemented on several platforms, COM is primarily used with Microsoft Windows. COM is expected to be replaced to at least some extent by the Microsoft .NET framework, and support for Web Services through the Windows Communication Foundation (WCF). However, COM objects can still be used with all .NET languages without problems. Networked DCOM uses binary proprietary formats, while WCF encourages the use of XML-based SOAP messaging. COM also competes with CORBA and Java Beans as component software systems.
One of the first methods of interprocess communication in Windows was DDE which allowed sending and receiving messages in so-called “conversations” between applications. This technology was the base of OLE (Object Linking and Embedding) which in turn was one of the leading technologies introduced with Windows 3.0. Text conversations and Windows messages proved not to be as flexible as to allow sharing application features in a robust and extensible way. By the time version 3.1 of Windows was released, COM was created as a new foundation and OLE changed to OLE2.
Visual Basic introduced the VBX (packaged extensions in the form of dynamically linked libraries) which allowed the creation of objects to be graphically placed in a form and manipulated by properties and methods. These were later adapted for use by other languages such as [[Visual C++]]. OLE custom controls (OCXs) would be the replacement for the widely popular VBX.
Antony Williams, one of the more notable thinkers involved in the creation of the COM architecture, distributed a couple of internal papers in Microsoft that embraced the concept of software components; Object Architecture: Dealing With the Unknown – or – Type Safety in a Dynamically Extensible Class Library in 1988 and On Inheritance: What It Means and How To Use It in 1990. These provided the foundation of many, if not all, of the ideas behind the basics of COM.
From many of these ideas spawned Microsoft’s first object-based framework, OLE, which is short for Object Linking and Embedding. OLE was built on top of dynamic data exchange (DDE) and designed specifically for compound documents. It was introduced with Word for Windows and Excel in 1991, and was later included with Windows, starting with version 3.1 in 1992.
An example of a compound document is a spreadsheet embedded in a Word for Windows document; as changes are made to the spreadsheet within Excel, they appear automatically inside the Word document.
In 1991, Microsoft introduced Visual Basic Extensions (VBX) with Visual Basic 1.0.
In 1993, Microsoft released OLE 2 with underlying object model. While OLE 1 was focused on compound documents, COM and OLE 2 were designed to address software components in general. In 1994 OLE controls (OCX) were introduced as the successor to VBX controls. At the same time, Microsoft stated that OLE 2 would just be known as “OLE”, and that OLE was no longer an acronym, but a name for all of the company’s component technologies.
In early 1996, Microsoft found a new use for OLE Custom Controls, expanding their Web browser’s capability to present content, renamed some parts of OLE relating to the Internet ActiveX, and gradually renamed all OLE technologies to ActiveX, except the compound document technology that was used in Microsoft Office. Later that year, DCOM was introduced as an answer to CORBA.
COM was the major software development platform for Windows and, as such, influenced development of a number of supporting technologies.
In order to provide developers with support for distributed transactions, resource pooling, disconnected applications, event publication and subscription, better memory and processor (threads) management, as well as to position Windows as an alternative to other enterprise-level operating systems, Microsoft introduced a technology called Microsoft Transaction Server on Windows NT Service Pack 4.
With Windows 2000, that significant extension to COM was incorporated into the operating system (as opposed to the series of external tools provided by MTS) and renamed COM+. At the same time, Microsoft deemphasized DCOM as a separate entity. Transactional COM components were then handled more directly by the added layer of COM+. COM+ components were then added through the Component Services application interface.
An advantage of COM+ was that it could be run in “component farms”. A component, if coded properly, could be reused by new calls to its initializing routine without unloading it from memory. Components could also be distributed (called from another machine) as was previously only possible with DCOM.
COM+ also introduced a subscriber/publisher event mechanism called COM+ Events, and provided a new way of leveraging MSMQ (inter-application asynchronous messaging) with components called Queued Components. COM+ events extend the COM+ programming model to support late-bound events or method calls between the publisher or subscriber and the event system.
The COM platform has largely been superseded by the Microsoft .NET initiative, and Microsoft now focuses its marketing efforts on .NET. COM was often used to hook up complex, high performance code to front end code implemented in Visual Basic or ASP.
To some extent, COM is now deprecated in favor of .NET. Since .NET provides rapid development tools similar to Visual Basic for both Windows Forms and Web Forms with just-in-time compilation, back-end code can be implemented in any .NET Language including C#, Visual Basic and [[C++]].
Despite this, COM remains a viable technology with an important software base. As of this writing, Microsoft has no plans for discontinuing either COM or support for COM. COM is also ideal for script control of applications such as Office or Internet Explorer since it provides an interface for calling COM object methods from a script rather than requiring knowing the API at compile time. The GUID system developed for COM has wide uses any time a unique ID is needed.
Several of the services that COM+ provides, such as transactions and queued components, are still important for enterprise .NET applications.
There is limited support for backward compatibility. A COM object may be used in .NET by implementing a runtime callable wrapper (RCW). [1] .NET objects that conform to certain interface restrictions may be used in COM objects by calling a COM callable wrapper (CCW). [2] From both the COM and .NET sides, objects using the other technology appear as native objects.
.NET’s remoting model solves a number of COM’s remote execution shortcomings, allowing objects to be transparently marshalled by reference or value across process or machine boundaries.
Microsoft’s idea of embedding active content on web pages as COM/ActiveX components (rather than e.g. Java applets) created a combination of problems in the Internet Explorer web browser that has led to an explosion of computer virus, trojan and spyware infections. These malware attacks mostly depend on ActiveX for their activation and propagation to other computers. Microsoft recognized the problem with ActiveX as far back as 1996 when Charles Fitzgerald, program manager of Microsoft’s Java team said “If you want security on the ‘Net’, unplug your computer. … We never made the claim up front that ActiveX is intrinsically secure.” [3]
As COM and ActiveX components are run as native code on the user’s machine, there are fewer restrictions on what the code can do. Many of these problems have been addressed by the introduction of “code Signing” (based on digital signatures), and later by the .NET platform as well. Also, before an ActiveX control is installed, the user is prompted whether to allow the installation or not, enabling the user to disallow the installation of controls from sites that the user doesn’t trust. Additionally, it is possible to disable ActiveX controls altogether, or to only allow a selected few.
COM programmers build their software using COM-aware components. Different component types are identified by class IDs (CLSIDs), which are Globally Unique Identifiers, or GUIDs. Each COM component exposes its functionality through one or more interfaces. The different interfaces supported by a component are distinguished from each other using interface IDs (IIDs), which are also GUIDs.
COM interfaces have bindings in several languages, such as C, [[C++]], Visual Basic, and several of the scripting languages implemented on the Windows platform. All access to components is done through the methods of the interfaces. This allows techniques such as inter-process, or even inter-computer programming (the latter using the support of DCOM).
All COM components must (at the very least) implement the standard IUnknown interface, and thus all COM interfaces are derived from IUnknown. The IUnknown interface consists of three methods: AddRef() and Release(), which implement reference counting and controls the lifetime of interfaces; and QueryInterface(), which by specifying an IID allows a caller to retrieve references to the different interfaces the component implements. The effect of QueryInterface() is similar to dynamic_cast<> in [[C++]] or casts in Java and C#.
A COM component’s interfaces are required to exhibit the reflexive, symmetric, and transitive properties. The reflexive property refers to the ability for the QueryInterface() call on a given interface with the interface’s ID to return the same instance of the interface. The symmetric property requires that when interface B is retrieved from interface A via QueryInterface(), interface A is retrievable from interface B as well. The transitive property is similar to the symmetric property, but requires that if interface B is obtainable from interface A and interface C is obtainable from interface B, then interface C should be retrievable from interface A.
An interface consists of a pointer to a virtual function table that contains a list of pointers to the functions that implement the functions declared in the interface, in the same order that they are declared in the interface. This technique of passing structures of function pointers is very similar to the one used by OLE 1.0 to communicate with its system libraries.
COM specifies many other standard interfaces used to allow inter-component communication. For example, one such interface is IStream, which is exposed by components that have data stream semantics (e.g. a FileStream component used to read or write files). It has the expected Read and Write methods to perform stream reads and writes. Another standard interface is IOleObject, which is exposed by components that expect to be linked or embedded into a container. IOleObject contains methods that allow callers to determine the size of the component’s bounding rectangle, whether the component supports operations like ‘Open’, ‘Save’ and so on.
A class in COM is referred to as a coclass which is the contracted form of Component Object class. A coclass is COM’s language-independent way of defining a class in the object-oriented sense.
A coclass supplies concrete implementation(s) of one or more interfaces. In COM, such concrete implementations can be written in any programming language that supports COM component development, e.g. C++, Visual Basic, etc.
One of COM’s major contributions to the world of Windows development is the awareness of the concept of separation of interface from implementation. This awareness has no doubt influenced the way programmers build systems today. An extension of this fundamental concept is the notion of one interface, multiple implementations. This means that at runtime, an application can choose to instantiate an interface from one of many different concrete implementations.
Type libraries contain metadata that represent COM types. However, these types must first be described using Microsoft Interface Definition Language.
This is the common practice in the development of a COM component, i.e. to start with the definition of types using IDL. An IDL file is what COM provides that allows developers to define object-oriented classes, interfaces, structures, enumerations and other user-defined types in a language independent manner. COM IDL is similar in appearance to C/C++ declarations with the addition of keywords such as “interface” and “library” for defining interfaces and collections of classes, respectively. IDL also requires the use of bracketed attributes before declarations to provide additional information, such as the GUIDs of interfaces and the relationships between pointer parameters and length fields.
The IDL file is compiled by the MIDL compiler into a pair of forms for consumption from various languages. For C/C++, the MIDL compiler generates a compiler-independent header file containing struct definitions to match the vtbls of the declared interfaces and a C file containing declarations of the interface GUIDs. C++ source code for a proxy module can also be generated by the MIDL compiler. This proxy contains method stubs for converting COM calls into Remote Procedure Calls, thus enabling DCOM.
An IDL file may also be compiled by the MIDL compiler into a type library (.TLB file). The binary metadata contained within the type library is meant to be processed by language compilers and runtime environments (e.g. VB, Delphi, the .NET CLR etc). The end result of such TLB processing is that language-specific constructs are produced that represent the COM class defined in the .TLB (and ultimately that which was defined in the originating IDL file).
The fundamental principles of COM have their roots in Object-Oriented philosophies. It is a platform for the realization of Object-Oriented Development and Deployment.
Because COM is a runtime framework, types have to be individually identifiable and specifiable at runtime. To achieve this, globally unique identifiers (GUIDs) are used. Each COM type is designated its own GUID for identification at runtime (vis compile time).
In order that information on COM types be accessible at both compile time and runtime, COM presents the type library. It is through the effective use of type libraries that COM achieves its capabilities as a dynamic framework for the interaction of objects.
Consider the following example coclass definition in an IDL :
coclass MyObject
{
[default] interface IMyObject;
[default, source] dispinterface _IMyObjectEvents;
};
The above code fragment declares a COM class named MyObject which must implement an interface named IMyObject and which supports (not implements) the event interface _IMyObjectEvents.
Ignoring the event interface bit, this is conceptually equivalent to defining a C++ class like this :
class CSomeObject : public ISomeInterface
{
...
...
...
};
where ISomeInterface is a C++ pure virtual class.
Referring once again to the MyObject COM class: once a coclass definition for it has been formalized in an IDL, and a Type Library compiled from it, the onus is on the individual language compiler to read and appropriately interpret this Type Library and then produce whatever code (in the specific compiler’s language) necessary for a developer to implement and ultimately produce the binary executable code which can be deemed by COM to be of coclass MyObject.
Once an implementation of a COM coclass is built and is available in the system, next comes the question of how to instantiate it. Now, in languages like C++, we can use the CoCreateInstance() API in which we specify the CLSID (CLSID_MyObject) of the coclass as well as the interface (specified by the IID IID_IMyObject) from that coclass that we want to use to interact with that coclass. Calling CoCreateInstance() like this:
CoCreateInstance ( CLSID_MyObject, NULL, CLSCTX_INPROC_SERVER, IID_IMyObject, (void**)&m_pIMyObject );
is conceptually equivalent to the following C++ code :
ISomeInterface* pISomeInterface = new CSomeObject();
In the first case, we are saying to the COM sub-system that we want to obtain a pointer to an object that implements the IMyObject interface and we want coclass CLSID_MyObject’s particular implementation of this interface. In the second case, we are saying that we want to create an instance of a C++ class that implements the interface ISomeInterface and we are using CSomeObject as that C++ class.
A coclass, then, is an object-oriented class in the COM world. The main feature of the coclass is that it is (1) binary in nature and consequently (2) programming language-independent.
In Windows, COM classes, interfaces and type libraries are listed by GUIDs in the registry, under HKEY_CLASSES_ROOT\CLSID for classes and HKEY_CLASSES_ROOT\interface for interfaces. The COM libraries use the registry to locate either the correct local libraries for each COM object or the network location for a remote service.
The most fundamental COM interface of all, i.e. IUnknown (from which all COM interfaces must be derived), supports two main concepts: feature exploration through the QueryInterface method, and object lifetime management by including AddRef() and Release(). Reference counts and feature exploration apply to objects (not to each interface on an object) and thus must have a centralized implementation.
The COM specifications require a technique called reference counting to ensure that individual objects remain alive as long as there are clients which have acquired access to one or more of its interfaces and, conversely, that the same object is properly disposed of when all code that used the object have finished with it and no longer require it. A COM object is responsible for freeing its own memory once its reference count drops to zero.
For its implementation, a COM Object usually maintains an integer value that is used for reference counting. When AddRef() is called via any of object’s interfaces, this integer value gets incremented. When Release() is called, this integer gets decremented. AddRef() and Release() are the only means by which a client of a COM object is able to influence its lifetime. The internal integer value remains a private member of the COM object and will never be directly accessible.
The purpose of AddRef() is to indicate to the COM object that an additional reference to itself has been affected and hence it is necessary to remain alive as long as this reference is still valid. Conversely, the purpose of Release() is to indicate to the COM object that a client (or a part of the client’s code) has no further need for it and hence if this reference count has dropped to zero, it may be time to destroy itself.
Certain languages (e.g. Visual Basic) provide automatic reference counting so that COM object developers need not explicitly maintain any internal reference counter in their source codes. Using COM in C language, explicit reference counting is needed. In C++ you can do it by yourself or choose to use a smart pointer that will manage all the reference counting for you.
The following is a general guideline calling AddRef() and Release() to facilitate proper reference counting in COM object :
To facilitate and promote COM development, Microsoft introduced ATL (Active Template Library) for C++ developers. ATL provides for a higher-level COM development paradigm. It also shields COM client application developers from the need to directly maintain reference counting by providing smart pointer objects.
Other libraries and languages that are COM-aware include the Microsoft Foundation Classes, VBScript, Visual Basic, ECMAScript (JavaScript) and Borland Delphi.
COM standardizes the instantiation (i.e. creation) process of COM objects by requiring the use of Class Factories. In order for a COM object to be created, two associated items must exist :
Each COM Class or CoClass must be associated with a unique Class ID (a GUID). It must also be associated with its own Class Factory (that is achieved by using a centralized registry). A Class Factory is itself a COM object. It is an object that must expose the IClassFactory or IClassFactory2 (the latter with licensing support) interface. The responsibility of such an object is to create other objects.
A class factory object is usually contained within the same executable code (i.e. the server code) as the COM object itself. When a class factory is called upon to create a target object, this target object’s class id must be provided. This is how the class factory knows which class of object to instantiate.
A single class factory object may create objects of more than one class. That is, two objects of different class ids may be created by the same class factory object. However, this is transparent to the COM system.
By delegating the responsibility of object creation into a separate object, a greater level of abstraction is promoted, and the developer is given greater flexibility. For example, implementation of the Singleton and other creation patterns is facilitated. Also, the calling application is shielded from the COM object’s memory allocation semantics by the factory object.
In order for client applications to be able to acquire class factory objects, COM servers must properly expose them. A class factory is exposed differently, depending on the nature of the server code. A server which is DLL-based must export a DllGetClassObject() global function. A server which is EXE-based registers the class factory at runtime via the CoRegisterClassObject() Windows API function.
The following is a general outline of the sequence of object creation via its class factory :
IClassFactory* pIClassFactory = NULL; CoGetClassObject ( CLSID_SomeObject, CLSCTX_ALL, NULL, IID_IClassFactory, (LPVOID*)&pIClassFactory );
The above code indicates that the Class Factory object of a COM object, which is identified by the class id CLSID_SomeObject, is required. This class factory object is returned by way of its IClassFactory interface.
ISomeObject* pISomeObject = NULL;
if (pIClassFactory)
{
pIClassFactory -> CreateInstance
(
NULL,
IID_ISomeObject,
(LPVOID*)&pISomeObject
);
pIClassFactory -> Release();
pIClassFactory = NULL;
}
The above code indicates the use of the Class Factory object’s CreateInstance() method to create an object which exposes an interface identified by the IID_ISomeObject GUID. A pointer to the ISomeObject interface of this object is returned. Also note that because the class factory object is itself a COM object, it needs to be released when it is no longer required (i.e. its Release() method must be called).
The above demonstrates, at the most basic level, the use of a class factory to instantiate an object. Higher level constructs are also available, some of which do not even involve direct use of the Windows APIs.
For example, the CoCreateInstance() API can be used by an application to directly create a COM object without acquiring the object’s class factory. However, internally, the CoCreateInstance() API itself will invoke the CoGetClassObject() API to obtain the object’s class factory and then use the class factory’s CreateInstance() method to create the COM object.
VBScript supplies the New keyword as well as the CreateObject() global function for object instantiation. These language constructs encapsulate the acquisition of the class factory object of the target object (via the CoGetClassObject() API) followed by the invocation of the IClassFactory::CreateInstance() method.
Other languages, e.g. PowerBuilder’s PowerScript may also provide their own high-level object creation constructs. However, CoGetClassObject() and the IClassFactory interface remain the most fundamental object creation technique.
At the time of the inception of COM technologies, the only way for a client to find out what features an object would offer, was to actually create one instance and call into its QueryInterface method (part of the required IUnknown interface).
This way of exploration became awkward for many applications, including the selection of appropriate components for a certain task, and tools to help a developer understand how to use methods provided by an object.
As a result, COM Type Libraries were introduced, through which components can describe themselves. A type library contains information such as the CLSID of a component, the IIDs of the interfaces the component implements, and descriptions of each of the methods of those interfaces. Type libraries are typically used by RAD environments such as Visual Basic or Visual Studio to assist developers of client applications.
COM is a binary standard (also said to be language agnostic) and may be developed in any programming language capable of understanding and implementing its binary defined data types and interfaces.
Runtime libraries (in extreme situations, the programmers) are responsible for entering and leaving the COM environment, instantiating and reference counting COM objects, querying objects for version information, coding to take advantage of advanced object versions, and coding graceful degradation of function when newer versions aren’t available.
COM objects may be instantiated and referenced from within a process, across process boundaries within a computer, and across a network, using the DCOM technology. Out-of-process and remote objects may use marshalling to send method calls and return values back and forth. The marshalling is invisible to the object and the code using the object.
In COM, threading issues are addressed by a concept known as “apartment models“. Here the term “apartment” refers to an execution context wherein a single thread or a group of threads is associated with one or more COM objects.
Apartments stipulate the following general guidelines for participating threads and objects:
There are three types of Apartment Models in the COM world: Single-Threaded Apartment (STA), Multi-Threaded Apartment (MTA), and Neutral Apartment. Each apartment represents one mechanism whereby an object’s internal state may be synchronized across multiple threads.
The Single-Threaded Apartment (STA) model is a very commonly used model. Here, a COM object stands in a position similar to a desktop application’s user interface. In an STA model, a single thread is dedicated to drive an object’s methods, i.e. a single thread is always used to execute the methods of the object. In such an arrangement, method calls from threads outside of the apartment are marshalled and automatically queued by the system (via a standard Windows message queue). Thus, there is no worry about race conditions or lack of synchronicity because each method call of an object is always executed to completion before another is invoked.
If the COM object’s methods perform their own synchronization, multiple threads dedicated to calling methods on the COM object are permitted. This is termed the Multiple Threaded Apartment (MTA). Calls to an MTA object from a thread in an STA are also marshaled. A process can consist of multiple COM objects, some of which may use STA and others of which may use MTA. The Thread Neutral Apartment allows different threads, none of which is necessarily dedicated to calling methods on the object, to make such calls. The only proviso is that all methods on the object must be serially reentrant.
Since COM has a fairly complex implementation, programmers can be distracted by some of the “plumbing” issues.
When an STA is initialized it creates a hidden window that is used for inter-apartment and inter-process message routing. This window must have its message queue regularly pumped. This construct is known as a message pump. On earlier versions of Windows failure to do so could cause system-wide deadlocks. This problem is especially nasty because some Windows APIs initialize COM as part of their implementation, which causes a leak of implementation details.
Reference counting within COM may cause problems if two or more objects are circularly referenced. The design of an application must take this into account so that objects are not left orphaned.
Objects may also be left with active reference counts if the COM “event sink” model is used. Since the object that fires the event needs a reference to the object reacting to the event, the object’s reference count will never reach zero.
Reference cycles are typically broken using either out-of-band termination or split identities. In the out of band termination technique, an object exposes a method which, when called, forces it to drop its references to other objects, thereby breaking the cycle. In the split identity technique, a single implementation exposes two separate COM objects (also known as identities). This creates a weak reference between the COM objects, preventing a reference cycle.
Because the location of each component is stored in a system-wide location (the Windows registry), there can be only one version of a certain component installed. Thus, COM seriously suffers from DLL hell, where two or more applications require different versions of the same component.
Windows XP introduced a new mode of COM object registration called “Registration-free COM“. This facility makes it possible for applications that need to install COM objects to store all the required COM registry information in the application’s directory, instead of in the global registry, where, strictly speaking only a single application will ever use it. DLL hell can be substantially avoided using Registration-free COM, the only limitation being it requires at least Windows XP or later Windows versions and that it must not be used for EXE COM servers or system-wide components such as MDAC, MSXML, DirectX or Internet Explorer.
Trouble Every Day is the name of Tindersticks’ soundtrack to French director Claire Denis’s 2001 film Trouble Every Day.
The Light of Day or Light of Day may refer to:
A Q’re perpetuum or standing Q’re is a technical orthographic device to indicate the pronunciation of certain words in the masoretic text of the Hebrew Bible (Tanakh). The masoretes inherited a form of the Biblical text written in the consonantal letters of the Hebrew alphabet (with only a very limited and ambiguous indication of vowels by means of matres lectionis), and never altered this basic consonantal text when they annotated it with the written vowel diacritic symbols which they invented. However, sometimes the masoretes preferred a different reading of a word than that found in the pre-masoretic consonantal text. In this case, they wrote the vowel diacritics of their preferred reading in the main text (added around the consonantal letters of the masoretically-disapproved variant), with a special sign indicating that there was a marginal note for this word. In the margins there would be a note indicating the consonant letters of the preferred masoretic reading. Here the preferred masoretic reading is known as the Q’re (Aramaic קרי “to be read”), while the pre-masoretic consonantal spelling is known as the Ketibh (Aramaic כתיב “to be written”). In such cases, the vowel points of the Q’re were separated from the consonant letters of the Q’re — but they were meant to be read together (even though the vowel points of the Q’re are located on the consonant letters of Ketibh).
A “perpetual” Q’re differs from an ordinary Q’re in that there is no note marker and no accompanying marginal note — these are certain commonly-occurring cases of Q’re/Ketibh in which the reader is expected to understand that a Q’re exists merely from seeing the vowel points of the Q’re in the consonantal letters of the Ketibh.
For example, in the Pentateuch, the third-person singular feminine pronoun היא hī is usually spelled the same as the third-person singular masculine pronoun הוא hū. The masoretes indicated this situation by adding a written diacritic symbol for the vowel [i] to the pre-masoretic consonantal spelling h-w-’ הוא (see diagram). The resulting orthography would seem to indicate a pronunciation hiw, but this is meaningless in Biblical Hebrew, and a knowledgeable reader of the Biblical text would know to read the feminine pronoun hī here.
Many scholars hold the view that “Yehowah” (or in Latin transcription “Jehovah”) is a pseudo-Hebrew form which was mistakenly created when Medieval and/or Renaissance Christian scholars misunderstood the common Q’re perpetuum of the partial vowel points of Adonai written together with the consonants of the Tetragrammaton YHWH (in order to indicate that written YHWH should be pronounced aloud as “Adonai”, as was the usual Jewish practice at the time of the Masoretes). This would be a mistake of exactly the same type as reading hiw for the Q’re perpetuum of the third-person singular feminine pronoun.
In sports such as ice hockey and football (soccer), goal difference (that is, goals scored minus goals conceded) is often the first tiebreaker used to rank teams which finish a league competition with an equal number of points.
If a team’s points and goal difference are equal, then often goals scored is used as a second tiebreaker, with the team scoring the most goals winning. Alternative tiebreakers that may be used include looking at the head-to-head results between sides, playing a playoff, or the drawing of lots.
Goal average is a different scheme that predated goal difference. Using the goal average scheme the number of goals scored is divided by the number of goals conceded. Goal difference replaced goal average in the 1970 World Cup finals and from 1976-1977 season in the English Football League. Goal average is also used as the tiebreaker in Australian rules football where it is referred to as “percentage”. It is calculated as points scored for divided by points scored against multiplied by 100.
The different schemas can lead to strikingly different results. Consider the result of the following matches:
Under goal average, Team A would triumph:
| Team | Pts | Pld | W | D | L | F | A | GA |
|---|---|---|---|---|---|---|---|---|
| Team A | 3 | 2 | 1 | 0 | 1 | 3 | 1 | 3 |
| Team B | 3 | 2 | 1 | 0 | 1 | 6 | 3 | 2 |
| Team C | 3 | 2 | 1 | 0 | 1 | 1 | 6 | 0.1667 |
However, under goal difference, Team B would triumph:
| Team | Pts | Pld | W | D | L | F | A | GD |
|---|---|---|---|---|---|---|---|---|
| Team B | 3 | 2 | 1 | 0 | 1 | 6 | 3 | +3 |
| Team A | 3 | 2 | 1 | 0 | 1 | 3 | 1 | +2 |
| Team C | 3 | 2 | 1 | 0 | 1 | 1 | 6 | -5 |
Goal average was replaced by goal difference due to the former’s encouragement of lower-scoring games. A team that scores 70 while allowing 40 would have a lesser goal average (1.750) versus another team that scores 69 while allowing 39 (1.769). In the most extreme case, a team that drew every game but one with a 0-0 scoreline but won the remaining game 1-0 would have an infinitely large goal average, defeating on tiebreaker a team that drew every game but one with a 0-0 scoreline, but won the remaining game 100-1 (as this team’s goal average would be ‘only’ 100).
It’s notable, though that teams who’ve scored fewer than they’ve conceded can improve their goal average with a score draw. For example, a team with 15 for and 30 against has a goal difference of 0.5, but a 2-2 draw would increase their goal average to 0.53.
Arsenal Football Club famously won on goals scored in the English Football League season of 1988-1989, with a 2-0 victory over Liverpool FC on the last day of the season, the second and decisive goal being scored in injury time. Arsenal and Liverpool finished equal on points and goal difference, but with Arsenal ahead 73 to 65 on goals scored.
Had the league still been decided on goal average, Liverpool would have been the winners 2.321 to 2.028.
Luxembourgish (, , , ), also spelled Luxemburgish, is a West Germanic language spoken in Luxembourg. It was proclaimed one of the three official languages of Luxembourg in 1984 (along with French and German for judicial and administrative purposes).Mémorial A no. 16 (27 February 1984), pp. 196–197: “Loi du 24 février 1984 sur le régime des langues”.
There are about 300,000 people who speak Luxembourgish worldwide.
Luxembourgish belongs to the West Central German group of High German languages, and is the primary example of a Moselle Franconian language.
Luxembourgish is also spoken in small parts of the surrounding countries of Belgium (in the Province of Luxembourg near Arlon), France (in small parts of the Lorraine) and Germany (around Bitburg and Trier). In Germany and Lorraine it is simply considered as the local German dialect. Since the Second World War, however, the language has not been taught in these countries, with the result that use of Luxembourgish is largely restricted to the older generations.
Furthermore, the language is spoken by a few descendants of Luxembourg immigrants in the United States, and a closely related variety is spoken by emigrants to Transylvania, Romania (Siebenbürgen).
There are several distinct dialect forms of Luxembourgish including Areler (from Arlon), Eechternoacher (Echternach), Kliärrwer (Clervaux), Minetter, Miseler (Moselle), Stater (Luxembourg city), Veiner (Vianden) and Weelzer (Wiltz). Further small vocabulary differences may be seen even between small villages.
Increasing mobility of the population and the dissemination of the language through mass media such as radio and television are leading to a gradual standardisation towards a “Standard Luxembourgish” which has been labelled koine.
There is no distinct geographic boundary between the use of Luxembourgish and the use of other closely related High German dialects (for example Lorraine Franconian); it instead forms a dialect continuum of gradual change.
Spoken Luxembourgish is relatively hard to understand for speakers of German who are not familiar with Moselle Franconian dialects, though they can usually read the language. For Germans who are familiar with Moselle Franconian dialects, it is relatively easy to understand Luxembourgish, but more difficult to speak it properly because of the French influence. Even literary German, as it is written in Luxembourg, tends to include many French words and phrases.
There is no mutual intelligibility between Luxembourgish and French or any of the Romance dialects spoken in the adjacent parts of Belgium and France.
A number of proposals for standardising the orthography of Luxembourgish can be documented, going back to the middle of the 19th century. There was no officially recognised system, however, until the adoption of the “OLO” (ofizjel lezebuurjer ortografi) on 5 June 1946.[1] Mémorial A no. 40 (7 September 1946), pp. 637–641: “Arrêté ministériel du 5 juin 1946 portant fixation d’un système officiel d’orthographe luxembourgeois”. The proponents of this orthography were less interested in imposing a standardised spelling for the language than in providing a system for speakers of all varieties of Luxembourgish to transcribe words the way they pronounced them. Furthermore, the rules were evidently designed so that these phonetic transcriptions would resemble the corresponding German (or French) words as little as possible. For example:
The political motivations behind certain decisions (e.g., never to use “ö” and “ä”, or not to capitalise nouns as in German) are easy to imagine, but this proposed orthography was a failure precisely because it distanced itself so drastically from existing “foreign” standards that people were already familiar with.
A more successful standard eventually emerged from the work of the committee of specialists charged with the task of creating the Luxemburger Wörterbuch, published in 5 volumes between 1950 and 1977. The orthographic conventions adopted in this decades-long project, set out in Bruch (1955), provided the basis of the standard orthography that became official on 10 October 1975.Mémorial B no. 68 (16 November 1976), pp. 1365–1390: “Arrêté ministériel du 10 octobre 1975 portant réforme du système officiel d’orthographe luxembourgeoise”. Modifications to this standard were proposed by the Conseil permanent de la langue luxembourgeoise and adopted officially in the spelling reform of 30 July 1999.[2] Mémorial A no. 112 (11 August 1999), pp. 2040–2048: “Règlement grand-ducal du 30 juillet 1999 portant réforme du système officiel d’orthographe luxembourgeoise”. A detailed explanation of current practice for Luxembourgish can be found in Schanen & Lulling (2003).
The Luxembourgish alphabet consists of the 26 Latin letters plus three modified letters: “é”, “ä”, and “ë”. In loanwords from French and German, other diacritics are usually preserved:
A striking phonological process in Luxembourgish causes the deletion of final in certain contexts. This phenomenon was originally documented in the late 19th century for the dialect of the Eifel region, hence the name Eifeler Regel (Eifel Rule).Kiehl, Johannes. (2001) Regularität und Variabilität der n-Tilgung im Lëtzebuergeschen (”Eifeler Regel”). Ein unüberwachtes, induktives Lernverfahren. Magisterarbeit im Fach Computerlinguistik, Universität Trier.
Since Luxembourgish orthography strives for phonetic accuracy, this deletion of n is also reflected in writing. Nowadays the Eifeler Regel is presented as a spelling rule, but its correct application still depends on a knowledge of spoken Luxembourgish. The rule targets words ending in -n or -nn, and since this is an extremely common ending for verbs, plural nouns, and function words (e.g. articles, pronouns, prepositions) in Luxembourgish, its effects are widespread. The basic rule can be described as follows (see Schanen & Lulling 2003):
<li>It is not deleted, however:
<li>before a vowel
<li>at the end of a sentence or before a punctuation mark
<li>Deletion is optional before the following function words beginning in s: säin, si/se/s’, sech, seng, sou (and perhaps others).
</ul>
It is important to know that many words ending in -n or -nn are not affected by the Eifeler Regel:
In fact, n as a stem consonant (as opposed to part of a grammatical ending) is generally stable in content words, with notable exceptions such as Wäi(n) (wine), Stee(n) (stone), geschwë(nn) (soon).
When final -n is dropped from a plural noun whose singular form also ends in -e, a diaeresis must be used to distinguish the plural:
Luxembourgish has three genders (masculine, feminine, and neuter), and has three cases (nominative, accusative, and dative). These are marked morphologically on determiners and pronouns. As in German, there is no morphological gender distinction in the plural.
The forms of the articles and of some selected determiners are given below:
|
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Distinct nominative forms survive in a few nominal phrases such as der Däiwel (”the devil”) and eiser Herrgott (”our Lord”). Rare examples of the genitive are also found: Enn des Mounts (”end of the month”), Ufanks der Woch (”at the beginning of the week”). The functions of the genitive are normally expressed using a combination of the dative and a possessive determiner: e.g. dem Mann säi Buch (lit. “to the man his book”, i.e. “the man’s book”). This is known as a periphrastic genitive, and is a phenomenon also commonly seen in dialectal and colloquial German, and in Dutch.
The forms of the personal pronouns are given in the following table (unstressed forms appear in parentheses):
| nominative | accusative | dative | |
| 1sg | ech | mech | mir (mer) |
| 2sg | du (de) | dech | dir (der) |
| 3sgm | hien (en) | hien (en) | him (em) |
| 3sgf | si (se) | si (se) | hir (er) |
| 3sgn | hatt (et) | hatt (et) | him (em) |
| 1pl | mir (mer) | äis/eis | äis/eis |
| 2pl | dir (der) | iech | iech |
| 3pl | si (se) | si (se) | hinnen (en) |
The 2pl form is also used as a polite singular (like French vous, see T-V distinction); the forms are capitalised in writing. Women and girls can be referred to with forms of the neuter pronoun hatt:
Luxembourgish morphology distinguishes two types of adjective: attributive and predicative. Predicative adjectives appear with verbs like sinn (”to be”), and receive no extra ending:
Attributive adjectives are placed before the noun they describe, and change their ending according to the grammatical gender, number, and case:
Interesting to note is how the definite article changes with the use of an attributive adjective: feminine d goes to déi (or di), neuter d’ goes to dat, and plural d’ changes to déi.
The comparative in Luxembourgish is formed analytically, i.e. the adjective itself is not altered (compare the use of -er in German and English; tall → taller, klein → kleiner). Instead it is formed using the adverb méi: e.g. schéin → méi schéin
The superlative involves a synthetic form consisting of the adjective and the suffix -st: e.g. schéin → schéinst (compare German schönst, English prettiest). Attributive modification requires the emphatic definite article and the inflected superlative adjective:
Predicative modification uses either the same adjectival structure or the adverbial structure am+ -sten: e.g. schéin → am schéinsten:
Some common adjectives have exceptional comparative and superlative forms:
Luxembourgish exhibits “verb second” word order in clauses. More specifically, Luxembourgish is a V2-SOV language, like German and Dutch. In other words, we find the following finite clausal structures:
Non-finite verbs (infinitives and participles) generally appear in final position:
These rules interact so that in subordinate clauses, the finite verb and any non-finite verbs must all cluster at the end. Luxembourgish allows different word orders in these cases:
This is also the case when two non-finite verb forms occur together:
Luxembourgish (like Dutch but unlike German) allows prepositional phrases to appear after the verb cluster in subordinate clauses:
Luxembourgish has borrowed many French words. For example, the name for a bus driver is Buschauffeur (also Dutch), which would be Busfahrer in German and Chauffeur de bus in French.
Some words are different from High German but have equivalents in German dialects. An example would be the word potato, which is Gromper in Luxembourgish, but pomme de terre in French and Kartoffel in High German. Other words are exclusive to Luxembourgish, for example the word for “Match”, which is “Fixfeier”.
Note: Words spoken in sound clip do not reflect all words on this list.
Neologisms in Luxembourgish include both entirely new words, and the attachment of new meanings to old words in everyday speech. The most recent neologisms come from the English language in the fields of telecommunications, computer science, and the Internet.
Recent neologisms in Luxembourgish include:Lulling, Jérôme. (2002) La créativité lexicale en luxembourgeois, Doctoral thesis, Université Paul Valéry Montpellier III.
Between 2000 and 2002, the Luxembourgish linguist, Jérôme Lulling, compiled a lexical database of 125,000 word forms as the basis for the very first Luxembourgish spellchecker (Projet C.ORT.IN.A).
The LaF (Lëtzebuergesch als Friemsprooch – Luxembourgish as a Foreign Language) is a set of four language proficiency certifications for Luxembourgish and follows the ALTE framework of language examination standards. The tests are administered by the Centre de Langues Luxembourg, which is a member of the ALTE.