08.01.2006 07:29:45 PM (Last Update: 12.09.2009 09:56:38 AM)
The 2nd day of Lang.NET 2006 started with a talk from Gilad Bracha on dynamically typed languages on the JVM. This was an interesting talk in that it was not specifically about any Microsoft/.NET technologies, although the discussion was definitely relevant (especially given the interest in dynamic languages on the CLR). Bracha has a good sense of humor about being "behind enemy lines". He started talking about freedom of choice, and how the JVM "appears" to have freedom of choice...so long as the language is Java (or a statically-typed language). He discusses how the JVM must improve to support dynamic languages. He mentioned adding a new byte code called invokedynamic along with supporting hotswapping. He said the main goal is to have "native" support for dynamic languages. Currently there are four byte codes for method invocation, but none are geared for dynamic language scenarios. Having invokedynamic would help, but it also relaxes verification rules, which may lead to other problems. He also mentioned that method overloading adds all sorts of complexities and headaches for dynamic languages as it's really hard to figure out which method should be called. Furthermore, throwing multiple inheritance and multiple dispatch into the mix makes things even harder. He then dived into the hotswapping idea, where code is manipulated as the program executes (which is typical of dynamic languages). He said these languages are very addictive, but the JVM is currently not set up to handle this feature. Supporting hotswapping is not a trivial task, and there's a trade-off to support dynamic code relative to maintaining type safety. He said that there are no firm commitments from Sun on when invokedynamic and hotswapping will be implemented. He mentioned invokedynamic is not that hard to do, but hotswapping is much more complex. One way to implement this feature is to mark certain classes as "hotswappable" - only methods on these classes can be mutated, and these methods can only be called via invokedynamic. Near the end of his talk, the discussion spun off into issues that I found a bit hard to track - I couldn't tell if people were sublty trying to dig Sun and vice versa. He ended his talk saying that even with invokedynamic and hotswapping, multiple inheritance is still not addressed, and Bracha said that MI will probably not be supported in JVM in the near future. He said that Sun is very interested in having more languages (esp. dynamic languages) run smoothly on the JVM.
Next up was Gary Flake, who talked about the "imminent Internet singularity". I read Flake's "The Computational Beauty of Nature" book years ago so I was really looking forward to his talk (although I had perused his Powerpoint talk before I came to Lang.NET 2006 so I had a vauge idea what he was going to cover). His premise was that, right now, this is the best time to be a computer scientist. He defined the term "singularity", which is that technological improvements will improve so fast the future cannot be knowable. His focus was on the "Internet Singularity", which he said was "more grounded in reality". He went through four points to "prove" his case (or, as he said, give his argument more credibility). The first one was democratization and "macro-ization" - i.e. CPUs keep getting faster, cell phones have more processing power than supercomputers years and years ago, etc. He said that content is now democraized - i.e. people are no longer just content consumer, but content creators as well. This also applies to commerce, communities, etc. Essentially, the differences between "amateurs" and "professionals" are diminishing. His second point is based on power laws and "long tails". Power laws basically show that there's more exponentially more small things than large things (think distributon of bio-mass - whales vs. bacteria). He stated that some power laws have "long tails" - his canonical example is the recording industry (few "Britney Spears" but lots of vast unsigned performers). The "tail" can sometimes have more "weight" than the head - in other words, consumers are becoming producers, and the small producers may outweight the big producers. His third point was on ecosystems and network effects. Essentially, critical mass is when the value of a network increases with the number of participants (e.g. telephones and OS development). Reinforcing networks make the whole bigger than the sum of its parts. His last point was called "the innovator's dilemma". The issue is that "late arrivals win because they can take optimizations and apply them to the head". So the problem is that they need to kill their own business before someone else does. This is very relevant in the online world. He used the example of his work at Overture and paid searches, which at the time was considered stupid, but now is the basis of Google's revenue. Basically, "the process of societal evolution is itself changing". He summarized these points that "relationships between objects will inform our understanding of the world". He said that the Internet is a "fun-house" mirror of the world, and because of this analogy, we can use the Internet to continually evolve our knowledge in a feedback loop (of sorts). Flake's enthusiam was easily seen, although I find it a bit odd to see his discussion at a seminar on programming languages, although his concepts can easily be applied to languages (during an answer he said "Visual Basic democratized programming"). He also called AJAX a "train wreck and we should be embarrased by it" - I completely agree. He also mentioned PhotoSynth as an example of what he's working on. I wish Flake would've stuck around over lunch - I wanted to thank him for writing his computational book, but he took off before I could talk to him.
After a brief break (which included an interesting talk with John Lam - that was 30 intense minutes!), James Lapalme talked about modeling for hardware and software systems. He said people used to use HDLs to describe and simulate circuits, and how those concepts (modules, ports, etc.). Today, hardware systems are much more complex, and now we use system-leve description languages (SDLs) over HDLs. His focus is on ESys.NET and SoCML, a SDL targeted for the CLR to automatically pick up the properties of the CLR (garbage collection, reflection, etc.). I had a hard time following this talk - I really didn't get what Lapalme was getting at. Having an example would've been extremely beneficial.
Marcus Lorez followed Lapalme with a talk on Hydra, which is a tool to translate source code to different languages. He said they created a modified C# language called H#, and targeted Java as a retargetable language. Frankly, I don't know why he did this, as you can use Reflector and plug-in a language translator to produce code in a given language. This isn't always 100% code preservation, and this also requires compilation first (as Reflector doesn't read source code), but this seems like an easy approach. Also, Lorez's presentation style just wasn't that good. He pretty much read off of his slides and had almost no energy behind his delivery.
After the lunch break (where I saw someone's personal project of translating C# code to JavaScript so you could run it client-side - kind of an odd yet slick idea), Bradley Millington talked about Blinq, which is a tool to do data-binding in ASP.NET applications from DLinq object schemas. He went through a quick demo, creating a web application against the Northwind database. He stressed that Blinq is meant to be a simple demonstration tool. He talks about the steps that Blinq goes through to create the forms correctly. Blinq also support sorting, filtering, etc. Blinq seems like a nice and simple code generation tool for easy web applications, but I wonder how this will work for some wicked database schemas I've seen in the past at some clients.
Next, Shriram Krishnamurthi talked about programming and verifying interactive web applications. He started by showing how web applications pretty much suck because page navigations are notoriously messy. This is the well-known issue of statelessness (or scalability) on the web. This leads to many dependencies and this is (potentiall) very fragile. Krishnamurthi said that continuations would solve the problem. Someone asked a good question that "isn't the browser the problem?" Krishnamurthi didn't agree, but did agree that the web APIs need to be used correctly and developers really shouldn't have to worry about manipulating strings. Krishnamurthi dove into some examples of what it's like to program in this "better" API - it's not webRead, it's send/suspend (or send/finish). Krishnamurthi has created a web server that implements it called the Continuation Server which is written as a "boring functional program". He had some harsh (yet funny!) cuts on functional programming (but since I'm not a functional programmer I couldn't fully appreciate the cut on monads). Krishnamurthi moved to his new language, Flapjax. He did some simplistic behavior-attaching examples to start, and then he moved to a deli.cio.us scenario. I didn't quite see how this solved the web application problem he showed at the beginning, but Krishnamurthi definitely believes in what he's doing.
Paul Vick followed Krishnamurthi with a talk on VB. He began with the Linus Torvales quote that's going around these days about his view on VB. He then dove into what's going into VB 9: query and data interchange extensions. VB 9 will support lambda functions - interesting! He talked about the query expressions and how this has been a big issue for VB 9 as VB developers usually know SQL and it's important to express that. He also showed error issues they ran into - the exception message was overtly verbose and trying to find the problem was really messy. He showed a demo of XML integration into VB. I really didn't know what to make of it - my initial impression is that it looked clutzy. It's cool because I could imagine what the code WOULD look like using XmlDocument or XPathDocument and Vick's code was much more succinct. He made an error during his demo and it became very clear that developers will need to keep code context in mind ("am I in an XML context? Better get my <%= out!"). He talked about the future of VB after version 9, and he stated that they're looking at adding more dynamic extensions to VB. This makes VB sound like it's "going back 15 years" to old versions of VB, where it's like a dynamic language. He showed a prototype of an Eval() function, very similar to what was shown yesterday in the IronPython demo. He also showed an app called Live Stage, where one could execute VB-like code like IronPython.
The last speaker of the day was Miguel de Icaza, who talked about Mono. He talked about the motivation behind the Mono project - basically he was on a Linux project written in C that took way too long to do, and C# looked like a good alternative. Their original goals were small, but as everyone knows Mono has grown way beyond a simple C# compiler. He talked about the libraries they've built, like ASP.NET, Evolution#, and OpenOffice. It was interesting to note that Mono's version of NGen (AOT) may actually hurt you in some situations, but that's also true of NGen. He went through the historial releases (1.0 - "T-Bone", 1.2 - "Rump Steak", 2.0 - "Sirloin"). It was amazing to hear de Icaza talk about his complete lack of knowledge of ADO.NET and SQL; then again, who knows everything? de Icaza is a funny guy - when he was showing the photo browsing app, he kept looking for a better picture because he wanted to avoid showing "ugly people". The GUI toolkits are Gtk#, Windows.Forms, and Cocoa#. He demonstrated MonoDevelop, and showed how one creates a Gtk# application (which was really cool to see). He showed Reflector working on his system. Being someone who has never used Linux, this talk was very interesting - I was really impressed by what he was doing during his demo.
Printer-Friendly Version