Indem wir Zeichen setzen, aneinanderreihen, Sätze oder Programme schreiben, Sinn erzeugen prägen sich Spurrillen, über die die nächsten Bedeutungen hinweggleiten oder in sie hinein rutschen.

1 2 3 4 5 6 7 8 9

Many thanks to Brill for providing me with a copy of Stéphanie J Bakker’s The Noun Phrase in Ancient Greek: A Functional Analysis of the Order and Articulation of NP Constituents in Herodotus (ASCP 15; Leiden: Brill, 2009).

I actually received it a couple weeks ago, but I’ve been too busy to post lately. I’m about half way through the book thus far and have thoroughly enjoyed it. The first half of the book is a discussion of word order within the noun phrase and the second half deals with the function of the Greek article within the noun phrase. Part II is particularly excellent and unmatched in the literature on Ancient Greek. You can expect a full two or three part review probably toward the end of December or early January.

Wow, this is a great book.

As someone who has a highly vested interest in syntax databases, I’m excited to hear David Lang say that Syntax databases will be coming to the next version of Accordance.

I will be giving a presentation at BibleTech: 2010 on the very subject of Syntax databases currently titled “Greek Syntax Databases: Retrospect & Prospects” in which I’ll examine, compare and critique the two currently available syntax databases: Opentext.org & Cascadia Syntax Graphs and then also (hopefully) present some of my own work on representing Greek syntax. Currently the abstract isn’t yet up, but this is a good summary. I’ve been hoping to do something like this for some time, so I’m looking forward to the conference. Much of my presentation has been brewing for at least 14 months, though very little has showed up here on my blog.

I definitely look forward to seeing what Accordance has to offer when they release their next version and may very well consider looking into getting it if I like what I see.

…and I’m always willing to do a review copy…

There’s a few different methods to make your application apply syntax highlighting, this method below works for me, and although there’s many better, and more efficient ways it can be done, this is simple. Really simple.

First off, you need a reference for RegularExpressions -

using System.Text.RegularExpressions;

…and you’ll need to create a Rich Text Box, and either a button or menu item – you can have this working on a timer or a ‘TextChanged’ function, but it requires a bit more work, and can get very messy with large sections of text.

We need to declare regular expression strings to a variable that we’ll be searching for, it’s easiest to place it in the ‘global declaration’ area.. So right after:

public partial class Form1 : Form
{

Create your variable declaration:


public Regex keyWordsBlue = new Regex("if |then |else |fi |true |while |do |done |set |export |bool |break |case |class |const |for |foreach |goto |in |void |if\n|then\n|else\n|fi\n|true\n|while\n|do\n|done\n|set\n|export\n|bool\n|break\n|case\n|class\n|const\n|for\n|foreach\n|goto\n|in\n|void\n");


This is basically saying anything between the quotes, delimited by a pipe(|) symbol will get highlighted.

I’ve picked some common protected function words in Unix for my example. Since I don’t want *every* occurance of this to be highlighted, i’ve made it so the word requires a space or a return (new line \n) character after it, which 99% of the time it will have.

The next bit will apply the highlighting. Personally I prefer to have this in a button, or menu item – if you want this to run on ‘TextChanged’ or via a timer, you’ll need to edit it ever so slightly.

Remember to create this in a seperate function, so you can call it from different places as/when required.

