n2liquid's sandbox

Archive for the ‘Reviews’ Category

Introduction

I have recently created an account on MyFigureCollection.net, a really nice site in which you can post and manage collections of action figures you own, favorite and comment others’ photos, etc. It is pretty much a small social network for action figure enthusiasts.

Hatsune Miku and Black Gold Saw (MFC.net banner by Danboard_san)

The site contents truly is amazing, and I’ll certainly actively participate in it once I get a fine camera and more figures.

Overall the site is pretty good and the idea is really nice, but the service is not as good as it could be.

The matter of what is good and what is bad is pretty much personal, and there’s likely people out there who love MFC (no, not that MFC), but the site has a long way to go to suit my tastes in plenty.

For example, I think the site design could be greatly improved. Of course I can use Greasemonkey to do that, but people wouldn’t see it if I sent them links to my profile, so that only solves half the problem.

Another thing is that if I wanted to create some crazy relationships between my images (like saying 3 images have the same pose, only each has a different background and the last one is photoshopped to, say, remove the joints) I would have to resort to linking them in the description.

But I want better.

For a moment I thought about making a similar service with the changes I’d like to see, but I noticed it wouldn’t be worth it. Most people would stay in MFC.net, some would use both, and we would have the redundancy and mess that Orkut, Facebook, Google+ et al introduced.

It then striked me that these kinds of things wouldn’t happen if web federations like we had in Google Wave were more common.

Federated webspaces

Google Wave’s intent was to reinvent e-mail. One of the most important characteristcs of how e-mail works is that it is distributed.

Can you imagine how far behind we would be if we had a single e-mail provider? It could be Hotmail, guys!

The ability to set up a new mail server is something we take for granted, and we think we would be in a ridiculous position if we couldn’t.

And what if we had multiple e-mail providers that couldn’t send messages to each other? If your e-mail ended in @hotmail.com and mine ended in @gmail.com, I would have to create a Hotmail account just to send you a message. How freaking awkward would that be? Insane, isn’t it?

Insane it is, but that’s what we do when I’m on Facebook and you’re on Google+ today.

The creators of Wave obviously knew all this, and since they wanted to make “a better e-mail”, their product couldn’t have such a major setback, so they developed the Federation Protocol: a way to allow waves to cross server borders.

Not long ago, if I remember correctly, there was a big fuss around Facebook and its apparent reluctance in permitting users to interact with other services such as Twitter. Facebook has obviously changed its mind now, but they still don’t want to give users the ability to export their own data.

Also recently, Google decided to ban Anonymous from G+, and there’s been a lot of discussion on whether they should allow codenames to be used in their network. Some guys from Anonymous then decided to start work on their own social network, Anonplus (which, by the looks of it, isn’t going too far, but it is a noble initiative), but integration with other services is sure going to be tough.

There are many reasons to make social networks interact with each other, and it’s pretty much common sense that this is an important feature to have because the very idea of social networks is that people should be able to interact, and people are scattered across many different services.

One way of achieving such interactions is by federating a social network service just like we did for e-mail and Google Wave.

There is a social network called DIASPORA* being developed, whose server anyone can run an instance of locally and participate. This is by far the most promising social network project I’ve seen.

What I find, as a developer, particularly cool about federations, is that it allows nearly limitless personalization and improvement of services without breaking things. If MFC.net had a federation protocol, I would be able to friendly extend it instead of starting everything from scratch as if I hated it entirely. MFC.net is cool, I just want some small improvements here in there. No need for a wholly new service. That’s drastic.

Now, as a person, what I find important about federations is freedom.

If a service like G+ decides to ban me because it doesn’t like the ring of “n2liquid”, or because I’m excited about all the mess Anonymous is causing, I can just take my stuff and go to another server; maybe even my own if nobody likes me, and, in this case, I wouldn’t have to start a new social network project like Anonplus from scratch. I would simply pick something pre-made and put on a server, WordPress-style.

I hope somebody makes an easy-to-use framework for this so that everybody can effortlessly build the web of the future. XMPP is cool, but it’s nothing more than a foundation for such a framework. As it stands, I don’t see many people making simple websites like MFC.net using it for building federated networks.

