Nov 242006
 

Here’s a conversation between James and I that started on dynamic languages and went on a tangent about languages, revolutions and evolutions.
Ponch: I’ve just been working on Naymz stuff lately. Also tinkering with Groovy and using it with an MVC
James Humphrey: haven’t heard any good things about Groovy
James Humphrey: hearing a lot of bad things though
Ponch: Like what?
James Humphrey: can’t remember exactly…I think I remember something about it was just a pain in the ass to code in it. trying to remember specifics
Ponch: I think Groovy is fine for what it is, but I prefer ruby mostly.
James Humphrey: I think one was, there’s no good IDE out there for it
Ponch: Eclipse is really good, even has debugging for groovy
Ponch: Ruby is way behind in the IDE space.
Ponch: Groovy is way ahead.
Ponch: Groovy is much easier since it is just converted to Java. Ruby is different because it is a lot more dynamic
Ponch: So, you can’t really make a java class out of a ruby class
James Humphrey: I dunno, can’t really remember. I think most of the issues I read were programmatic. You know, loosely typed scripting issues; too much power given to the programmers, convention issues, etc
Ponch: haha those dudes would definitely hate ruby then.
James Humphrey: which dudes?
James Humphrey: oh, the dudes I read the artices ffrom?
Ponch: There are a lot of good articles about how loosely typed languages sometimes are better for large projects.
Ponch: Chcek out this thread I started at Groovy user list: Here’s the thread list that shows the replies:
http://www.nabble.com/codehaus—Groovy-f11866.html
and here is the post:
http://www.nabble.com/Trying-to-get-a-sense-for-dynamic-groovy-tf2665364.html
Ponch: It might be the largest thread. not sure though. hehe
James Humphrey: wtf is ‘duck typed’
Ponch: it is a loosely typed term. Here’s an example:
class Foo {
def foo() {}
}
class Bar {
def foo() {}
}

def someMethodThatCallsFoo(obj) { obj.foo() }

someMethodThatCallsFoo(new Foo())
someMethodThatCallsFoo(new Bar())
Ponch: I can call the method with any object that has that method. Only way to do this in Java is use an interface and have everything implement that interface and then the method takes the interface. Or using reflection (eeck!)
Ponch: That’s why most folks favor naming conventions heavily in dynamic languages, that way you can call methods that use length() and pass them String, Array, List, Map, anything that has that method on it.
James Humphrey: this is exactly why I hate scripting languages. I don’t understand any of this nor do I want to
Ponch: Man your already an old java meiser (sp?) hehe
James Humphrey: no, I just don’t like loosely typed languages. Usually, scripting languages are loosely typed. It’s just too hard to figure out what’s going on
James Humphrey: there’s just way too much freedom to write bad code and causing pain for maintaners
James Humphrey: er maintainers (ppl who do maintenance on the code)
Ponch: That is the most common misconception I think. Most people feel that way about them
Ponch: The freedom allows for less coders, less coder and easier maintenance (usually).
Ponch: sorry less code
James Humphrey: imo, there’s a programming semantic continuum. On the far right is DSLs and the far left SCripting languages. In the middle you have things like Java, C#, etc.