        private void ApplySyntaxHighlighting()
        {

            // Select all and set to black so that it's 'clean'
            rtbText.SelectAll();
            rtbText.SelectionColor = Color.Black;

            // Then unselect and scroll to the end of the file
            rtbText.ScrollToCaret();
            rtbText.Select(rtbText.Text.Length, 1);

            // Start applying the highlighting... Set a value to selPos
            int selPos = rtbText.SelectionStart;

            foreach (Match keyWordMatch in keyWordsBlue.Matches(rtbText.Text))
            {
                // Select the word..
                rtbText.Select(keyWordMatch.Index, keyWordMatch.Length);
                // Change it to blue
                rtbText.SelectionColor = Color.Blue;
                // Set it to bold for this example
                rtbText.SelectionFont = new Font(rtbText.SelectionFont, FontStyle.Bold);
                // Move cursor back to where it was
                rtbText.SelectionStart = selPos;
                // Change the default font color back to black.
                rtbText.SelectionColor = Color.Black;
            }
        }

Now, in your button or menu item, you need to call the function with “ApplySyntaxHighlighting();” – i.e.


private void applySyntaxHighlightingToolStripMenuItem_Click(object sender, EventArgs e)
{
ApplySyntaxHighlighting();
}


Once you’ve added some different regular expression strings, it should start looking a bit like this:

P.S – The expression I used for the comment line was:


public Regex keyWordsGreenComment = new Regex(@"\#.*?\n");


http://msdn.microsoft.com/en-us/magazine/ee358704.aspx

In order to do language specific syntax highlighting of your source code, replace “your code goes here” by your actual code:

See an example here.

For available language options refer to the link below.

Reference: WordPress Support.

Reference

Java is an object-oriented programming language developed by James Gosling and colleagues at Sun Microsystems in the early 1990s. Unlike conventional languages which are generally designed either to be compiled to native (machine) code, or to be interpreted from source code at runtime, Java is intended to be compiled to a bytecode, which is then run (generally using JIT compilation) by a Java Virtual Machine.

The language itself borrows much syntax from C and C++ but has a simpler object model and fewer low-level facilities. Java is only distantly related to JavaScript, though they have similar names and share a C-like syntax.

Java was started as a project called “Oak” by James Gosling in June 1991. Gosling’s goals were to implement a virtual machine and a language that had a familiar C-like notation but with greater uniformity and simplicity than C/C++. The first public implementation was Java 1.0 in 1995. It made the promise of “Write Once, Run Anywhere”, with free runtimes on popular platforms. It was fairly secure and its security was configurable, allowing for network and file access to be limited. The major web browsers soon incorporated it into their standard configurations in a secure “applet” configuration. popular quickly. New versions for large and small platforms (J2EE and J2ME) soon were designed with the advent of “Java 2″. Sun has not announced any plans for a “Java 3″.

In 1997, Sun approached the ISO/IEC JTC1 standards body and later the Ecma International to formalize Java, but it soon withdrew from the process. Java remains a proprietary de facto standard that is controlled through the Java Community Process. Sun makes most of its Java implementations available without charge, with revenue being generated by specialized products such as the Java Enterprise System. Sun distinguishes between its Software Development Kit (SDK) and Runtime Environment (JRE) which is a subset of the SDK, the primary distinction being that in the JRE the compiler is not present.

Philosophy

There were five primary goals in the creation of the Java language:

1. It should use the object-oriented programming methodology.
2. It should allow the same program to be executed on multiple operating systems.
3. It should contain built-in support for using computer networks.
4. It should be designed to execute code from remote sources securely.
5. It should be easy to use by selecting what was considered the good parts of other object-oriented languages.

To achieve the goals of networking support and remote code execution, Java programmers sometimes find it necessary to use extensions such as CORBA, Internet Communications Engine, or OSGi.

Object orientation

The first characteristic, object orientation (“OO”), refers to a method of programming and language design. Although there are many interpretations of OO, one primary distinguishing idea is to design software so that the various types of data it manipulates are combined together with their relevant operations. Thus, data and code are combined into entities called objects. An object can be thought of as a self-contained bundle of behavior (code) and state (data). The principle is to separate the things that change from the things that stay the same; often, a change to some data structure requires a corresponding change to the code that operates on that data, or vice versa. This separation into coherent objects provides a more stable foundation for a software system’s design. The intent is to make large software projects easier to manage, thus improving quality and reducing the number of failed projects.

Another primary goal of OO programming is to develop more generic objects so that software can become more reusable between projects. A generic “customer” object, for example, should have roughly the same basic set of behaviors between different software projects, especially when these projects overlap on some fundamental level as they often do in large organizations. In this sense, software objects can hopefully be seen more as pluggable components, helping the software industry build projects largely from existing and well-tested pieces, thus leading to a massive reduction in development times. Software reusability has met with mixed practical results, with two main difficulties: the design of truly generic objects is poorly understood, and a methodology for broad communication of reuse opportunities is lacking. Some open source communities want to help ease the reuse problem, by providing authors with ways to disseminate information about generally reusable objects and object libraries.

Platform independence

The second characteristic, platform independence, means that programs written in the Java language must run similarly on diverse hardware. One should be able to write a program once and run it anywhere.

This is achieved by most Java compilers by compiling the Java language code “halfway” to bytecode (specifically Java bytecode)—simplified machine instructions specific to the Java platform. The code is then run on a virtual machine (VM), a program written in native code on the host hardware that interprets and executes generic Java bytecode. Further, standardized libraries are provided to allow access to features of the host machines (such as graphics, threading and networking) in unified ways. Note that, although there’s an explicit compiling stage, at some point, the Java bytecode is interpreted or converted to native machine instructions by the JIT compiler.

There are also implementations of Java compilers that compile to native object code, such as GCJ, removing the intermediate bytecode stage, but the output of these compilers can only be run on a single architecture.

Sun’s license for Java insists that all implementations be “compatible”. This resulted in a legal dispute with Microsoft after Sun claimed that the Microsoft implementation did not support the RMI and JNI interfaces and had added platform-specific features of their own. In response, Microsoft no longer ships Java with Windows, and in recent versions of Windows, Internet Explorer cannot support Java applets without a third-party plug-in. However, Sun and others have made available Java run-time systems at no cost for those and other versions of Windows.

The first implementations of the language used an interpreted virtual machine to achieve portability. These implementations produced programs that ran more slowly than programs compiled to native executables, for instance written in C or C++, so the language suffered a reputation for poor performance. More recent JVM implementations produce programs that run significantly faster than before, using multiple techniques.

The first technique is to simply compile directly into native code like a more traditional compiler, skipping bytecodes entirely. This achieves good performance, but at the expense of portability. Another technique, known as just-in-time compilation (JIT), translates the Java bytecodes into native code at the time that the program is run which results in a program that executes faster than interpreted code but also incurs compilation overhead during execution. More sophisticated VMs use dynamic recompilation, in which the VM can analyze the behavior of the running program and selectively recompile and optimize critical parts of the program. Dynamic recompilation can achieve optimizations superior to static compilation because the dynamic compiler can base optimizations on knowledge about the runtime environment and the set of loaded classes. JIT compilation and dynamic recompilation allow Java programs to take advantage of the speed of native code without losing portability.

Portability is a technically difficult goal to achieve, and Java’s success at that goal has been mixed. Although it is indeed possible to write programs for the Java platform that behave consistently across many host platforms, the large number of available platforms with small errors or inconsistencies led some to parody Sun’s “Write once, run anywhere” slogan as “Write once, debug everywhere”.

Platform-independent Java is however very successful with server-side applications, such as Web services, servlets, and Enterprise JavaBeans, as well as with Embedded systems based on OSGi, using Embedded Java environments.

Automatic garbage collection

One idea behind Java’s automatic memory management model is that programmers should be spared the burden of having to perform manual memory management. In some languages the programmer allocates memory to create any object stored on the heap and is responsible for later manually deallocating that memory to delete any such objects. If a programmer forgets to deallocate memory or writes code that fails to do so in a timely fashion, a memory leak can occur: the program will consume a potentially arbitrarily large amount of memory. In addition, if a region of memory is deallocated twice, the program can become unstable and may crash. Finally, in non garbage collected environments, there is a certain degree of overhead and complexity of user-code to track and finalize allocations.

In Java, this potential problem is avoided by automatic garbage collection. The programmer determines when objects are created, and the Java runtime is responsible for managing the object’s lifecycle. The program or other objects can reference an object by holding a reference to it (which, from a low-level point of view, is its address on the heap). When no references to an object remain, the Java garbage collector automatically deletes the unreachable object, freeing memory and preventing a memory leak. Memory leaks may still occur if a programmer’s code holds a reference to an object that is no longer needed—in other words, they can still occur but at higher conceptual levels.

The use of garbage collection in a language can also affect programming paradigms. If, for example, the developer assumes that the cost of memory allocation/recollection is low, they may choose to more freely construct objects instead of pre-initializing, holding and reusing them. With the small cost of potential performance penalties (inner-loop construction of large/complex objects), this facilitates thread-isolation (no need to synchronize as different threads work on different object instances) and data-hiding. The use of transient immutable value-objects minimizes side-effect programming.

Comparing Java and C++, it is possible in C++ to implement similar functionality (for example, a memory management model for specific classes can be designed in C++ to improve speed and lower memory fragmentation considerably), with the possible cost of extra development time and some application complexity. In Java, garbage collection is built-in and virtually invisible to the developer. That is, developers may have no notion of when garbage collection will take place as it may not necessarily correlate with any actions being explicitly performed by the code they write. Depending on intended application, this can be beneficial or disadvantageous: the programmer is freed from performing low-level tasks, but at the same time loses the option of writing lower level code.

Syntax

The syntax of Java is largely derived from C++. However, unlike C++, which combines the syntax for structured, generic, and object-oriented programming, Java was built from the ground up to be virtually fully object-oriented: everything in Java is an object with the exceptions of atomic datatypes (ordinal and real numbers, boolean values, and characters) and everything in Java is written inside a class.

Applet

Java applets are programs that are embedded in other applications, typically in a Web page displayed in a Web browser.

// Hello.java
import java.applet.Applet;
import java.awt.Graphics;

public class Hello extends Applet {
public void paint(Graphics gc) {
gc.drawString(“Hello, world!”, 65, 95);
}
}

This applet will simply draw the string “Hello, world!” in the rectangle within which the applet will run. This is a slightly better example of using Java’s OO features in that the class explicitly extends the basic “Applet” class, that it overrides the “paint” method and that it uses import statements.

<!– Hello.html –>
<html>
<head>
<title>Hello World Applet</title>
</head>
<body>
<applet code=”Hello” width=”200″ height=”200″>
</applet>
</body>
</html>

An applet is placed in an HTML document using the <applet> HTML element. The applet tag has three attributes set: code=”Hello” specifies the name of the Applet class and width=”200″ height=”200″ sets the pixel width and height of the applet. (Applets may also be embedded in HTML using either the object or embed element, although support for these elements by Web browsers is inconsistent.

Servlet

Java servlets are server-side Java EE components that generate responses to requests from clients.

// Hello.java
import java.io.*;
import javax.servlet.*;

public class Hello extends GenericServlet {
public void service(ServletRequest request, ServletResponse response)
throws ServletException, IOException
{
response.setContentType(“text/html”);
PrintWriter pw = response.getWriter();
pw.println(“Hello, world!”);
pw.close();
}
}

The import statements direct the Java compiler to include all of the public classes and interfaces from the java.io and javax.servlet packages in the compilation. The Hello class extends the GenericServlet class; the GenericServlet class provides the interface for the server to forward requests to the servlet and control the servlet’s lifecycle.

The Hello class overrides the service(ServletRequest, ServletResponse) method defined by the Servlet interface to provide the code for the service request handler. The service() method is passed a ServletRequest object that contains the request from the client and a ServletResponse object used to create the response returned to the client. The service() method declares that it throws the exceptions ServletException and IOException if a problem prevents it from responding to the request.

The setContentType(String) method in the response object is called to set the MIME content type of the returned data to “text/html”. The getWriter() method in the response returns a PrintWriter object that is used to write the data that is sent to the client. The println(String) method is called to write the “Hello, world!” string to the response and then the close() method is called to close the print writer, which causes the data that has been written to the stream to be returned to the client.

Swing application

Swing is the advanced graphical user interface library for the Java SE platform.

// Hello.java
import javax.swing.*;

public class Hello extends JFrame {
Hello() {
setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
add(new JLabel(“Hello, world!”));
pack();
}

public static void main(String[] args) {
new Hello().setVisible(true);
}
}

The import statement directs the Java compiler to include all of the public classes and interfaces from the javax.swing package in the compilation. The Hello class extends the JFrame class; the JFrame class implements a window with a title bar with a close control.

The Hello() constructor initializes the frame by first calling the setDefaultCloseOperation(int) method inherited from JFrame to set the default operation when the close control on the title bar is selected to WindowConstants.DISPOSE_ON_CLOSE—this causes the JFrame to be disposed of when the frame is closed (as opposed to merely hidden), which allows the JVM to exit and the program to terminate. Next a new JLabel is created for the string “Hello, world!” and the add(Component) method inherited from the Container superclass is called to add the label to the frame. The pack() method inherited from the Window superclass is called to size the window and layout its contents.

The main() method is called by the JVM when the program starts. It instantiates a new Hello frame and causes it to be displayed by calling the setVisible(boolean) method inherited from the Component superclass with the boolean parameter true. Note that once the frame is displayed, exiting the main method does not cause the program to terminate because the AWT event dispatching thread remains active until all of the Swing top-level windows have been disposed.

Look and feel

The default look and feel of GUI applications written in Java using the Swing toolkit is very different from native applications. It is possible to specify a different look and feel through the pluggable look and feel system of Swing. Clones of Windows, GTK and Motif are supplied by Sun. Apple also provides an Aqua look and feel for Mac OS X. Though prior implementations of these look and feels have been considered lacking, Swing in Java SE 6 addresses this problem by using more native widget drawing routines of the underlying platforms. Alternatively, third party toolkits such as wx4j or SWT may be used for increased integration with the native windowing system.

Lack of OO purity and facilities

Java’s primitive types are not objects. Primitive types hold their values in the stack rather than being references to values. This was a conscious decision by Java’s designers for performance reasons. Because of this, Java is not considered to be a pure object-oriented programming language. However, as of Java 5.0, autoboxing enables programmers to write as if primitive types are their wrapper classes, and freely interchange between them for improved flexibility. Java designers decided not to implement certain features present in other OO languages, including:

* multiple inheritance
* operator overloading
* class properties
* tuples

Java Runtime Environment

The Java Runtime Environment or JRE is the software required to run any application deployed on the Java Platform. End-users commonly use a JRE in software packages and Web browser plugins. Sun also distributes a superset of the JRE called the Java 2 SDK (more commonly known as the JDK), which includes development tools such as the Java compiler, Javadoc, and debugger.

Above article originally from wikipedia.org. Above article is available under GNU Free Documentation License.

Find sample blogs on a gazillion topics at Alpha Inventions

I'll have what she's having

The Risk-Free Trial? Guilty

Vintage Garden, by Xx_rebeldiamonds_xX

Last summer I bit on a “risk-free trial” for an açaí-berry formula and a colon-cleanse detox product, both in capsule form. I was aware of the risks of a “risk-free trial.” The strategy is similar to that used by publishers such as Bottom Line Books and Rodale Books, which let you “examine a book free for thirty days,” during which you could doubtless read the book and send it back, keeping the bonus gift, usually a small but useful guide to Growing Healing Herbs in a Sunny Window, or perhaps Homemade Garden-Pest Repellents.

I lost 12 pounds

In any event, I was quick to read the fine print on my “risk-free trial” of açaí-berry formula and colon-cleanse detox product. I needed to return the bottles containing the “unused product” to an address in Florida within ten days of my receiving them, which the company estimated at three days after shipping. Otherwise, my credit card would be charged $89.95 per month until cancellation.

Usually, it’s a miracle if my mail gets opened within ten days of receipt, but the phrase risk-free trial sets off warning bells. So… an unprecedented TWO days after receiving the product, I extracted my ten-day supply from each bottle and sent the remainder via USPS Priority Mail to the Florida address. Even so, my credit card was charged $89.95.

Astonishingly, the charge was removed without my having to make so much as a phone call. I’ve heard from other victims, however, that such charges can be very sticky.

You are actually at risk the minute you divulge your credit-card information, which is required for the “minimal shipping charge” of $1.95 or whatever.  If you must take the risk-free-trial risk, consider using a temporary (prepaid) credit card and keep the balance very low or cancel it altogether. Or not. Consult your legal professional.

By the way (and DO consult your healthcare professional before trying this regimen), I lost 12 pounds in two months on the colon-cleanse detox capsules.

Next: Truth in Advertising, Your Just Deserts — “Get the Smooth, Flawless, Young-Looking Skin You Deserve”

Below: I thought there was missing text, but it’s just Silly Syntax

From an Arizona Department of Health Services Report…

Neurological Effects [of exposure to hydrogen sulfide in sewer gas]:
Ataxia, choreoathetosis, dystonia, inability to stand in one 20-month-old child

Holiday Store ** Random Cards of Kindness

]]> http://robleshermoso.wordpress.com/2009/11/19/tip-golang-syntax-highlighting/ Thu, 19 Nov 2009 12:43:25 +0000 Chema http://robleshermoso.wordpress.com/2009/11/19/tip-golang-syntax-highlighting/

