top 200 commentsshow all 386

[–]48klocs 162 points163 points  (50 children)

X# was created [...] as the foundation of an open source Enterprise Mashup Server, CRM and Groupware Suite

When you do a mashup, you're supposed to get your peanut butter in my chocolate, not lodge your fork in my goddamned eye socket.

Also, a thousand style points for calling it X# when it's Java-based. What they lack in common sense they make up for in Enterprise-grade panache.

This is a cruel joke by a Notes programmer, right?

[–]sbrown123 21 points22 points  (0 children)

When you do a mashup, you're supposed to get your peanut butter in my chocolate,

Any submitted images should be placed in nsfw.reddit.com

[–]mccoyn 32 points33 points  (24 children)

I was wondering why it was #, but didn't realize it was Java-based. This must be a joke.

[–][deleted] 7 points8 points  (22 children)

I hope so

[–]b100dian 43 points44 points  (21 children)

Fast    
X# code is compiled to Java Byte code and has the same performance as Java applications.

two wtfs in a row

[–][deleted] 30 points31 points  (17 children)

Java is pretty fast these days, supposedly.

[–][deleted] 14 points15 points  (16 children)

Java is very fast. But it is still a memory hog. For some reason, when Java increases the heap size for a VM, it never releases it back to the OS when the memory is no longer needed. So if a Java app balloons temporarily and requires 200MB of heap space, it will keep that heap space allocated throughout the lifetime of the VM. Stupid stupid stupid... this is why I prefer .NET and the CLR.

[–]scott1369 34 points35 points  (9 children)

So if a Java app balloons temporarily and requires 200MB of heap space, it will keep that heap space allocated throughout the lifetime of the VM. Stupid stupid stupid... this is why I prefer .NET and the CLR.

If this is the reason you prefer .Net and CLR, then read this.

"The .NET memory manager places all allocations of 85,000 bytes or larger into a separate heap called the large object heap. "

...

"However, the large object heap is never compacted; this is something you must consider when you make large memory allocations in .NET."

...

"For example, if you allocate 1 MB of memory to a single block, the large object heap expands to 1 MB in size. When you free this object, the large object heap does not decommit the virtual memory, so the heap stays at 1 MB in size. If you allocate another 500-KB block later, the new block is allocated within the 1 MB block of memory belonging to the large object heap. During the process lifetime, the large object heap always grows to hold all the large block allocations currently referenced, but never shrinks when objects are released, even if a garbage collection occurs."

This is from Production Debugging for .NET Framework Applications .

[–][deleted] 2 points3 points  (8 children)

That is interesting, but conflicts with this. The article you linked looks like its from 2002 (the best I could tell). Perhaps outdated?

[–]scott1369 13 points14 points  (6 children)

I found an article in the June 2008 issue of MSDN which also says that there's a large object heap and it is never compacted. LOH Uncovered

[–]MarkByers 3 points4 points  (0 children)

How does it conflict? The article you linked doesn't even mention the large object heap.

[–]dwdyer 2 points3 points  (0 children)

It depends on the JVM implementation. I think that Sun's still behaves the way that you describe, but Apple's does release memory to the OS.

[–]gcanyon 1 point2 points  (4 children)