Imo, we should be moving more towards DSLs. SCripting languages are just too hard to figure out, maintain, and document. Sure, it’s easy to program in it…that’s the problem though
James Humphrey: contiuum is probably a bad model
James Humphrey: evolution maybe. dunno, you know what I mean though I think
Ponch: Many believe that DSLs are built on top of dyNamic languages.
Ponch: You can find a lot of information about using ruby to build DSLs very quickly
Ponch: To me it is more about features of a language because in the end they all do the same thing, compile down to assembler.
James Humphrey: I agree with that. I just think that you can evolutionize languages without making them loosely typed
Ponch: You can go both ways in evolution. C# is evolution on Java. Ruby is evolution on Perl
James Humphrey: and, you’re right. Honestly, I could care less about what’s underneath the language (usually) because in the end I know that it’s all assembly anyway. What’s important to me is not just how it’s coded but how it’s maintained
Ponch: my motto is use the right tool for the job. I don’t like writing java to handle a simple command line search and replace. Much better to use ruby. Don’t like using ruby to build a text parser, to slow.
James Humphrey: and, in my limited experience, it just seems to me that maintaining scripting languages are a pain in the ass because you never know what you’re going to get. One person does it this way, another does it that way, which leads to confusion
Ponch: Usually that doesn’t happen though.
Ponch: The code is concise enough that to understand it takes very little time.
Ponch: I figure the more tools I have in my toolkit the better off I am.
Ponch: That is why I’m learning groovy and python and c#, so I can figure out how they all work in case I need them
James Humphrey: it’s like, why create the allen wrench? now I have to have more tools in my toolbox to get a job done to maintain something. ;). I think there’s a fine line with evolving and just creating more shit
Ponch: haha you definitely carry a sentiment that many others do. The problem in our business is productivity. How can I get something done faster, better, more well tested, more maintainable, etc. Java just doesn’t fit the bill in all cases. Nor does C++ or Ruby or anything. You could use Java to make a 3D game, but you’ll probably spend more time doing it, and have worse results. The key is to figure out how to be the most productive and often that means looking at lots of different languages, frameworks, tools, IDEs, etc.
James Humphrey: I think scripting languages have their use, don’t get me wrong. I also think that they are probably a natural process to evolution within the software world. I just don’t think they are the revolution that we’re all waiting for
Ponch: I agree with that. I don’t think there ever will be one of those.
Ponch: It will just be a constant refresh of ideas and principles
James Humphrey: like anything yeah, but I disagree. I think something (like c, like java) will come to revolutionize the way software engineers do things
Ponch: maybe, I wouldn’t discount that, but I don’t think Java was a revolution. It was just C++ with a few tweaks.
(09:42:06 AM) James Humphrey: maybe yeah. I dunno though: garbage collection, exception handling, pure OO….there wasn’t much of that around, or at the very least there wasn’t anything getting a lot of visibility
Ponch: You are right about those things, but C++ had garbage collection it was just manual and dangerous, it had exceptions they just sucked and Java still isn’t pure OO because it has primitives (unlike ruby).
James Humphrey: true, I should have said ‘automatic garbage collection’ (which isn’t all that to be honest). And, yeah, java primatives…/shrug
Ponch: Maybe a revolution will happen, but it will be something like IAL, which BTW sounds like Isle, which is kinda a cool name.
James Humphrey: whoa, never looked at it that way before
Ponch: A DSL for a very common domain (web aps)
James Humphrey: that would rule
James Humphrey: it’s also very very very very fucking complicated. even with your and my experience combined, we can’t figure it out
Ponch: probably not completely, but we can make good steps and then get people interested and helping out.
James Humphrey: and we have over what…at least 15 years combined web experience (I have 9 or 10 I think)
Ponch: I started building web apps in 98 I think.
Ponch: Maybe 97. hmmm not sure
Ponch: so 8-9 years for me
Ponch: BTW this conversation is really good. Mind if I post it?
James Humphrey: sure, I don’t mind
James Humphrey: good luck organizing the flow of this though
James Humphrey: hehe
Ponch: I was just gonna copy and paste. ;)
James Humphrey: haha
James Humphrey: ugh
James Humphrey: kinda funny…you spend your ‘free’ time blogging. I spend my ‘free’ time playing games
Ponch: yeah, moved from games to dork-dom
Ponch: hehe

Nov 152006
 

SOA is probably the worst breed of marketing because it hides the fact that it is distributed and then people not only shoot themselves in the foot, but blow their whole freakin’ leg off!

Nov 152006
 

Ben Alex and I have been working recently to finalize the inclusion of patch I made for getting AJAX login to work with ACEGI. After a number of very constructive conversations and looking at some of the new features in 1.0.3, Ben and I decided to remove the patch and instead leverage a pure configuration driven approach, which does leverage mostly redirects to handle AJAX authentication.

I’ll be putting together an article for how to accomplish the AJAX login today and initially posting it here as well as possibly over at JavaLobby. It will cover the steps required to get AJAX login working with ACEGI 1.x and will also cover a feature in 1.0.3 that allows a forward instead of a redirect in one instance.

Nov 062006
 

I have a correction for the 8 fallacies of distributed computing that I think is relevant and as far as I can tell it has not been widely discussed.

3. Bandwidth is infinite

I think it is more appropriate that this be

3. Resources are infinite

Bandwidth implies a networking constraint in which data cannot flow via the ethernet card at an infinite speed nor at an infinite amount. Bandwidth is normally measured in bytes per second, so this interpretation seems accurate.

Resources on the other hand allow this fallacy to encompass so much more than simply network bandwidth. The network is a resource as is disk space as are file handles and sockets. Therefore, expanding this fallacy into a larger category you can start to include distributed computing problems such as finite database connections shared across machines, fixed number of TCP endpoints per machine (inbound and outbound) and so many others.

If you are worried about the term resources being too general than this can be adapted to:

3. Network resources are infinite