GoLang logo

Translate to:English

Un truco rápido. Si estais acostumbrados a usar VIM, es casi seguro que tengais activo el resalto de sintaxis según el tipo de fichero.

Como GoLang está todavía en fase experimental, tu copia de VIM no reconocerá el formato *.go, y por tanto no te resaltará su sintaxis.

Los chicos de GoLang piensan en todo y han creado un fichero de sintaxis para VIM, Kate, Xcode y Emacs.

Para activarlo en VIM, hay que hacer lo siguiente:

1. Crear/modificar el archivo ~/.vimrc y añadir las siguientes líneas:
   au BufRead,BufNewFile *.go set filetype=go
au! Syntax go source <ruta-raiz-de-golang>/misc/vim/go.vim
2. Modificamos “<ruta-raiz-de-golang>” con la ruta de GOROOT.
3. Guardamos y listo.

Ya os costará menos echarle un vistazo a los ficheros .go

Que aproveche!

Actualización: para Kate es muy fácil, basta con copiar el fichero ‘$(GOROOT)/misc/kate/go.xml’ a /usr/share/apps/katepart/syntax
Translate to:English
Menéame Twitter

Subject-verb agreement

          This syntax issue can really bedevil writers, especially students who are still struggling a little with the myriad of rules and regs. Perhaps part of the problem with this guideline is the word “agreement.” We all know the meaning of “agree” as in “You and I will never agree,” or “We will agree to disagree,” but when we talk about subject-verb agreement, we’re actually talking about something entirely different. In this case “agree” means matching subjects and verbs according to number. That is, when you have a singular subject, you have to match it with a singular verb: The dog runs. When you have a plural subject, you must have a plural verb form: The dogs run.

In short sentences we can hear the problem: The dogs runs just doesn’t sound right so we can usually make the necessary changes to The dogs run.

There are, however, three problems that can crop up:

• Prepositional phrases
• Indefinite pronouns
• Reversed sentence order

 Prepositional phrases consist of words that slip in between the subject and the verb. The dogs in the mudroom is dirty. The noun “mudroom” may be singular making us think, perhaps, that the following verb “is” should be singular as well. But the subject is “dogs.” Take out the prepositional phrase in the mudroom and we’re left with the sentence The dogs is dirty, which is clearly not correct. The correct verb should be “are” as in “The dogs in the mudroom are dirty.”

We only need to remember one thing about indefinite pronouns: if a word has one of these endings: everybody, everyone, anyone, anything, etc., it is singular. We can also include each, either, and neither in this group.

• Everyone is going…
• Each is taking the train…
• If anyone comes later…

The normal pattern for English sentence order is subject-verb. There are, however, a few cases where this order is reversed. For instance:

          There are dogs in the kitchen.  The standard order would be Dogs are there in the kitchen. Or some such version that places the subject and verb in the standard order.

          Where are they? Or:  They are where?

          We would not write or say There is dogs in the kitchen, or They is where?

          Easy this is, yes?

          Thank you Yoda, but not always.

