A Bug's Life!

Hi,

This is a tips that may be useful if one day you’re messing with OSes installations on a Mac.

As you certainly know, you can press the Alt key when booting your computer to choose between different boot media, what you may not know is that when this is done, you can also eject the CD-ROM. That may help you one day!

This post was written for the haXe’s mailing-list. I decided to cross-post it here because I want people who do not read the list to be aware that this discussion is taking place and its place is on the mailing-list. So, if you want to participate, do so on the mailing-list.

/* Please note that this is a long post. There’s no pun intended in it. There’s no complaining for the sake of complaining, I’m not targeting anyone.
*/

Hello,

As haXe, and most important, its community, are growing, I I think that it could be a good idea to organize the community.

This would have to take into account several points :

• Wiki maintenance
• Standard haXe’s framework management
• Community management

Those are the three main concerned points IMHO. Now, let’s go deeper into each one.

Wiki maintenance

As we all know, the wiki is an important thing because it is the first thing a new-comer sees. But it’s also important because it’s where you’ll find the “official” documentation. The maintaining the wiki is difficult ATM because : anyone can edit it, it’s multi-languages.

In fact, the main problem is that it’s multi-language. So, when we change something in an English page (and we do that quite often, to reflect a point discussed on this list for example), it may not be reflected in other languages (and in fact, there are quite a lot of chances that it will not be reflected). And to be honest, there are some languages that haven’t seen any change for months. This is a very important problem because the default website one sees is not the English one but the localized one which may be really out of sync.

I know we already discussed that, but again, I think it would be good to have one person in charge for each language. That doesn’t mean that no one else should be editing it. That would just mean that this person would be a manager, eventually have a team of persons with who he could work. This is very important and would ease keeping other languages in sync with the English one.

Standard haXe’s framework management

The Standard Framework is a very important thing too, because as we all know, even if a language is really good, it’s nothing without a good framework. The thing is the framework is already *big* (don’t forget the code base is even bigger because of multiple targets) and maybe it should grow.

There are two concerns about the haXe Framework :

• We need a way to bring new things in the framework, but not anything should make it to the framework. So, we need some kind of “proposal” and “moderation” procedures.
• We need to be able to maintain the framework : accepted proposals have to be implemented, bugs have to be solved.

Here again, I suggest that we go we the “managers” way. But how to split it? By targets ? Or by API’s parts? (SPOD, JS things, …)

Community management

Ok seriously, the community is growing, and it’s not limited to this mailing-list. The problem is that we are only aware of people who uses this mailing-list because we do not organize anything else for the others. Not having “activity” community oriented also makes some people leave haXe because they feel like there’s nothing happening. I know I’ll hear the “but it’s open-source, so things are taking place everywhere on blogs, websites,… outside of haXe’s one” thing. That’s true, but we also need to centralize things. That do not mean that we need to annihilate things that are outside, but we need to organize things “inside” too. Look at “modern” languages and frameworks that made it : they organized things “inside”.

In two days, it will be 4 years since haXe development started and in a little less than a month, that it’s been first released to the public. And how many “community meeting on the web” did we have? One. ONE. Incredible! Four years, so many people dedicated to haXe, and we only had ONE meeting online. Why? Because there’s no one to organize things that are community-oriented.

If we want community-driven things, we need community-oriented activity. And we need someone to organize it.

Please note that I’m going to cross-post this to my blog so that if some people do not know that the ML is here, they can get in touch. But I want the discussion to take place here. This is the place where it has to be.

Regards,

—
DASNOIS Benjamin
http://www.benjamindasnois.com

Hello everyone,

There’s been an interesting question on the haXe’s mailing-list regarding typing of functions. No matter what the question really was, it made me think I should write something about functions typing in haXe because it may not be really obvious when you’re not used to it.

So, Functions are typed.

Yes, functions are, like any other object, typed. Their type depends on two thing :

• The arguments taken by the function
• The return type of the function (the type of the object that’s going to be returned)

So a function written like this :

public function m1(arg1 : String, arg2 : String) : Int

would be typed as taking as first parameter a String, as second parameter a String, and returning an Int. We note this like that :

String->String->Int

More fun.

What’s even funnier, is that a function can take a function as a parameter, it can also return a function. So, how would we write that? It’s easy, just put parenthesis around things! Now, let’s imagine a function m1 that wants as first parameter a String, as second argument a function taking a String and returning an Int, and that returns an Int. We would write it like that :

function m1(arg1 : String, arg2 : String->Int) : Int;

And this would be typed as :

String->(String->Int)->Int.

Imagine m2, which takes the same parameters as m1 but returns a function taking an Int, an Int and returning a String. We could write it like this :

function m2(arg1 : String, arg2 : String->Int) : Int->Int->String;

This would be typed as :

String->(String->Int)->(Int->Int->String)

And you can embed things more and more… but pay attention to the parenthesis! ;)

Hello,

Yesterday, Michiel Crefcoeur, sent a mail on the haXe mailing-list in which he pointed me to two languages : Fan and Scala.

His point was that those language support dynamic typing and compile to Java and .NET, so that would ease the development of a Java&dotNET back-end. In that, he got a point.

But there’s a problem to me… Fan seems to be pretty cool but it doesn’t give you access to the underlying API (instead, it provides a top-level API) and I do not like that, also I don’t feel like it supports Android. This is important to me as I think mobile development is one of the ways to go nowadays (it is the way to keep us connected anywhere, anytime). The same thing applies to Scala.

Moreover, there’s the fact that we would depend on another language, that doesn’t sound like a good idea. (Okay, at the moment I depend on Java, but it is seriously backed-up by Sun no?).

So at the moment, I’m still targeting Java. Do you think I’m wrong?

Hello,

Nicolas Cannasse has written about why Action Script 3 is a failure, so I’m going to write about why I think haXe has a great potential to become the language of the future.

haXe is about Web Development

Well seriously… Everyone is aware of that, first targets of haXe were Flash, Neko (was mostly used for server-side at the time) and JavaScript. That’s the basic definition of “web development” : develop a web-site and a web-site is composed of three parts :

1. The server side.
2. The Rich client side (Flash)
3. The “less rich” client side (JavaScript)

So, it’s obvious that haXe is made for web-development, since it even has what was needed : Remoting. Flash and JS can communicate with the server very easily, and Flash and JS can communicate together as easily. So everything is there.

Everything is about Web Development

Let’s be honest, nowadays, everything is about the web : most of the applications on your desktop connect to the web or have something to do with the web (even composing a document means that you certainly want to email it or publish it…) and even better : desktop applications are now built using web technologies (think about AIR and Titanium) and this is possible up to a certain point.

What haXe provides

haXe is able to target JS and Flash ; that means it can be used to develop desktop applications easily (by targeting AIR for example). That allows the developer to use one language to develop web-sites and desktop applications with technologies that he knows, and more over, the developer can use the haXe framework to easily make the desktop application communicate with the web-application. And think about it : we are doing more and more mobile applications, and what are their purpose? Allowing us to stay “connected” everywhere. That means that what we have on our computers, on our mobile phones are indeed web-applications, or at least, extensions to web-applications.

And I guess that’s why haXe (apart from the syntax and all related things) has so much potential : it’s been thought for the web and it is still being thought for it.

Hello everyone,

I just wanted to write to let you know that the haXe/Java generator (the one used in the haXe on Android video) now supports generics.

It may seem obvious but that was not that easy to implement.

haXe supports constraints on generics, but those constraints won’t be written in the generated output.

I hope there aren’t too many bugs and by the way, I’m getting more confident with OCaml (even though my style may be ugly at the moment!)

Stay tuned!

Hello and welcome on my new web-space.

This one is dedicated to all my tech-related stuff. You will mostly find ressources and my thoughts about Open Source, web-development and haXe-related development.

But at first, I would like to thank Mr. Nicolas Mérouze from Yeasty Mobs (a french company specialized in consulting for the web and applications development in Ruby) who is managing the benjamindasnois.com domain. You can also find his personnal weblog (updated when he has time) there.

Stay tuned for more things to come!