I hope federations become the rule. It’s not just cool; it can become a pillar of internet freedom.

Got this from Play-Asia.com today:

Image

Image

Image

Very well articulated, cute, and bigger than I expected \o/

She’s fantastic! *-* Btw, sorry for the low-qualiy shots.

Afternote: I think I could’ve been more specific when I targeted imperative languages; I think I should’ve said procedural languages instead. Not that it changes much, just to be pedantic…

I know, I know, there are lots of blog posts and web pages telling why their authors hate C++.

I know putting yet another one on the network won’t give me much visibility. I know most people will just ignore it thinking I’ll just reiterate over the same points again.

But I have to say, as a foreword, that I never entirely agreed to any of such rants, so this one might be just a little bit “new” compared to them.

I used to really love C++

… for its C-like closer-to-the-hardware (compared to most other languages) approach. For one, I felt like C++ would never push me towards dynamic allocation when that wasn’t needed. It’d never push me towards dynamic dispatching when that wasn’t needed. Wouldn’t push me towards pointers unless they were really called for.

I felt that I had total control over my tool set

When you drive a car you start feeling like it’s an extension to your body; you know your summed up dimensions, so you don’t crash when taking it out of the garage.

In the case of higher-level languages like Java, C#, or even Delphi or Visual Basic, when you do something, you always have to ask others what are the exact implications of what you’re doing.

Are you comparing strings without knowing? Are you using dynamic dispatch when you think you’re doing an extremely trivial task inside a tight-like-hell loop?

Documentation never makes those things clear.

For reasons I’m not really sure, ever since I started using C++, I always felt like I automagically knew the implications of all my steps. I knew I wasn’t buying bloat for a triviality.

As my knowledge of the language evolved and I discovered new language features, I was always surprised that even though that feature was there, I hardly ever used it even if indirectly. And they were still very useful. And I never took more than a few minutes to understand how that worked and exactly how it’d impact my code.

I can’t say I was never took by surprise. For example, I remember I was shocked when I discovered dynamic_cast would do an insane amount of string comparisons depending on the implementation. But, frankly, I don’t remember of any other event like this.

I then started using Java at the university

And was damn shocked that people just starting to code were using a very large chunk of the C++ tool set without even knowing it. Every breath a Java programmer take causes a handful of virtual dispatches (edit: I didn’t know the JIT’ter eliminated those back then, heh) and dynamic allocations to happen behind the scenes.

Everything is a pointer, so everything gets dynamically allocated (okay, maybe the VM actually puts stuff in the stack when it thinks it’s a good idea, but the point is that you don’t see this happening; the programmer is blind to those details), every variable is nullable, pass by reference and pass by value are mangled into the same syntax and people don’t get it why modifying an object argument modifies the original one, and why modifying an integer argument doesn’t. They have no idea how tough string concatenation really is for a computer and simply use it blindly all the time, among other things…

“Hahaha!! Java’s such an utter mess~! :3”, I thought. “Thank goodness I’m a C++ programmer :’DD”.

Even today I don’t know what magic spell is used so that the processor prefetches the right code path when a Java method is called, or if Java programmers just don’t care about those things. “Come on, that doesn’t impact code speed!”, right?

Well, I am a game programmer. I must be able to make things look good on a Nintendo DS. I’m sorry if my game doesn’t run in a data center cluster, ok? I’ve seen presentations showing how proper caching and prefetching impact PS3 games, and no over-engineered piece of OOP code compensates for one cache miss every two instructions.

Same thing goes for C#, and I didn’t even get started with dynamically typed languages.

So, seeing how every language used so many things C and C++ taught me were not to be taken lightly without even telling me, I felt C++ was my safe little castle. And it was very comfy while it lasted.

Then I started understanding better why C++’s features existed

I started understanding that OOP didn’t just mean creating objects the way I saw fit. I bumped upon the principles of object-oriented design, and I felt I groked a bunch of them.