That’s my new word.  I learned it today watching a comercial for South Park, to which I thought, “this is brilliant… ‘craptastic.’”

It means:

craptastic (adjective) : the opposite of fantastic, expressing how phenomenally bad something is.

That movie was craptastic.

Wenn man mit foreach() arbeitet, sollte man vorher prüfen ob das Array überhaupt einen Eintrag hat. Das habe ich nun einfach mit der Funktion count() realisiert.

if(count($arr) >= 1) {
foreach ($arr as $value) {
echo "Value: $value\n";
}
}

Though both require relative clauses to begin with a relative pronoun, Greek and English are typologically distinct in that one employs the pronoun with the gap strategy (English) and the other only needs the pronoun (Greek): a man who Chris saw [GAP] vs. τὸ ποτήριον ὃ ἐγὼ μέλλω πίνειν (the cup that I am about to drink [no gap]).

The English Gap is implicitly necessary for our processing of the grammatical relation of relative pronouns (in this case the Object relation), whereas in Greek, grammatical relations are marked by morphology* rather than structural relations/word order.

*This is not to say that English doesn’t have some morphological marking occurring on it’s pronouns, but this morphology is not the central marker of grammatical relations. Grammatical relations are centrally marked by structural position within the clause. Hence when English speakers hear relative clauses they consciously notice the Gap position where the Object would typically appear.

I recently had to switch back to Perl programming — after 10+ years of carefully avoiding it. For some reason it brought back to my mind the kind of image found below. It took me 30 years to realize Franquin’s characters are all Perl programmers.

Tomorrow we will have a student session of TiL featuring our own Brad Hoot (UIC Ph.D. student) and visiting student Álvaro Recio (University of Salamanca Ph.D. student).  Brad Hoot will present “An Optimality Theoretic Analysis of Focus in Spanish and English”.  His presentation will be conducted in English.  Álvaro Recio will present “Las propiedades argumentales de los complementos del nombre en español” (see abstract below), and his presentation will be given in Spanish.

As always the talk will be at 3 in 1750 University Hall with light refreshments provided.

Álvaro Recio (University of Salamanca)                    UIC TiL Fall 2009

Abstract
Las propiedades argumentales de los complementos del nombre en español

 Son muchos los autores que en las últimas décadas han puesto de relieve el paralelismo existente entre la estructura interna del sintagma nominal y del sintagma verbal. No todos los modificadores realizan la misma aportación al significado de un sintagma, ni tienen idénticas propiedades formales ni gozan del mismo estatuto sintáctico. De la misma manera que el verbo posee una red argumental que le permite seleccionar determinado tipo de complementos, ciertos sustantivos, bien por herencia deverbal, bien por su propia semántica interna, seleccionan igualmente complementos argumentales. En consecuencia, en el interior de los grupos nominales, de forma paralela a las oraciones, también es preciso distinguir entre argumentos y adjuntos. Si bien en otras lenguas, fundamentalmente inglés, italiano y francés, se han dedicado  numerosos estudios al respecto, en el ámbito hispánico apenas se han esbozado unas pautas generales de clasificación de estos complementos, por lo que se revela necesario un análisis exhaustivo y profundo aplicado al español.

 El objetivo de esta charla es presentar las características generales de un proyecto que trata de ahondar en la estructura interna del sintagma nominal en castellano, en los llamados complementos argumentales del sustantivo. Para ello, se expondrán los rasgos fundamentales que permiten determinar qué clases de sustantivos pueden seleccionar argumentos en español, cuál es la estructura de estos y qué tipo de vínculo los enlaza con el núcleo nominal, pues parece que no todos los argumentos tienen el mismo peso dentro del sintagma: el de mayor relieve temático podría ser considerado el “sujeto” del sintagma nominal.

 Especial atención se dedicará a las subordinadas sustantivas que se vinculan a un nombre a través de una preposición (por ejemplo, la idea de comprar un coche o el problema de que los alumnos no estudien), ya que muchos aspectos de su funcionamiento están todavía desatendidos. Una rigurosa descripción de los modificadores del sustantivo no puede ignorar este tipo de construcciones y requiere analizar las características de los núcleos que las aceptan, el carácter argumental o no de la oración, así como la elección del modo correspondiente en el verbo subordinado.

Novelist John Irving holds forth on Big Think on an array of writing issues in short videos excerpted from a long interview. He discusses his working habits—eight to nine hours a day writing in longhand in lined notebooks, seven days a week—and the deep rifts in America that trouble him. He talks about using post-it notes, the long process of revision, achieving syntactical unity throughout a long work, and the glory of the long, lavishly detailed, plotted, visual nineteenth-century novels of Dickens, Hardy, Melville, and Hawthorne. The tidbits are worth a listen.

During some recent reading, it struck me that a useful framework for thinking about and talking about sentence generation is the MTT or “meaning-text theory” of Igor Mel’cuk, et al Here is one readable reference:

Igor A. Mel’čuk and Alain Polguère, (1987) “A Formal Lexicon in Meaning-Text Theory”, Computational Linguistics, vol. 13, pp. 261-275.

portal.acm.org/citation.cfm?id=48160.48166
www.aclweb.org/anthology/J/J87/J87-3006.pdf

Within the context of that theory, the output of the Stanford parser is strictly at the SSynR or “surface syntactic representation” level, while, as a general rule Relex attempts to generate the DSynR or “Deep syntactic representation” structure.  Some of what I’ve been trying to do with opencog is towards the “SemR” structure, as described in that paper.

The more I read about MTT, the more it seems to capture some of what we are trying to do (defacto are doing) with NLP within opencog.  In particular, the MTT concept of a “lexical function” (which is not really described in that paper??) could be a particularly strong way of guaranteeing correct syntactic output for segsim, nlgen or NLGen2

– Linas Vepstas

Ao começar este post, eu me lembrei de uma situação onde uma amiga havia questionado ingenuamente o conceito de código-fonte. Para os leigos, portanto, forneço a citação do Dicionário Eletrônico Houaiss (v.1.0.5a):

código-fonte

n substantivo masculino
Rubrica: informática.
sistema de símbolos utilizado para codificar o programa-fonte

E programa-fonte?

n substantivo masculino
Rubrica: informática.
programa de computador em sua forma original, anotado pelo programador em uma linguagem-fonte, antes de ser codificado em instruções de linguagem de máquina

E linguagem-fonte?

n substantivo feminino
Rubrica: informática.
linguagem em que um programa de computador está originalmente escrito, antes de ser codificado em linguagem de máquina

Em minhas palavras, o código-fonte é uma linguagem humanamente inteligível que, quando utilizada corretamente por um programador, pode ser transformada em uma linguagem que os computadores entendam a fim de executar alguma tarefa dentro de um programa de informática.

Voltando ao tema deste post, muitas vezes eu tive que reproduzir aqui neste weblog algum código-fonte de exemplo. Para destaca-lo do restante do texto, modifiquei a cor de todo bloco que representasse essa codificação.

Assim, eu usava:

class Pessoa extends Humano {

private $nome;

private $sexo;

public setNome($nome){

$this->nome = $nome;

}

public setSexo($sexo){

$this->sexo = $sexo;

}

}

porém, ele ficaria muito mais legal, se eu fizesse isso aqui:

class Pessoa extends Humano {

private $nome;

private $sexo;

public setNome($nome){

$this->nome = $nome;

}

public setSexo($sexo){

$this->sexo = $sexo;

}

}

Gostei! Como faz?

O wordpress tem um recurso legal chamado SyntaxHighlighter, que faz com que seu código seja mostrado de uma maneira mais acessível aos programadores.

Eu desconhecia esse truque até que entrei no blog do Giolvani e decidi que era hora de deixar a preguiça de lado e começar a fazer alguma coisa mais consistente pra ajudar o povo que me visita.

Então, encontrei esse tutorialzinho dentro do Codex e gostaria de compartilhar com vocês. O link é:

http://en.support.wordpress.com/code/posting-source-code/

Para transformar, é fácil:

digite o código-fonte dentro da seguinte estrutura:

[ sourcecode language="sua linguagem" ]
seu código fonte
[ /sourcecode ]

EM TEMPO -> coloquei espaços em branco após os colchetes intencionalmente para que ele pudesse aparecer na íntegra dentro deste post. Na prática você deve remover os espaços em branco de dentro das tags, ou seja, após o “[" e antes do "]“.

Dicas úteis:

No lugar de sua linguagem, você deve especificar sobre qual linguagem de programação o highlight se refere, pois existem diversos code-standards para diferentes tipos de linguagem.

Os parâmetros suportados são:

• actionscript3
• bash
• csharp
• cpp
• css
• delphi
• diff
• groovy
• javascript
• java
• javafx
• perl
• php
• text
• powershell
• python
• ruby
• scala
• sql
• vb
• xml

Caso nenhum parâmetro seja especificado, o pseudo bbcode do wordpress vai assumir que você quer apenas fazer um texto simples sem highlight, ou seja, o valor default desse parâmetro é igual a “text”.

Os outros parâmetros opcionais são:

• autolinks (true/false) — Transforma todas as URLs do seu código-fonte em clicáveis. O valor default é true.
• collapse (true/false) — Se true, o bloco de código será comprimido (fechado, resumido, collapsed) quando a página carregar, exigindo que o visitante clique para expandir e melhor visualizar. É ótimo para códigos gigantescos. O valor default é false.
• firstline (número) — Use isso para personalizar o valor numérico da linha inicial da sua numeração. O valor default é 1.
• gutter (true/false) — Se false, os números das linhas que aparecem no lado esquerdo serão escondidos. O valor default é true.
• highlight (números das linhas separados por vírgulas) — Você pode listar os números das linhas que você quer destacar, por exemplo: “5, 55, 1578″.
• htmlscript (true/false) — Se true, qualquer HTML/XML do seu código, ficarão em destaque. É bem útil quando você está misturando linguagens dentro de seu script, como é exemplo de uso ter um código PHP inserido dentro de um contexto HTML. O valor default é false e funcionará somente com algumas linguagens específicas.
• light (true/false) — Se true, a numeração das linhas e a barra de ferramentas ficarão ocultas. É útil quando você quer postar algo pequeno, como somente 1 ou 2 linhas de código. Isso deixa a visibilidade da sua página bem mais limpa e agradável. O valor default é false.
• ruler (true/false) — Se true, uma régua de posicionamento de caracteres será mostrada no topo da sua codificação. O valor default é false.
• toolbar (true/false) — Se false, a barra de ferramentas que mostra botões utilitário quanto você posiciona o mouse em cima do código não será mostrada. O valor default é true.
• wraplines (true/false) — Se true, a quebra automática de linhas será desabilitada, o que causará o aparecimento de uma barra de rolagem para códigos com linhas muito longas. O valor default é false.

Com isso, o visual dos nossos blogs do wordpress ficarão muito melhor. A partir desse post, estarei adotando essa boa prática.

um abraço ao visitante.

I’d just like to say ‘thank you’ to everyone who visited The Outspoken Omphaloskeptic yesterday. I’m not sure how or why it happened, but yesterday the site received the most traffic of any day since its navel-gazing inception. There were over 30% more visitors than on the previous busiest day. Less than ten of yesterdays hits were generated by links from other sites or search engine results. That means most of you visitors have chosen to land on this site.  For those of you who keep coming back, I’ll try to make sure that doing so is worth your while.

On a somewhat related note, I’ve noticed two tendencies in myself since I started posting to this blog. The first is something that I’m sure is very common: I tend to read, watch, look at or otherwise experience things and part of my brain is saying “Hey, I could post about that.” Though relatively frequent this new tendency to consider the possibility of turning everyday experiences into omphaloskeptic fodder doesn’t amount to a full-blown obsession on my part. Instead it simply provides an additional filter for my thinking, it gives me another reason to pause and reflect on things. That’s got to be a good thing, right? At any rate, I’m not too bothered by the possibility that The Outspoken Omphaloskeptic has subjective or introspectively self-indulgent tendencies.  This blog was, as the title might suggest, conceived with precisely those tendencies in mind. Yes, I post with the hope that I might strike a chord amongst visitors, but I’m not trying to claim my experience of life or my views are universal.  That would just be boring.  Besides, if I become too introverted in my postings visitor numbers will quickly dwindle to zero and I will be, essentially, sending myself e-mail.  I can do that without a website.

The second tendency I’ve noticed is that I have a major inability to proofread and edit when I’m writing for the Omphaloskeptic.  Normally, these are things I’m pretty good at and I can’t figure out what my problem is when it comes to writing this blog.  A few people have suggested that it has something to do with trying to edit on screen, but that’s how I do all my editing.  Maybe its just sheer excitement and an accompanying eagerness to get my posts published that combine to result in the slipping of my standards.  I’m not sure.

I’ve had to stop revisiting postings after I’ve published them because I’m filled with self-disgust and shame at some of the obvious mistakes that I find, mistakes I don’t make elsewhere.  It doesn’t seem to matter how many times I proofread a posting or even if I sit on it over night and read it again immediately before publishing, some evil demon in me takes over and indulges his desire to make me look like a fool with only a rudimentary knowledge of spelling, grammar, syntax and diction. This wouldn’t matter so much if I didn’t refuse to edit the posts once they’ve been up for more than a few minutes.  Doing so just strikes me as dishonest for some reason; I’d rather live with mistakes that make me literally cringe.  I think the best course of action may be for me to avoid revisiting items once I’ve posted them.  Does anyone else have this problem? Do you have any tips for overcoming it?  Is this some sort of karmic payback for all the ink I’ve spilled correcting the writings of others?

This is the longest posting I’ve done yet for a Friday and I feel its appropriately inconsequential even if it isn’t light-hearted.  My brain doesn’t want to cooperate and, as it is Friday, I’m going to give in to its demands and go lay on the floor with my dogs until my wife and mother-in-law return with supplies for our dinner.

Thanks again to all of you who have been regular visitors to the site.  The fact that some of you choose to read some the flapdoodle I spill is bemusing and vaguely edifying.  As ever, comments are welcome and feel free to send the Omphaloskeptic’s URL along to anyone who might be interested.   You could even let me know how many mistakes you can find in this posting if you like.