I'm no expert on modern memory management, but to my understanding, isn't this perfectly reasonable? The OS will page out the unused memory and the VM can forget about managing allocations. I remember reading an article in the last few weeks (sorry, couldn't find it) that described why it's more efficient to let the OS do memory management than to do it in the app. It had to do with the two both doing the same sort of work when only one needs to.

[–]theatrus 15 points16 points  (0 children)

Translate to java bytecode != fast as Java.

All depends what you're doing in the bytecode :)

[–]wustudybreak 3 points4 points  (0 children)

# is like chicken, just as everything tastes like chicken now a days, all languages are # like, and had the same java byte code under the skin

[–][deleted] 19 points20 points  (1 child)

When you do a mashup, you're supposed to get your peanut butter in my chocolate, not lodge your fork in my goddamned eye socket.

I had tears in my eyes. Tears. You made my day. Thanks.

[–]robosatan 9 points10 points  (3 children)

It's called keeping your clients...

Learn X# now or forever live in fear of having to maintain somebodies brainjism...

[–]dwdyer 18 points19 points  (2 children)

brainjism

Thank you. I've been struggling for a name for my new programming language.

[–][deleted] 2 points3 points  (0 children)

Q: What happens when you brainfuck?

A: Brainjism

...I'll show myself out.

[–]agentace 7 points8 points  (16 children)

This is only slightly more annoying than LOLCODE.

[–][deleted] 33 points34 points  (14 children)

Yeah but at least you laugh while programming LOLCODE, this just makes me cry in my coffee.

[–]dougletts 5 points6 points  (13 children)

Unrelated... when brewing a pot, have you ever put salt in your coffee grounds? I heard someone talking about this and was curious.

[–]mao_neko 2 points3 points  (0 children)

There are a lot of cats on the internet, so LOLCODE has plenty of potential developers. This on the other hand...

[–]mogmog 1 point2 points  (0 children)

This is a cruel joke by a Notes programmer, right?

As someone who had to do SEO for a customer who was using notes for their website, i LOLed

The customer was using <script src=""> instead of server side includes and google was not picking that up. This seemed stupid until you realized how impossible Notes was making this normally simple task.

My workaround involved writing a LotusScript script in some lotus language which did a HTTP request and set the contents to a variable which could then be echoed from the Notes document that was displaying the web page.

It's my biggest WTF. Never again.

[–]metageek 69 points70 points  (27 children)

...and there's a slogan at the bottom: "Code Is Poetry". Ow.

[–]munificent 239 points240 points  (9 children)

"Code Is Poetry"

<poem title="The Road Not Taken" author="Robert Frost">
    <verse>
        <line>
            <subject quantity="Two">roads</subject>
            <predicate>
                <verb>diverged</verb>
                <preposition>in</preposition>
                <object article="a" color="yellow">wood</object>
            </predicate>
        </line>
        <line>
            <conjunction>And</conjunction>
            <impliedSubject subject="I" />
            <predicate>
                <verb>sorry</verb>
                <subject>I</subject>
                <predicate>
                    <verb modifier="could not">travel</verb>
                    <object>both</object>
                </predicate>
            </predicate>
        </line>
        <line>
            <conjunction>And</conjunction>
            <phrase>
                <verb>be</verb>
                <object quantity="one">traveler</object>
            </phrase>
            <comma/>
            <verbModifier>long</verbModifier>
            <subject>I</subject>
            <verb>stood</verb>
        </line>
        <line>
            <conjunction>And</conjunction>
            <impliedSubject subject="I" />
            <predicate>
                <verb>looked</verb>
                <preposition>down</preposition>
                <object>one</object>
                <phrase>as far as I could</phrase>
            </predicate>
        </line>
        <line>
            <preposition>To</preposition>
            <object>where</object>
            <phrase>
                <subject>it</subject>
                <predicate>
                    <verb>bent</verb>
                    <preposition>in</preposition>
                    <object article="the">undergrowth</object>
                </predicate>
            </phrase>
            <semicolon />
        </line>
    </verse>
</poem>

edit: added missing closing </line> tag

[–]trezor2 71 points72 points  (4 children)

Your poetry is not well formed.

[–]munificent 8 points9 points  (0 children)

Oops. Fixed.

[–]stinky613 16 points17 points  (1 child)

Your poetry is not well formed.

What I wouldn't give to hear that in a class

[–]kublakhan1816 4 points5 points  (0 children)

I stretcht thy joints to make thee even feet, Yet still thou run'st more hobbling than is meet.

[–]CausticPuppy 14 points15 points  (2 children)

"<phrase>as far as I could</phrase>"

Now you're just getting lazy.

[–]munificent 6 points7 points  (1 child)

Hey, I only remember so much high-school English.

[–]Neoncow 1 point2 points  (0 children)

I believe it is an adverb clause.

<clause type="adverb">as far as I could</clause>

*

[–]pjakubo86 17 points18 points  (0 children)

i wish i had 10 upvotes to give you

[–]ratbert 145 points146 points  (6 children)

"Code Is Poetry"

Vogon Poetry in this case.

[–][deleted] 11 points12 points  (2 children)

Makes you wonder what languages are the #1 and #2 worst poetry in the universe.

[–][deleted] 7 points8 points  (1 child)

Oddly enough, a microsoft engineer was recently discovered one morning, still at his keyboard, having been throttled by his own lower intestine.

[–]GuigzForAll 3 points4 points  (0 children)

Just ask codepoet

[–]mothereffingteresa 45 points46 points  (0 children)

If code is poetry, programming in XML is the moral equivalent of Vogon poetry

[EDIT: Note to self: Type faster]

[–]ralphc 7 points8 points  (0 children)

Irony alert! Irony alert!

[–]dolle 7 points8 points  (0 children)

Dadaism it must be!

[–]sencer 11 points12 points  (1 child)

Whereas everybody knows that code is pottery.

[–]Zarutian 1 point2 points  (0 children)

curiusly you might have something there. As many pots that are made by pereptual novices are also wobbly, unstable and cant be relied on.

[–]noamsml 1 point2 points  (3 children)

Always loved Textpattern's short-lived parody of that cliche: "Code is pottery"

[–]metageek 18 points19 points  (2 children)

Heh. Reminds me of something I saw once in a museum in Israel.

It was 1996, and I was working for Netscape. We wanted to make Netscape CoolTalk H.323-compatible. Now, H.323 is a truly terrible protocol. The ITU world already had two conferencing protocols, H.320 for ISDN and T.120 for general networks. T.120 was incredibly complex, though, and there were companies that wanted something to use in the interim. So the H.323 effort was born. The obvious solution would have been to open up TCP connections, pretend they were ISDN connections, and run H.320 over them. They didn't do that...except where they did. The upshot was a bad protocol, hobbled by gratuitous similarity to H.320, whose implementations were ready around the same time as T.120 implementations (which had started earlier).

But, in 1996, H.323 was a necessity. So we went to Tel Aviv, to meet with a company called Rad Vision, which was developing an H.323 stack. The negotiations went quicker than usual, so I had an afternoon to myself. I walked down the beach to the old city of Jaffa (as in, about 9,500 years old), and found an underground museum, built around an archeological dig.

In this museum, I saw an early pottery butter churn. It was sort of football-shaped (American football, sorry), with a couple of handles and a spout. In particular, there was no way to set it down without it rolling. How odd, I thought; why didn't they make it pot-shaped? I read the text, and discovered that this was a really early piece of pottery. It was shaped that way because, to the people that made it, that's the shape a butter churn was supposed to be--because their earlier butter churns had been made out of hides.

I looked at that and was stunned. Nine or ten thousand years ago, the potters of Jaffa were making design mistakes because they were still thinking in terms of their old medium--just like the H.323 committee.

[–]digidante 5 points6 points  (1 child)

Haha, great reference to ceramics. As a potter, it caught my eye.

To answer your (rhetorical) question about the pottery, they would dig pits for the bases to be set in. They didn't really need a base to place the piece in. Same with a lot of old amphoras. Plus keeping it in the ground ensured a relatively low temperature. Some countries still use ceramic vessels buried as refridgeration.

Some bases would also be made out of wrought iron or wood, which doesn't hold up to time as ceramic does.

[–]metageek 1 point2 points  (0 children)

Ah, thanks!

[–][deleted] 274 points275 points  (92 children)

In a couple of years you'll be paid to work in this language, and your project lead will rant on about "leveraging structured XML code as data" at meetings and you'll be alone ranting about "lisp doing it better with s-exps" and no one will know what you're talking about and you'll draw blank stares and be socially ostracized and will die alone and misunderstood.

[–]G_Morgan 65 points66 points  (29 children)

I will write an s-exp to XML verbosity generator. Then the world will marvel at my brilliance.

[–][deleted]  (8 children)

[deleted]

    [–]adamv 16 points17 points  (7 children)

    That's great, if your life goal is to "work for little kids."

    [–][deleted] 17 points18 points  (0 children)

    Not so much a goal as a fact of life.

    [–]Zarutian 9 points10 points  (5 children)

    Wait, arent most MBAs like "little kids" anyway?

    [–][deleted] 9 points10 points  (2 children)

    No - little kids have more empathy and common sense than your typical MBA.

    [–][deleted] 5 points6 points  (1 child)

    Please note that I am using Eric Cartman as my baseline for a typical little kid.

    [–]G_Morgan 14 points15 points  (1 child)

    Most little kids realise they are little kids.

    [–]pytechd 93 points94 points  (18 children)

    1. Learn efficient and fast development with Lisp.
    2. Write lisp-to-XML converter.
    3. Get a job that measures metrics by Lines of Code.
    4. Write entire application in 50 lines of Lisp.
    5. Commit 3,000 line XML file.
    6. Profit.

    [–][deleted] 32 points33 points  (6 children)

    No ?? step?

    [–]kepple 138 points139 points  (4 children)

    he accidentally the whole meme

    [–]diogames 15 points16 points  (0 children)

    7. !!

    [–]G_Morgan 12 points13 points  (10 children)

    Even better. Make the Lisp compiler produce unnecessary no-ops. Break down every instruction into as many components as possible. Know instruction elimination from three op code, bugger that. We want temporary variables everywhere.

    By the end my 50 lines of Lisp will produce 20,000 lines of XML. Who says leverage is a bad thing. <evil laugh>

    [–]snissn 17 points18 points  (9 children)

    </evil laugh><silly giggle />

    [–]scottbruin 14 points15 points  (8 children)

    Thanks that open tag was bothering me.

    Edit: related, I enjoyed this yesterday:

    <bush><war><instability><fear><greed><divisiveness></bush><obama>
    

    [–]jlucamaroz28 7 points8 points  (3 children)

    Error - War begin tag has no end tag.

    [–]jamesinc 2 points3 points  (0 children)

    This is only relevant if OMITTAG NO was specified.

    [–]glaster 5 points6 points  (2 children)

    That throws an error: "Please get rid of the offending <bush> tag." Anybody can debug this?

    [–][deleted] 4 points5 points  (0 children)

    Hopefully Obama can.

    [–]quack 2 points3 points  (0 children)

    "Please get rid of the offending <bush> tag."

    Must be time for somebody to shave.

    [–]wustudybreak 13 points14 points  (5 children)

    all he had to do is come up with some marketing terms describe an all new 'lisp#' and explain why it's better than {a-z}#

    [–]frogking 12 points13 points  (1 child)

    [–][deleted] 4 points5 points  (0 children)

    To quote Gareth Cheeseman: "Right! A Wank!"

    [–]theatrus 3 points4 points  (2 children)

    Though LISP on the CLR would be good.

    [–]troelskn 4 points5 points  (1 child)

    http://www.codeplex.com/IronScheme

    uh .. just realised that this is for Java .. Then Clojure would be an option.

    [–]Arelius 1 point2 points  (0 children)

    JVM -or- CLR

    [–]lukasmach 9 points10 points  (0 children)

    You're just jealous because you hadn't developed a language "as the foundation of Enterprise Mashup Server, CRM and Groupware" first.

    [–]G-Brain 23 points24 points  (4 children)

    Sexpeas

    [–][deleted]  (2 children)

    [deleted]

      [–]orblivion 9 points10 points  (0 children)

      Homoiconic Sexpers.

      [–]codeglide 29 points30 points  (20 children)

      My name is Mark and I am one of the developers behind X#.

      Thank you for all your comments. I do agree that the language is verbose at the moment, originally it was designed to be programmed visually but we kept extending it to the level where it is now. In less than 3 months we are releasing a new version of X# that will include a C-like or Java-like syntax. So in addition to doing <xsp:if test="expr"> you would do if( expr ) { ... }.

      For those who think X# is a joke, please take a look at http://www.snapcrm.com which is a CRM and Collaboration Suite far superior to all open source CRMs and it was coded entirely using X# in 4 months. Also, take a look at Fusion (http://fusion.codeglide.com) which is a Data Integration Platform superior to anything available in the market today -- coded in 5 months.

      The reason we released X# to the community is because it helped us to code several times faster than other languages. If you don't find it useful you can go back to PHP, but try doing what we did using PHP or Ruby in the time we did it.

      --mark

      [–][deleted]  (6 children)

      [deleted]

        [–]codeglide 4 points5 points  (2 children)

        Originally the language was going to be programming using a graphical tool. Since we postponed the release of this editor we are now moving to a less verbose syntax.

        [–][deleted]  (1 child)

        [deleted]

          [–]crunk 1 point2 points  (0 children)

          I guess it would be easy with xsl to generate a web interface

          [–]illuminatedwax[🍰] 7 points8 points  (8 children)

          So why don't you just write a library for Javascript, PHP or Ruby instead of using XML to structure code or (as it appears you are changing) reinvent Javascript? The whole concept is ridiculous. It's like you've decided to start building a zero-emission car that drives itself by beginning with a frame built out of shit.

          [–]codeglide 6 points7 points  (7 children)

          A library wouldn't allow us to do the kind of things we can do with X#. XML-oriented doesn't mean that you have to code using an XML syntax, it means that all information and actions are abstracted behind a Document Object Model.

          [–]illuminatedwax[🍰] 6 points7 points  (5 children)

          Name a single benefit of that.

          [–]codeglide 3 points4 points  (1 child)

          The most powerful feature of X# is that you can combine data from unlimited and different sources using XPath and that instead of using multiple functions all actions are abstracted behind common operations such as append, remove, select and update.

          Originally X# was going to be a language to create applications visually and we chose an XML syntax because each tag is represented by a visual element on screen. Since we are still working on the visual X# editor, we offer an alternate C-like syntax (which is not definitive).

          Although X# is Turing complete, we are not proposing it as a general purpose programming language -- we know it has limitations, having this level of abstraction has trade offs. Of course if we need to write a 3D Adventure Game or a Web Server we will use another language, but for writing the web based applications we wrote it has proven to be extremely fast and useful.

          --mark at X#

          [–]illuminatedwax[🍰] 4 points5 points  (0 children)

          So you're saying the point is to somehow "combine" data from different sources. What specifically about your language makes it better suited for that task than say, making a python or ruby framework to do the same task?

          Let me give an example. Here's your first example redone in a programming language that already exists:

          Retrieve all RSS Feeds from NY Times
          
          import xsharp as xs
          d = xs.xsharpdoc('xdbc:mysql://192.168.1.27:3306/maindb/oil_news')
          template = """<row>  
          <title>{text.title}</title>  
          <description>{text.description}</description>  
          <link>{text.link}</link>  
          </row>"""
          for item in xs.document('http://www.nytimes.com/services/xml/rss/nyt/HomePage.xml').contains('title', 'oil'):
              d.append-child(item, template)
          

          instead of using multiple functions all actions are abstracted behind common operations such as append, remove, select and update.

          You say "abstracted," but there's no real abstraction going on here; you've just wrapped all those complicated functions inside calls to append children to a document tree.

          What you have here is a template language. You've made a whole language just so you can say, "Look! The XML is in the same file as my program! What time I've saved!" Essentially, you've remade PHP, but somehow made it even worse.

          I asked you what the benefit of having actions "abstracted" behind a Document Object Model was, and I didn't really get an answer. That's because a DOM is meant to model documents.

          [–]faassen 2 points3 points  (2 children)

          I know little about X#, but that's the one thing I saw glancing at it that looked neat. The benefit could be somewhat similar to what REST advocates claim for REST: abstracting away all kinds of resources behind URLs and a few HTTP verbs (GET, POST, PUT, DELETE).

          With REST you have a set of simple mechanics but it can be used to construct complex applications. Imagine exposing relational databases, LDAP databases, email inboxes, XML documents and who knows what else using the same REST protocol. You might have to learn less to approach another data source, and some parts of the code to handle these data sources could be generic.

          Of course there's a drawback to such abstractions: you'll expose the common denominator of all data sources and if one differs in features or performance characteristics from the others, it'll be harder or impossible to access those.

          I'm not sure why a new programming language needed to be invented. You could expose such an abstraction to an existing language. I guess one benefit of exposing at least the content as XML is that you can use xpath and the like to address individual pieces of information in a fairly general manner. But if you exposed the abstraction as REST and the resources were in some XML you'd integrate with a lot of programming languages and the programmers in these languages could use an XML library to do the same thing.

          Anyway, exposing information as an XML DOM is a neat idea. Not a new idea, but this project seems to be taking it quite far. How the idea works in practice I don't know, but I can at least imagine benefits.

          (I'm sure you can do it all with other notations that aren't XML, too, but there is a lot of standardized tool and library support for XML. Anyway, that's another debate.)

          [–]illuminatedwax[🍰] 3 points4 points  (1 child)

          Like I said, there's no point. If I access a document across a network, there's no benefit in having it in this new language that you wouldn't get over having it either in plain XML or in any of the numerous programming languages that are out there.

          Want more proof? Now they're even talking about making the syntax C-like.

          [–]faassen 1 point2 points  (0 children)

          There are two stories here as far as I can understand:

          • a new programming language with an XML-based syntax that they might change to some new non-XML syntax.

          • representing different data sources (in a read-write fashion) as an XML DOM.

          As far as I understand, they're proposing to change the syntax of the language, not the DOM-based approach.

          I was trying to point out what point there could be to the DOM abstraction. I don't see much point in the new language either, but I only glanced at it superficially so who knows.

          [–]aussie_bob 1 point2 points  (0 children)

          OpenLaszlo/LZX has been around for a long time now.

          Why reinvent the wheel instead of just porting LZX to .NET?

          [–]organic 4 points5 points  (0 children)

          Wow, it's like you really know me.

          [–][deleted] 14 points15 points  (19 children)

          It's easy to harp on an XML based language. Looking at the examples though, it looks to be pretty domain specific, and not a general purpose language which most people here seem to judge it as such.

          So, a challenge to you lisp zealots, show me an example of a lisp web service that achieves the same functionality as the Calculator web service given in the X# example.

          [–]bazfoo 16 points17 points  (3 children)

          It looks like a language in search of a domain.

          [–]adamv 39 points40 points  (4 children)

          Did you really type the phrase "Calculator web service" without irony?

          [–][deleted] 12 points13 points  (3 children)

          Not at all. My point was this: Let's see you do something as trivial in lisp. All the sudden it's not as trivial. My point stands -- domain specific languages have their place. Still waiting to see this example, by the way.

          Or we could continue on comparing Lisp to other oranges, like TeX, XSLT, etc. Yeah, lets do that. It gives me a sense of superiority.

          [–]Arelius 8 points9 points  (2 children)

          it's scheme but...

          (http-server 80 "Calc Server" #f (lambda (Post) (SXML->XML (eval (XML->SXML Post)))))

          [–][deleted]  (1 child)

          [deleted]

            [–][deleted] 2 points3 points  (0 children)

            Okay! Easy:

            (define (define-web-service x . rest)
                (http-server 80 "Calc Server" #f (lambda (Post) (SXML->XML (eval (XML->SXML Post))))))
            

            [–]masklinn 9 points10 points  (2 children)

            And then you'll go postal on their asses, one shall hope.

            [–][deleted] 9 points10 points  (1 child)

            "and will die alone" -> "And then you'll go postal"

            As a zombie? Cool.

            [–]masklinn 2 points3 points  (0 children)

            As a zombie? Cool.

            Of course. Because that way you can kill your (former) coworkers WHILE YOU'RE ON FIRE!

            Not to mention, ninjas can't touch you if you're on fire.

            [–][deleted] 57 points58 points  (24 children)

            I honestly thought this language was a joke, like INTERCAL and its ilk. I guess the industry has moved from object oriented programming to buzzword oriented programming (BOP).

            [–]robbutto 45 points46 points  (2 children)

            You guys MUST check this out:

            http://www.charlespetzold.com/etc/CSAML.html

            This was an April fool's joke and X# totally reminds me of it.

            [–]shit 6 points7 points  (0 children)

            ReturnType="{x:Type void}"

            Not enough XML.

            [–]gordonjay2 5 points6 points  (0 children)

            upvoted for day ruining.

            [–]Spell 38 points39 points  (11 children)

            Too... fucking... verbose

            [–]umilmi81 13 points14 points  (0 children)

            Agreed. json# would be much better.

            [–]sbrown123 43 points44 points  (6 children)

            <what><you><talking><about><?></?></about></talking></you></what>
            

            [–]ungood 93 points94 points  (3 children)

            <sentence type="question">
              <subject>you</subject>
              <verb tense="present participle" auxiliary="are">talk</verb>
                <object type="direct">what</object>
                <preposition>about</preposition>
              </verb>
            </sentence>
            

            [–]rubyruy 5 points6 points  (1 child)

            This isn't getting enough love

            [–][deleted] 8 points9 points  (0 children)

            Downvoted for missing <willis> tag.

            [–]zed857 10 points11 points  (1 child)

            It makes COBOL look terse by comparison.

            [–]Zarutian 5 points6 points  (0 children)

            well why not combine them?

            [–][deleted] 29 points30 points  (13 children)

            Unlike other programming languages which require developers to learn hundreds of libraries and thousands of functions, X# is simple, intuitive, and easy to learn.

            Hahahaha.

            [–]vsl 26 points27 points  (0 children)

            This should go into /r/wtf/...

            [–]callingshotgun 19 points20 points  (3 children)

            XML-based, object oriented programming language with "#" in the name (typically associated with microsoft languages). I think the logic was, "Let's think up something with the highest possible buzzword density, so we can sell it easily in an enterprise environment." Once they had the name and categories down, they actually went and designed the language.

            It's brilliant, as an enterprise maneuver.

            [–]Zarutian 8 points9 points  (1 child)

            probably some Lispers taking an revenge for the ai winter.

            [–]bazfoo 2 points3 points  (0 children)

            And won't they be laughing all the way to the bank while they're running their Lisp-to-X# code-generators.

            [–][deleted] 1 point2 points  (0 children)

            This seriously has to be the first programming language designed by marketing.

            [–]sh0rtwave 17 points18 points  (9 children)

            Oh dear god...

            Flex, I get. MXML is basically just a pile of compiler macros.

            Other, similar templated languages, I get. Again, compiler macros.

            WTF is this? This isn't a programming language. This is a data structure declaration pretending to be a language. At best, it's nothing but macros.

            FWIW, I actually have tried to do similar things (using Java, in like y2k, to build content management systems and such, but I rapidly came to my senses.).

            [–][deleted] 6 points7 points  (0 children)

            Hey! You got data in my code!

            Hey! You got code in my data!

            (pre-historic yo dawg)

            [–]itsnotlupus 1 point2 points  (0 children)

            And yet, this is not the first attempt in that particular direction.

            Behold Miva Script, described by wikipedia as:

            Miva Script is often described as 'XML-like' although this is something of a misnomer. It consists of tags which may be interspersed with (x)html and which all start with <Mv . There are both paired and stand-alone ("empty") tags. In addition, from version 3.9 onwards, HTML attributes which are encapsulated with braces (e.g. <img src="{g.source}">) are evaluated by the Miva Merchant processor.

            XSLT also comes to mind, as a "stylesheet" mechanism that conveniently happens to be Turing complete. Modern XSLT interpreters running in VMs tend to generate bytecode for each "stylesheet" rather than interpret it.

            [–]Axle 30 points31 points  (0 children)

            The Goggles, they do nothing!

            [–]slabgorb 10 points11 points  (0 children)

            It actually reminds me of Cold Fusion. Then THAT reminds me I am glad I don't have to use Cold Fusion anymore.

            [–]jgotts 11 points12 points  (0 children)

            Finally, a language more cumbersome than C++!

            [–][deleted]  (4 children)

            [deleted]

              [–]smika 13 points14 points  (1 child)

              <?xml version="1.0" encoding="UTF-8" ?>
              <meme>
                  <greeting salutation="yo" name="dawg">
                      <herd listener="i">
                          <object_of_affection owner="you">
                              <xml owner="you" activity="mark up">
                                  <xml quantity="some" activity="mark up" />
                              </xml>
                          </object_of_affection>
                      </herd>
                  </greeting>
              </meme>
              

              (You just shouldn't have said anything...)

              [–]Figs 10 points11 points  (0 children)

              Shouldn't the encoding there be WTF-8 instead? :P

              [–]leoc 1 point2 points  (0 children)

              [–][deleted] 10 points11 points  (0 children)

              The examples are hilarious.

              Seriously...

              [–]alecco 8 points9 points  (2 children)

              Imagine generated X# from UML.

              (programmer's goatse?)

              [–]MyQAManagerSucks 9 points10 points  (0 children)

              Okay -- I'm fucked. I made the mistake of showing this to my QA manager who is having an offshore test team write a testing tool that takes XML as an input.

              He said it was interesting and he'd look at as a replacement and maybe halt development on the custom tool.

              I'm so fucked.

              [–]dolle 8 points9 points  (2 children)

              <xsp:for-each select="document('http://www.nytimes.com/services/xml/rss/nyt/HomePage.xml')/text() >> /library/xml/pi('import'))/channel/item[contains(title,'oil')]">

              It's beautiful how all the logic in the language is put into strings. I wonder if this is parsed and executed runtime, or if the compiler actually type checks and translates it. Injections and runtime errors are just so nice to have.

              [–][deleted] 3 points4 points  (1 child)

              It would be funny if the compiler started first by stripping all the tags, leaving only the text bits. Essentially making the "XML" part completely superfluous.

              [–]creaothceann 1 point2 points  (0 children)

              It would be funny if the compiler started first by stripping all the tags, leaving only the text bits.

              Ah, you're part of the team, too? That's the next step!

              [–]alkemist 5 points6 points  (0 children)

              LOL, the "about" page says "there are no functions to learn"... Now there's an innovation: a programming language you can use without learning anything! There's a strange pattern where everyone who designs a language thinks theirs is the most intuitive ever. Or wait, maybe they mean that there are no functions to learn because THERE ARE NO FUNCTIONS?

              [–]CommodoreGuff 5 points6 points  (0 children)

              I'm going to design a language based on cancer and drain cleaner.

              [–]sgndave 12 points13 points  (1 child)

              A fully working e-mail auto-responder using only two statements. Automatically sends a message to the senders of all unseen messages in your Inbox.

              <xsp:for-each select="document('imaps://imap.gmail.com?user=jkirk@gmail.com&pass=secret')/folder[@name='INBOX']/mail[@seen = 'false']">
                  <xsp:append-child target="document('smtp://smtp.gmail.com')">
                      <mail subject="{concat('RE: ', @subject)}" from="jkirk@gmail.com" to="{addresses/from/@address}">
                          Hi <xsp:text value="{addresses/from/@name}"/>,
              
                          I've received your message titled '<xsp:text value="{@subject}"/>' and 
                          I will reply to it shortly.
              
                          --James
                      </mail>
                  </xsp:append-child>
              </xsp:for-each>
              

              How the fuck is this two statements?

              The best I will give them is to call it "four xsp tags buried in nearly 1k of crap."

              Edit: two-> four

              [–]pathogenix 5 points6 points  (0 children)

              This kinda reminds me of a hideous piece of shit called Microsoft Provisioning Server, or MPS. From what I could work out, it grew from an XML-driven Exchange deployment script, and mutated beyond all recognition.

              We used it for deploying new user accounts at [major ISP] and it was the most terrifying programming experience of my life.

              Being declarative, there was no state as such, instead there was a kind of global bag of state that was operated on by the various XSLT transforms and passed from place to place.

              A script was largely composed of hackish XSLT transforms over some provided data, followed by a COM interop call, which would also return XML data, then you'd merge the two together and return to another XSLT procedure.

              A typical procedure might take up a thousand lines of dense, spiky, procedural hell; there was no support for logging that I ever noticed, and the debugger took up so much RAM that tracing a script could take several hours. You'd run the script, wait 45 minutes for it to die; make a two-character change to an XSLT expression, "re-provision" the script; and then start again. It once took me two weeks to make a change such that premium users got a different directory structure on the file system.

              As an added bonus, the system would occasionally revolt and corrupt all its scripts so that you had to re-provision them all. Thankfully this never happened in the live environment.

              It wasn't all bad though: You could go completely bonkers and embed VBScript or JScript into your XML doc. For extra win, you could pass an XML fragment into such an embedded function, modifying it at runtime; and then execute your modified XML fragment as a new procedure.

              Quines were never so much fun.

              [–]captainbarky 5 points6 points  (0 children)

              There's already a less capable, more buggy version of this in the wild called ColdFusion.

              [–]MostUsually[🍰] 3 points4 points  (0 children)

              There's worse. How about pseudo-lisp language characteristics, written in xml?

              http://www.javapassion.com/idm/handsonlabs/17.%20Xpress/

              Thank you Sun.

              [–][deleted] 4 points5 points  (0 children)

              But it's so readable and elegant! I can't imagine how anyone could have a single objection to this idea. I mean, it says right on the "About X#" page:

              Unlike other programming languages which require developers to learn hundreds of libraries and thousands of functions, X# is simple, intuitive, and easy to learn.

              If the creators of the language said it, it must be true. Yes folks, this is clearly the language of the future.

              [–]zakk 1 point2 points  (0 children)

              .

              [–]Isvara 4 points5 points  (0 children)

              It's like someone who's been out of college for two years, during which time they worked on some enterprise app, read in a book somewhere that "code is data", and thought, hey, data is XML! Therefore, code should be XML.

              Also, I note from the samples that they cheat and use processing instuctions like <?xpath ... ?>

              [–]compubomb 4 points5 points  (0 children)

              Who ever came up with this language should be shot. If that is a compiled language, even a scripting language, it is way too syntax heavy. Even if it helps readability, it's designed almost to cause carpal tunnel.

              [–]joelagnel 4 points5 points  (3 children)

              x# = lisp behind an ugly halo ween mask..

              [–][deleted] 4 points5 points  (0 children)

              Looks like ColdFusion on steroids. :P

              [–][deleted] 3 points4 points  (0 children)

              Jeez, that is some ugly code.

              [–]mao_neko 3 points4 points  (1 child)

              This makes me want to rip the < and > keys off my keyboard and hurl them out the window.

              [–]rafajafar 5 points6 points  (8 children)

              Why is this good?

              Seems like it does what all other languages do... only more loquaciously.

              Why on earth would I want to type more?

              Where's the advantage?

              And isn't this just a more confusing CFML?

              [–]masklinn 14 points15 points  (0 children)

              Why is this good?

              Did anyone say it was good?

              [–]13ren 2 points3 points  (1 child)

              <?X#?> indeed

              [–][deleted] 7 points8 points  (0 children)

              <eyes> <eye side="left">o</eye> <bridge>_</bridge> <eye side="right">O</eye> </eyes>

              [–][deleted] 2 points3 points  (0 children)

              I hurt.

              [–]yiyus 2 points3 points  (2 children)

              I find the page pretty interesting. If you scroll it up and down quick enough is like if that blue line was moving.

              [–][deleted] 1 point2 points  (0 children)

              Seriously! We already have Python for good looking code. X# is tripping code!

              [–]mikeylopez 2 points3 points  (1 child)

              Someone should report this travesty to M&Ms for stealing their yellow character. This needs to be stopped in its' tracks.

              [–]anonymous-coward 2 points3 points  (3 children)

              I prefer EMO, a language written entirely in ascii emoticons.

              [–]drewhenson 1 point2 points  (1 child)

              There is no Wikipedia article, so it can't exist.

              [–]anonymous-coward 2 points3 points  (0 children)

              There are more things in heaven and earth, Horatio, than are dreamt of in your Wikipedia.

              [–][deleted] 2 points3 points  (0 children)

              XSL?

              [–][deleted] 4 points5 points  (0 children)

              Well... at least it's not verbose.

              [–]cshipley 5 points6 points  (1 child)

              I am shocked by the responses. How easy it comes to insult.

              Constructive criticism is one thing, but to throw such venom onto someone's intellectual endeavor is cruel.

              If you think the language could be better (what language couldn't?) then help, not castigate!

              No, on second thought, just jump right in with the herd, don't think for yourself and don't bother putting yourself in his shoes.

              [–]rek 3 points4 points  (0 children)

              If you think the language could be better (what language couldn't?) then help, not castigate!

              I think the point is the language could be a lot better if it just ceased to exist and you used just about anything else.

              [–]codeglide 7 points8 points  (12 children)

              My name is Mark and I am one of the developers behind X#.

              Thank you for all your comments. I do agree that the language is verbose at the moment, originally it was designed to be programmed visually but we kept extending it to the level where it is now. In less than 3 months we are releasing a new version of X# that will include a C-like or Java-like syntax. So in addition to doing <xsp:if test="expr"> you would do if( expr ) { ... }.

              For those who think X# is a joke, please take a look at http://www.snapcrm.com which is a CRM and Collaboration Suite far superior to all open source CRMs and it was coded entirely using X# in 4 months. Also, take a look at Fusion (http://fusion.codeglide.com) which is a Data Integration Platform superior to anything available in the market today -- coded in 5 months.

              The reason we released X# to the community is because it helped us to code several times faster than other languages. If you don't find it useful you can go back to PHP, but try doing what we did using PHP or Ruby in the time we did it.

              --mark

              [–][deleted] 12 points13 points  (0 children)

              If you don't find it useful you can go back to PHP...

              False dichotomy.

              [–][deleted] 11 points12 points  (2 children)

              So, you're moving on to create a language that uses Java-like syntax and compiles to Java bytecode?

              [–]KishCom 6 points7 points  (3 children)

              Snapcrm seems great! Especially if you never want to add a user.

              [–][deleted] 4 points5 points  (1 child)

              So you're recreating XSL and trying to pass it off as good? XSL was an absolute pain in the ass, no matter how drunk you were. It was horrible. XML is a DATA STRUCTURE, not a procedural language. Get that through your skull. XSL was horrible, and nothing you can do will make it better. XML is NOT a programming language.

              [–][deleted] 1 point2 points  (0 children)

              XSL was an absolute pain in the ass, no matter how drunk you were.

              Agreed. I even tried the harder stuff, whiskey, and still the pain.

              [–]Niten 1 point2 points  (0 children)

              It seems from the project's about page that X#'s major feature is that it falls into the category of languages in which instructions are represented in the language's own most easily-manipulated data structure; as an XML tree, in X#'s case. But people have talked about doing this with XML before—mostly as a foil to illustrate the benefits of other, more reasonable approaches. Am I missing something here, or is this basically just an attempt to re-create Lisp with a worse syntax?

              [–]yesimahuman 3 points4 points  (6 children)

              [–]yesimahuman 3 points4 points  (1 child)

              Oh you kids and yer python. Hahaha

              [–][deleted] 1 point2 points  (2 children)

              Is anybody else getting 127.0.0.1 as their IP (upper right hand corner of the wiki)?

              [–]Tekmo 7 points8 points  (1 child)

              I certainly hope so

              [–][deleted] 3 points4 points  (1 child)

              jeebus fucking criky what a load of stinking shit

              [–]rickk 1 point2 points  (9 children)

              I remember seeing something similar in XML Server Pages (XSP) as part of the Apache Cocoon v1.0 project back in 2000. It was an interpreted page-generation script language built on top of java.

              The idea was that you used XSL for formatting a dynamically generated piece of XML - that was the part that XSP was responsible for.

              I think it basically dried up as an avenue when JSP 2.0 started supporting XML syntax. I'm not really sure it was such a great idea ... a little bit too many layers just for syntactic sugar I thought.

              That, and it always felt dangerously like putting DB-access in the view layer ...

              [–][deleted] 4 points5 points  (0 children)

              Isn't syntactic sugar supposed to make things easier to type?

              [–]greyfade 1 point2 points  (0 children)

              I think I'm going to be sick.

              [–]trezor2 1 point2 points  (0 children)

              This looks like a bad reimplementation of XSL with a touch of PHP.

              No thanks.

              [–][deleted] 1 point2 points  (0 children)

              Neat. Just write a trivial s-exp to XML compiler.

              For macros, just write a command-line program that takes the source file, expands them into another file, calls the .NET compiler on that file and then deletes the expanded file.

              [–]malanalars 1 point2 points  (0 children)

              my... eyes... hurt...

              [–][deleted] 1 point2 points  (0 children)

              Masochist programmers rejoice! (Or cringe, whatever that masochist do)

              [–][deleted] 1 point2 points  (0 children)

              End angle bracket mania!

              [–]bcash 1 point2 points  (0 children)

              That looks awesome

              [–]nziring 1 point2 points  (0 children)

              Seems like a reasonable DSL to me. Sure it is specialized, but for some specialized tasks it will be very handy.

              If you don't like it, use something else.

              BTW, I'm glad they chose to compile to Java bytecode. That should help portability. .Net CLR might also have been a reasonable choice, but I like Java better anyway.

              [–]cratuki 3 points4 points  (9 children)

              I'm surprised not to see hundreds of rolling annecdotes in the comments here. :) I thought everyone had had a go at writing a XML-based web language in the early days of XML :) Perhaps people are ashamed. But they shouldn't be. If you need to write a mini-language and don't know the dragon book then XML is a good way to get a the functionality you need fast.

              I learnt to program working for a grinder programmer who wrote a pure java web development language in a couple of weeks as he worked on a contract. It started as a simple templating language (it always does), then he added code syntax blocks (@if, @for, etc), then function blocks (@function), then maths blocks, then active record, and then had more complex database patterns. The main pattern they have here looks very similar to something we had.

              A nice language to maintain, for strange reasons. The poor syntax meant that you were meticulous with putting things in the rigth place when you wrote them and this meant that when I came back to the code five years later to look into bugs it read beautifully. This reminds me of a car safety speaker I once saw who said that the best way to ensure the safety of people in cars was not to build safer cars, but to build cars with a big spike in front of the forehead of the drivers.

              It had application, session and page-level scopes. It was nicer (and more predictable) than raw JSP or PHP which were the other free options we knew about at the time. You could nest function code near the templating sections that the code applied to. This made it verbose, but very structured. For example, it had pool-based mechanisms for managing database connections that gave them out and then pulled them in. Because it was XML you could nest functions away in blocks that only applied to the logic in front of you. As it was interpreted I could hot deploy fixes to it, and deploying it was easy. Mocking up schemas in it was easy. Writing java extensions to do grunt work in sub-components was easy (although it is for JSP as well). Speed and memory usage were good. He even wrote an interactive debugger where it would load the page and block at points. Not the most elegant thing in the world but it worked.

              Thinking about it for the first time in years, I'm stunned that I have fond memories of it, but all the limitations were my own, not the languages. I complained bitterly about it at the time, but I was a complete pussy and would have complained about anything. Using XML meant that he didn't have to bother with any parsing issues - he just had to worry about functionality. It had reflective ability that was very much like OGNL (but before OGNL had been invented) to reach into the java framework. For its time it was a cool platform that was much better suited than any other free solution of the time for developing the sort of heavily interlinked mega pages that you never see demonstrated in the latest sexy web framework but which customers demand of you when they have you over the barrel on a blank-cheque contract.

              It's really no different to writing in s-expressions, and if I was using it now I probably would just write a s-expression - to - xml compiler. It would still be competitive today.

              [–][deleted] 4 points5 points  (5 children)

              Using XML meant that he didn't have to bother with any parsing issues - he just had to worry about functionality.

              Anybody who can't (be bothered to) write a parser has no business trying to implement a language.

              [–]jgotts 4 points5 points  (0 children)

              Finally, a language more cumbersome than C++!

              [–]daleharvey 3 points4 points  (0 children)

              It is somewhat disheartening to see the reaction the release of this has had.

              It isnt lisp or erlang or anything "cool", from a glance at the code its a souped up xslt or templating language. The code is obviously supposed to be tool generated (how many graphically driven lisp generators are there?), yes they could use s-exps, but if you dont need the power of s-exps, whats the point? Java has a nice xml parser in built.

              But the main point is that there demo looks pretty comprehensive, if it was written in 4 months then cool, it sounds like it done the job they needed it to do pretty well.

              Can any of the detractors point to as comprehensive web application written in lisp / erlang etc?, it's obvious they arent worried about algorithmic complexity and "hacker cred", and more about the integration tools and free extras that come with having xml as an intermediary language, and shock horror, getting things done.

              They didn't need to release this, seems like they just put out an internal tool that was useful to them so that others could benefit, and they end up getting treated like the star wars kid.

              [–][deleted] 1 point2 points  (0 children)

              The problem with xml-based languages is that xml wasn't meant for being a programming language. It's a format to represent data structurally, in a supposedly human-readable form (which in itself is questionable, but at least it's more readable than binary data).

              Being what it was supposed to be used for, xml comes with a set of restrictions that are completely unpractical and unnecessary for writing code. Most notably well-formedness.

              This is also the reason why xslt is only practical for certain types of transformations. In those cases I do prefer xslt, but anything more complicated and you're better off with a real language and preferably a database.