As it currently stands, this question is not a good fit for our Q&A format. We expect answers to be supported by facts, references, or expertise, but this question will likely solicit debate, arguments, polling, or extended discussion. If you feel that this question can be improved and possibly reopened, visit the help center for guidance.
Closed 12 years ago.
There was discussion in early 2009 about whether Microsoft would release the source for the F# compiler under the MS-PL/another license. A StackOverflow thread mentioned the state as of then.
Since then a lot has happened. We've seen an official release of F# with the .NET Framework 4.0 (and Visual Studio 2010), and for all I know, it's still completely closed-source. Have Microsoft just been quiet on the subject, or have they explicitly stated that they no longer intend to open-source the compiler? Perhaps things are in the process already. Basically, any news/considerations?
(As others have pointed out, the source has always been available, but is not yet under MS-PL, the 'approved open source' license - it currently has a more restrictive license.)
If I were being completely speculative, I might hypothesize that there are a number of things which might have "delayed" an open-source release of the F# compiler, including these:
The compiler code requires a bit of tidying up. The source has always been public, but without an open source license, not too many have looked at it. If you open it, people will look, in which case, it would be nice if the code followed at least some basic style guidelines, like using RecommendedDotNETNamingConventions rather than old_legacy_ones. In a sense, an open-source F# compiler would be one 'canonical F# app', so it would be important for the code to be of high quality with regards to basic things like F# coding conventions (that evolved over time the past 5+ years since the compiler code was originally developed).
The current code is hard to build on any platform. An open-source release would require at least reasonable docs on how to build the compiler (still non-trivial today!) and ideally build scripts for major platforms (e.g. Windows/linux/etc).
Even if IronPython/IronRuby ('open' teams) are "just down the hall" from the F# team at MS, making things 'open' still requires getting a great deal of buy-in/sign-off from management, and re-sign-off from new management if the management changes before you get the first open-source release out the door.
(all the usual 'overhead' of managing an open-source project)
All of the above take manpower, and manpower spent on those things is manpower not spent on other things, like working on the next version of F#. So in practice it may be more feasible for the handful of people doing F# work to nibble away at the work above in free time, rather than devote, say, an entire month to focus on an open-source release. So that might slow things down. (As others have tangentially suggested by pointing at links to job postings, some of the manpower could hypothetically be filled by interns at MSR.)
I emphasize that all of this is completely hypothetical speculation, as there's been no official word from anybody in a long time.
As Robert's comment on your question indicates, the source code is already available as part of each installation, though it does not come with an open source license. Additionally, reading between the lines, I think that things like this blog post by Don Syme still point to an open source release as a priority for the team.
Is it a question? I'm not sure, it's more of a request for any news relating to an existing situation. Adding "considerations" to the request is confusing, what considerations are there? The MS C# compiler is closed source but the C# spec is with ECMA. The F# spec has not been opened to the wider community which is the telling part I feel.
The decision is left with Microsoft, I dont think anyone here can answer that. However, even if it is closed source, we will still probably have all the benefits of the framework, as Microsoft is quite committed to improve and provide more functionalities in the framework. I think even if something is not open sourced or not, but the creator is supporting it or not, that is the biggest concern I have. We have tones of projects in open source but they become code junk after they are not maintained and never improved.
Related
As it currently stands, this question is not a good fit for our Q&A format. We expect answers to be supported by facts, references, or expertise, but this question will likely solicit debate, arguments, polling, or extended discussion. If you feel that this question can be improved and possibly reopened, visit the help center for guidance.
Closed 9 years ago.
Before you condemn this as subjective, consider that there are differences between different frameworks. Writing something with PHP, I assume, is probably a lot less verbose and thus time consuming and expensive than writing it in binary. While the differences may not be as pronounced between the title options, I think there probably are significant differences which can result in, for example, a DoodleJump-type app taking more or less time to code in each.
Although there are other factors involved in choosing a framework, I'm just asking which one requires the least amount of coding and thus time and expense for equally skilled developers to accomplish the same thing (conjuring DoodleJump physics, a basic TicTacToe game, creating a UI, whatever). I'd appreciate links to sources if you have them, as well as direct experience comparing the verbosity of one or more in accomplishing the same task.
I'd most like to get an idea of how Flash and HTML5 compare to Corona (in terms of development time), but I'm also curious about the others.
Well you should seriously rephrase the question. It looks like subjective.
I'll just give my experience with all these tools.
Disclaimer:- The following review is my own personal opinion and involves my personal experience. You might have different opinion.
Marmalade
While I've used marmalade for most of my deployed projects, I've never used their RAD tool quick for any serious development. I was asked to try it out by remaking one of our deployed game. I was really impressed with it's quickness and less-verbosity. Although it was only for 2D and I recommended it's use over normal marmalade for all our 2D games. Unfortunately, we never made any 2D games after that. The benefit was that it comes preloaded with box2D and Cocos-2Dx and still supports C++ libraries. Didn't try EDK with it yet, but it should support that too. The con (for me) was I had to learn luascript for that.
Flash
Well I am not a flash expert here, but I tried it on two of our deployed game and it was a good one. Although it was too limited in what it seemed to have. We had to Re-code one of these games in marmlade, just to support some 3D elements, which were not possible to do in flash(at least for me). Flash was too verbose and too confusing for me, since we don't know where the actual script is attached. I guess it must have happened with all programmers who tried flash after trying any other tool, like marmalade. It just confuse you.
Unity
Well it was much much better than Flash, and is actually a well written game engine. Although it might cost a fortune for Indie developers, but still it's worth it. I've been using it for almost 4-5 months and I already started liking it over any other engine. It's easy to learn and too less verbose. You just need to drag and drop and attach the script to the gameobjects.(Not really that simple actually). No need to worry about Physics engine, no worries about plugins(since most of the plugins are already avaialable). And you can do 3D in that too.
Never tried Corona and HTML5 for any development project, so can't have a say in that.
As it currently stands, this question is not a good fit for our Q&A format. We expect answers to be supported by facts, references, or expertise, but this question will likely solicit debate, arguments, polling, or extended discussion. If you feel that this question can be improved and possibly reopened, visit the help center for guidance.
Closed 10 years ago.
What genetic-programming library, regardless of language, has the most active community and is the most well developed?
It's hard to tell, frankly. ParadisEO seems to be very active, and is a pretty large library encompassing various metaheuristics besides GP. Note that it is a superset of the EO library. OpenBEAGLE is nice, but it hasn't been updated since 2007. Watchmaker is very good and active right now, but it only has a proof of concept implementation of GP for now. There's a plethora of libraries out there and rather hard to tell which is the best one. And it's not very hard to roll your own GP, so keep that possibility in mind.
HeuristicLab has a very sophisticated implementation that is both fast. For example in an independent benchmark you can see that the speed of HeuristicLab's interpreter was equal to a newly coded minimalistic C++ interpreter that included optimizations. It is also very flexible in that you can configure the grammar that creates your tree in the GUI environment. So you can create functions that should e.g. only have certain variables as inputs, but not all. The implementation is based on a long heritage of code, that is very actively developed and which is reviewed before each release to ensure the continued quality. HeuristicLab supports Regression, Classification, as well as custom problems like Santa Fe trail or Lawn Mower (of which a tutorial exists that helps you implement your own custom problem). There is crossvalidation, there is a separation of training, validation and test that you can make use of to detect overfitting. You will get as results how much each variable is present in the whole population, how much your symbols are present in the population so you can estimate what variables are important. This is displayed as a graph over time. There's also a pareto analyzer that you can enable to show all solutions by quality and complexity. HeuristicLab also contains the recently (GECCO2012) emerging GP benchmark library to enable people to test and compare results. Apart from GP there are further regression and classification algorithms implemented like SVM, Random Forests, k-NN, etc.
It's implemented in C# and runs on .Net 4 (currently only on windows, mono support is close to finish).
You might want to check out Gene Expression Programming (GEP). It is an alternative form of genetic programming.
There is a technology site at http://www.gene-expression-programming.com/. The company behind it is GEPSoft http://www.gepsoft.com.
I'm a fan of ECJ, "A Java-based Evolutionary Computation Research System":
http://cs.gmu.edu/~eclab/projects/ecj/
The mailing list is usually moderately active, indicating to me the general good health of the project. I have been using ECJ for almost all of my GA and GP research and it has a lot of interesting built-in features plus several third party contributions.
ECJ's creator, Sean Luke, also wrote an awesome and free downloadable book: cs.gmu.edu/~sean/book/metaheuristics/
JGAP for Java seems fairly active. Looking at the checkin history there was a burst of activity a couple of months ago.
http://jgap.sourceforge.net/
You can try this C# .NET 4.0 port of Sean Luke's ECJ (Evolutionary Computation in Java):
http://branecloud.codeplex.com
It is very flexible and powerful software! But it is also relatively easy to get started because it includes many working console samples out-of-the-box (and many helpful unit tests that were developed during the conversion).
As noted above, if you program in Java, you should visit Sean Luke's site directly:
http://cs.gmu.edu/~eclab/projects/ecj/
It has been under active development for 13 years!
Ben
CILib from the CIRG team. It's been update regularly. The developers are always frequent to answer your questions.
Forum: http://www.cilib.net/
As it currently stands, this question is not a good fit for our Q&A format. We expect answers to be supported by facts, references, or expertise, but this question will likely solicit debate, arguments, polling, or extended discussion. If you feel that this question can be improved and possibly reopened, visit the help center for guidance.
Closed 10 years ago.
When deciding whether you are getting involved in a fairly big open source project in order to contribute to its code base, how significant are the project's issue tracking facilities (i.e. tracking of bugs & feature requests) for your decision to contribute or not?
There are still many non-trivial (huge code base) open source projects out there, that don't formally do issue tracking - and while some contributors may indeed still do this privately in the form of miscellaneous "ToDo" lists, I have personally found the lack of availability and established use of issue tracking to be a fairly reliable indicator for a lack of organization, structure and overall project coordination.
What are other people thinking?
I would say it would be a fairly significant factor.
An open issue tracking system is one component of what I would call having an 'open development process' - where anybody who is so interested can see the developers' decisions as they are being made, and contribute to the discussion.
Some projects don't really have an open issue tracking system (or a good one) but still have publicly visible discussion lists, maybe an IRC channel where there are always people on, maybe a forum/bulletin board, etc. In my opinion such projects are still fairly attractive in terms of contributing to them.
What I have personally found is that while I work with very many different open source projects out there, I don't ever really become part of a larger group. However I do find bugs and would like to report them and would like to find out if the issue was found before, and when and if it is going to be fixed.
For myself personally, an open bug tracker or mailing list where I can shoot a one-off email to notify people of the bug is better than having to signup for the mailing list or register for the bug tracker. I already have enough accounts all over the place, I don't need yet another one for the piece of software.
So the friction involved in reporting a bug is definitely an issue, also being able to view the status of bugs and having them be searchable is a big help in determining on whether or not I will report my issues to the project or not.
So yes, open issue tracking, easy to use, easily visible (digging through a page for 20 minutes is not my idea of fun) and best of all with as little friction to get a report of a feature wanted/bug in.
A number of projects that I'm involved with still do everything on the mailing lists. If a bug comes in (and gets confirmed, and can be fixed) its put in some kind of BUGS file within the repository. As things get fixed, the entry in the file is noted.
Not my preference, but its what other contributors are accustomed to and like. It could be that someone doesn't want the hassles of hosting the bug system, dealing with the SPAM it might attract, etc. Could it be that the project doesn't get very many bug or feature requests?
The real question of 'should you' really revolves around the code, no? Or how much you could learn / teach by working with any particular group? If you begin contributing and show yourself to be friendly and useful, you might meet no resistance when suggesting something like trac or bugzilla.
The only thing that would make me consider steering clear of any given project would be a total lack of any kind of version control. But, even then, I'd have to weigh what I'd be given up against the hassle of managing patches with racy merges.
As it currently stands, this question is not a good fit for our Q&A format. We expect answers to be supported by facts, references, or expertise, but this question will likely solicit debate, arguments, polling, or extended discussion. If you feel that this question can be improved and possibly reopened, visit the help center for guidance.
Closed 10 years ago.
Microsoft is tearing down walls and barriers. Their product and project development process is becoming increasingly transparent. They are blogging all over the place and they are releasing open source code projects by the minute. While all this is great, it can be overwhelming!
People like Scott Hanselman are doing their best to keep up with all the information and clarifying stuff. Still it is virtually impossible to get any kind of complete picture of where Microsoft is heading and which projects that will last in the longer run. Projects lingers in beta stage (courtesy of the "Google Approach"), and information is spread in blogs, on Codeplex and elsewhere. And in the midst of everything new, we poor developers need to produce stuff and pick which projects to use.
I want to know how you handle all this? My own sources for good info is:
Trusty 'ol MSDN
Scott Hanselman (blog and podcast)
Various other bloggers like Glenn Block
Personally, I handle it by not caring. If one of my friends thinks something is important or cool, they'll link me. Beyond that, I don't have the time to worry about what Microsoft is doing this month/week/day.
I use Microsoft Communities. They are all listed on http://www.microsoftcommunities.com/. The orbs and ticker are cool, but I have never had them open for very long.
Channel 9 is usually buzzing about nearly everything they're up to. They're starting to do more podcasts, screencasts and interviews.
Channel 10 is more blurbs and videos but I find it suppliments Channel 9 nicely.
I always look at each new thing and try to figure out if this is something that is truly new and useful or is it something old in a new, shiny package.
For me personally I like to pick one thing and work on it for a while to learn it in a way that allows me to be effective at my job. If you try to "drink from the fire hose" you will retain little and only end up feeling overwhelmed.
Out of everything that Microsoft has released lately there are only two of things that I found to be pertinent and truly groundbreaking: WCF and LINQ. I have spent a lot of my time learning these technologies as I believe that they are the most relevant and useful.
Now none of this may be true for you - the trick is to figure out what is relevant to you and your goals and focus on those things.
I have had a lot of luck with the weblogs.asp.net main feed. It's an aggregation of all blogs on the site, including Scott Guthrie's and other Microsoft insiders, as well as a lot of non-Microsoft folks who are fairly serious technical bloggers.
The topics are definitely not just limited to ASP.NET, there is healthy coverage of .NET development and Microsoft technologies in general.
You can scan the headers of the blog posts, and themes jump out to you that point to what is "hot" and new in the Microsoft space.
The DotNet Rocks podcast is good. Not necessarily purely MS oriented though.
As it currently stands, this question is not a good fit for our Q&A format. We expect answers to be supported by facts, references, or expertise, but this question will likely solicit debate, arguments, polling, or extended discussion. If you feel that this question can be improved and possibly reopened, visit the help center for guidance.
Closed 10 years ago.
What license should I pick on codeplex if I want an open source project? What are the pros and cons on all licenses?
If you want to ensure that anyone who modifies your program or builds on top of your program (by linking to it) should share their changes in the same way that you share yours, you should choose the GPL.
If you want to ensure that anyone who modifies your library share their changes, but allow people to dynamically link to it from a proprietary application, in which they don't share the source with you under the terms you shared it with them, you should choose the LGPL.
If you want to allow anyone to use your code as they wish, with no significant restrictions other than providing you credit, you should use the MIT (also known as X11) license. It is short, simple, easy to understand, and permissive.
If you need to integrate with an existing project that already has a license, you should probably just use the same license. Having everything in one project under the same license makes life a lot easier for anyone who wants to use it. But if you're creating a new project, I would recommend one of the three licenses listed above, since they are widely used, well known so people know exactly what you mean when you mention them, and will make it easier to integrate your code with existing projects. There are lots of other licenses to choose from, but in general, they just make things more complicated and difficult (because they are less well known, because of license incompatibilities, etc) without improving on one of the licenses listed above.
It depends very much on what you want. I'll summarize very briefly, but I recommend reading more in depth on various licenses.
GPL: great if you want to share code but you couldn't sleep at night if someone put your code into a commercial product. Con: tons of legal stuff that's almost impossible to comprehend.
BSD/ISC/MIT: very minimal license that only retains copyright attribution. Maybe be used is commercial products. Can be understood by common people. Cons: if you care if Apple takes your code then it's not for you (webkit in safari, freebsd userland in OSX).
Apache/Mozilla: kind of like GPL, but also protects the brand name. Cons: you can't tweak and still call it by the name you got it.
Lots of variations on the above. Cons: nobody knows just what the license means.
The choice of license is personal, and depends on how you want your project used.
I would recommend reading up on this at the Open Source Inititive.
In particular, they have a page describing licenses grouped in categories.
Here are some of the more common, by goal:
For encouraging commercial usage of your project, I'd recommend looking at the BSD and MIT licenses.
For encouraging commercial and noncommercial work, but forcing that all users share any modifications to your code, look at the LGPL license.
If you want to force everybody who uses your code to share any modifications, look into the GPL license.
There are many others listed, each with their own significant benefits and downsides... These are just four very common choices.