I thought I finally understood what designing software was like and started foaming through the mouth like a mad dog to put everything into practice. I felt I understood what good software design really was about.

I noticed that even though I understood that a class should respect the open-closed principle (OCP), any but the simplest of the classes played well with it when putting it into practice using C++.

I noticed that soon enough my classes simply had to be modified to be extended, and the more I struggled to make them “OCP-compliant”, the more I had to resort to dynamic_cast‘s, hash maps, etc., slowly drifting towards C++’s higher-level, heavier constructs.

I might as well just switch to a dynamic language if I’m to use everything I have to use to make this shit work. And we’re just talking about one of the most basic principles of OOP here.

I then thought I should remain calm, though. C++ just had to have means to do things right without becoming Java-without-the-VM. So I started digging into templates and template metaprogramming, just to find out those features were largely meant for a different paradigm altogether.

C++ isn’t just OOP, it’s multi-paradigm, remember?

So I got in touch with this new paradigm, called generic programming (GP), and noticed it simply didn’t click with OOP, at least not in C++.

“Wtf?”, I asked myself. “It feels as though I’m programming the same thing in two different, incompatible programming languages!”, I thought. I could write part of my code using GP, part of it using OOP and more or less get both parts to “talk” one to another, but sure like hell both paradigms couldn’t coexist inside one same logical part of my code.

This confused me a lot.

At first sight, C++’s templates and OOP looked like they’d beautifully complement each other, but that couldn’t be further from the truth.

Getting them to complement each other requires hacking through the most obscure quirks of template metaprogramming and discovering just how ugly the C++ standard really is.

I discovered that, overall, the GP guys don’t like OOP, and the OOP guys don’t like GP, and that templates were introduced into C++ so that it would support GP just for the sake of those who liked that paradigm. No effort seems to have been put to make both work well together.

Some guys from the Research and Development Laboratory at EPITA, a french computer engineering graduate school (whose website seems to be offline for years; does anybody know why?), who, like me, were not fully satisfied with either GP or OOP actually got to mix both together using pure C++.

They named this technique SCOOP (Static C++ Object-Oriented Programming) and released a library to ease its use, and although I really respect those guys for what they did, I feel like SCOOP may all-too-easily become a maintenance nightmare, not to mention nobody would understand your code if you started using SCOOP in your everyday code.

This discovery was the last straw it took me to accept my idealization of C++ as simply one massively giant fallacy. Not only programming the way I thought was right would produce hard-to-maintain, hard-to-understand code, it would also use too much templates, which basically means the memory footprint would skyrocket because the compiler would vomit infinite amounts of slightly different versions of the same machine code into the executable file, which is generally cool on the PC, where memory is abundant, but is just suicide in embedded devices like video-games.

Ever since then I feel like C++ just can’t convey my voice anymore, be it like a computer or a video-game developer.

C++’s expressiveness dried out for me

When I write C++ code now I feel like I’m wearing a goddamn straitjacket.

My mind goes blank and I can’t help myself to write anything. All attempts to equalize my code with the best practices in my mind feel like I’m bumping into walls.

What bothers me the most, though, is how everybody is just happily getting stuff done in the world, be it with C, C++, Java, C#, Python, Ruby, JavaScript, or whatnot, while I’m completely stuck watching them breaking each and every principle of OOP and saying they love OOP.

I think now’s a good time to ask you what the hell do you mean when you say you feel comfortable with the OOP expressiveness of your language?

Sure, you can more of less map the agents of your problem-universe and it kinda feels like your design is “living”. But you must be fucking kidding me if you tell me you can write good OOP with Java or C#, or even C++.

With the currently available statically-typed languages, I don’t see how the best OOP practices can be put into use. Static typing simply fucks it big time.

If you’re creating classes in Java, C#, or C++ and thinking you’re actually doing mankind a favor you’re just fooling yourself. You are not. You’re just awkwardly getting the work done. Your OOP skills are a joke. You should reeducate yourself. You’re sacrificing your most brilliant ideas by writing them the wrong way, making everybody have to rewrite them later if they want to reuse them.

