Lambda the Ultimate

I don't know if this question is within the bounds of LTU, but this thread is kinda close so I think it might be okay (if not please delete). My situation is I'm an undergrad, and I want to go on to a good ph.d program and eventually do research and teach. I'm interested in domain specific languages, parallizing compilers, and PL theory. I was hoping some of the academic folks here could advise me.

My problem is that the CS dept at my school is very weak in plt. It's a decent school (I'd say middian level state univerisity), but the dept strength is in networking. From the thread above I've read some documents about grad school, and as you'd expect, to get into a good ph.d program it's good to have some research experience as an undergrad.

So given my situation, does anyone have any advice for me? Switching schools isn't an option (right now) due to my work as a legacy system maintainer paying too well to leave just yet. I spoke with the Dept head and he didn't have any ideas. Thanks in advance...

This is more of a meta usability issue than a substantive one, but I think it might concern a number of us, so at the risk of straying too far off topic, here goes:

Up until now I've been killing a lot of trees printing out PL research papers, most of which are distributed as two column PDF's in ACM conference paper format.

I would much rather load them all into a Sony Reader or similar device so I could keep my entire technical library with me on a memory card.

Unfortunately, these PDF's aren't in "Tagged PDF" format, which is to say that they aren't annotated with structural meta data that would let a mobile device "re-flow" them for display on a small screen.

Has anyone figured out a way, short of buying an expensive copy of the full Acrobat publishing software, to automatically add this tagging meta data to our papers or to otherwise strip out two column formatting from PDFs so they could be viewed at a reasonable size in landscape mode without having to read the top left column, scroll down to the bottom half of the left column, then back up to see the top of the right column, and then back down again to see the bottom right quadrant of the page?

Maybe we could all agree on some sort of secondary raw text, rtf, or XML-based distribution format that would be more amennable to use on mobile devices. The fixed page size two column layout served us well in the age of print, but in an age of digital paper and e-ink it seems a tad sub-optimal.

Hello,

I'm new here and this is my first post. :-)

I'm a software engineer, mostly with background in C, C++, Java, and PHP, but I have a strong interest in expanding my knowledge and learning other programming language paradigms. I've already looked through the "Getting Started" thread here, as well as wikipedia on topics like functional programming, monads, closures, haskell, lambda calculus, etc. However, I'm still having trouble understanding all the concepts. I get some things like erlang, scheme, half of lisp ;-), but others escape me completely.

So what I'm after is a extra-basic reference to such things. What exactly is the concept, why is it important, what benefit does it provide, an example of a real-world situation where it's helpful, etc. All boiled down to basic terminology and explanations. Is there such explanations online? Is there a "Programming language paradigms for Dummies" out there anywhere? :-)

Thanks,
- Jeremiah

Dear all,

the proceedings of PLAN-X 2007, the Fifth ACM SIGPLAN Workshop on
Programming Language Technologies for XML (held on January 20, 2007 in Nice, France, collocated with and just after POPL 2007) have been posted and are available for download (PDF): www.plan-x-2007.org

The 100-page volume contains eight research papers and four software demonstration descriptions. There should be something in there for everybody (who hangs out here, that is).

Enjoy,
—Torsten Grust (PLAN-X 2007 General Chair)

We have an argument on the Wikipedia article on closure on whether C# 2.0 and ECMAScript closures are "fully featured" closures or not. The crux of the argument against them being true closures seems to be that they do not capture lexical bindings of return/break/continue statements from the outer scope in either of those languages. You can read the entire discussion here

I would appreciate any comments on the issue from people familiar with the subject - figured of all places, this would be the best one to look for any such ;) - either in this thread, or on the discussion page of the article.

I thought this paper was one of the most interesting papers at POPL this year. In it, Malacaria uses information theory to provide a quantitative analysis of how much high-security information is revealed to an attacker by a particular program.

This is extremely interesting work, because without a framework like this I don't think information flow analysis can be used to analyze real programs for security holes. That's because to date it has been all-or-nothing: the analysis flags a warning if any information is leaked to an attacker, and this is much too restrictive a notion. For example, a password routine "leaks information" to an attacker, because if an attacker guesses a password and is blocked, they've learned that the random string they guessed is not the password. But as long as an attacker can't do a brute-force search, the program is actually secure, even though it technically leaks information.

However, in Malacaria's approach, you can make this idea of security more precise, by saying something like "a secure program leaks at most c bits of information", and this makes sense because there's a quantitative measure of information leakage.

Very cool!

R.W. Floyd's Turing Award Lecture “The Paradigms of Programming” is freely available in an online journal here. It is almost 30 years old, and still very much relevant. A quotation: To the designer of programming languages, I say: unless you can support the paradigms I use when I program, or at least support my extending your language into one that does support my programming methods, I don’t need your shiny new languages [...]

Here's an interesting paper recently mention in another thread: Total Functional Programming...

Abstract: The driving idea of functional programming is to make programming more closely related to mathematics. A program in a functional language such as Haskell or Miranda consists of equations which are both computation rules and a basis for simple algebraic reasoning about the functions and data structures they define. The existing model of functional programming, although elegant and powerful, is compromised to a greater extent than is commonly recognized by the presence of partial functions. We consider a simple discipline of total functional programming designed to exclude the possibility of non-termination. Among other things this requires a type distinction between data, which is finite, and codata, which is potentially infinite.

I presume that the bogus definiton of "fib" is a subtle reminder of the importance of eliminating bottom.

Anders Hejlsberg, Herb Sutter, Erik Meijer, Brian Beckman: Software Composability and the Future of Languages

This is an about an hour long video on channel9 about various .NET languages.

http://channel9.msdn.com/Showpost.aspx?postid=273697

I'm writing a Lisp-to-C compiler, trying to keep compiler and runtime very simple and close to C, because I want to embed the language into C applications, and use C libraries.

My closures are structs with a C function pointer and an environment.

Ideally, I'd like the language to be properly tail-recursive like Scheme; however, without resorting to techniques like trampolines, Cheney on the M.T.A., or putting the whole program into one function, it seems that the only possible thing is what BitC does:

Within any function f, calls to f that appear in tail position w.r.t. the body of f must be tail recursive.

[...]

Within a letrec, calls to any function bound in the letrec that appear in tail position within some function bound by the letrec must be tail recursive.

These requirements apply only to function calls whose destination can be statically resolved by the compiler at compile time.

What do you think about this restriction?

Does anyone have experience with the new tail call optimization of GCC, especially when making an indirect call via a function pointer?