Languages like JavaScript, on the other hand…

… from what I have seen, really do empower you as a programmer.

But JavaScript is a gigantic hash map, and what did I say about taking strings, the computer cache, and memory footprint lightly?

Really…

I want a language that empowers me, but not by defecating on the hardware’s head. What do I do?

Conclusion

I’ve written a lot in this post, but I passed far from explaining why I think this way. Hopefully you’ll forgive me for not citing any references. I’m just too depressed to get things straight. This post isn’t as much for you as it is for me, the n2 whose brain is bursting to flames and wanted to write down the reasons why.

I still feel the urge to code, but I’m afraid it will pass with every failed attempt to feel good programming again.

I might try one of those purely functional programming languages out there, but I don’t see how a game could be naturally described with them.

And, really… I hate C++ now. No other language seems to solve my problems, but at least they didn’t deceive me for so long. I wish I could believe somebody would point me out to something in it that would enlighten me and let me restart my programming journey, but I’m afraid I’ve seen enough of C++ to know this isn’t going to happen. I need something else.

And I need something new.

I don’t know if I’m just utterly lazy or what, but in many occasions I didn’t try out some brilliant layout, CSS or JavaScript idea or insight simply because I had to open up a code editor and a browser window, and find somewhere to save the test files.

Recently, though, I found what I think is gotta be the solution for this problemthe very fittingly named jsdo.it web-service:

jsdo.it's "Start coding" button

In a way, it reminds of Github’s “Gist” service, but with jsdo.it you actually get to try things out real easy (only HTML/CSS/JS, though).

It officially reads “J.S. Do It”, but I absolutely can’t unspeak “Just Do It” out of my mind, which makes a lot of sense for me. Dunno whether this was the name’s original intent.

As far as I could tell, the service was set up by a japanese company called KAYAC Inc., and the site is pretty much flooded by japanese users, which I think can be great for people who, like me, are trying to make some nihonjin contacts.

They also have a “tour” page at http://jsdo.it/tour worth visiting.

Anyways, jsdo.it works like this:

  1. People rapidly create their accounts using OAuth-like login.
  2. People write HTML5/CSS3/JavaScript code right in the browser and see where their code is going almost in realtime, and use tags to categorize their stuff.Actually you do have to keep hitting “Save” to see the changes, but it really got into the development flow for me, and the result appears in the same window as the sources, so it’s harder to get distracted from e.g., alt-tabbing windows around.
  3. Other people fork your code, and edit it the same way it was written (in-browser).
  4. People publish tiny URL’s on IM, Twitter, et al, for people to try out their snippets. For example, today I wrote this: http://jsrun.it/n2liquid/8YFt.
  5. People favorite snippets, follow each others’ updates around (like Twitter), and post code-related questions with code attached, which others can fork and make small changes to better illustrate their answers or help you solve a problem.
  6. ???
  7. Profit.

Long story short, I didn’t usually try webdev things out, and now, because of jsdo.it, I’m doing it every now and then.

What’s funny is that jsdo.it’s usability, just like the vast majority of japanese websites’ usability, is not one of the best there is out there.

The editor gets a bit slow if you enter too much code, and for some reason it overflows a bit the page (and they’ve used html { overflow: hidden }, so I always have to fix that using Firebug and the likes…).

Further, I didn’t like much how the Q&A system works. You add a “question” tag to your code and I don’t know what happens next. Didn’t try it, but seems loosy and could be better developed. My opinion here, you yourself might love it.

From what I could see, there’s just a handful of people actively posting interesting stuff there, but the concept is still great. I wish more people used the service. It could be a lot funnier if I saw some familiar faces there.

Definitely try the service out. It’s very fast to do so, and the service is lacking some more gaijin there (:


Cute bouncing pixels

un.ma.i!

Twitter (technical)

Error: Please make sure the Twitter account is public.

Twitter (personal)

Error: Twitter did not respond. Please wait a few minutes and refresh this page.

Get messaged when I post something new!
Just enter your e-mail and hit Follow:

Join 171 other followers

%d bloggers like this: