Does F# support .NET Micro Framework - f#

I realise this has been asked quite some time ago, but time has passed. Although F# supports .NET and .NET core, does it also support .NET Micro Framework? I wouldn't mind programming in F# for embedded applications (e.g. for the Stellaris platform).

This question has been answered before, and insufficiently answered. The project has been pretty quiet since 2011, and in my opinion it may be wise to instead look at nanoframework . Neither officially support F#, however I think the best way to figure out if it will work is to try to use it.

Related

Starting out with Umbraco 5.1

Having never used a CMS system before, I'm just starting evaluating .net CMS systems, with the two most attractive options seemed to be Umbraco or Orchard.
Re Umbraco, I'd prefer to use the MVC flavoured v5, rather than spending lots of time learning XSLT for version 4.7, when that has come to the end of its development cycle. But, is now (May 2012, very soon after the release of 5.1) is actually a good time to start out on the Umbraco learning curve, as there doesn't seem to be the depth of support and documentation out there for v5 compared to v4? I'm sure it'll be improving all the time, but as it'll be my first CMS system, it seems a little scary leaping into a brand new, rapidly developing system.
Sorry for the subjectiveness / vagueness of the question, but any useful comments comparing the probable learning curves of Orchard and Umbraco 5.1 would be very much appreciated.
You may already be aware of this but as of today (13th June 2012) Umbraco 5 is officially an abandoned project due to the fact it was fundamentally flawed at the architecural level and deemed unfixable.
It was announced at the Developer Conference... you can see the reasons why in the blog post below. Suffice to say, you're advised to not use it.
http://umbraco.com/follow-us/blog-archive/2012/6/13/v5-rip.aspx
or watch the rather cringeworthy keynote video here :
http://umbraco.com/follow-us/blog-archive/2012/6/13/cg12-keynote-video.aspx
4.7.x supports Razor - so you don't have to learn XSLT.
That being said, v5 is the future, and it is out, so I wouldn't bet my money on v4 for a new project. Check v5 out, read the bits of documentation that are available, and ask in the umbraco forums if you're stuck. Umbracians are friendly and do help each other out in the forums.
EDIT
Umbraco v5 has been discontinued - you should not use it for any production site.
I agree with the above poster: You don't need to xslt with umbraco at all, v4.7 supports Razor.
Its a good time to start learning v5, but I would not promise any deadlines to clients any time soon. There are a lot of performance related issues that make it unsuitable for all but the smallest of sites right now - If your deadline is 6 months out, you could probably bank on V5 being stable by then, anything less than that, and you are better of sticking with 4.7, which is really fast, full-featured and a pleasure to work with.
Depending on the site, and if you stick with razor, the upgrade might not be that hard if you ever need to do it. I just spent about 3 months developing a v5 site, and because of the problems had to convert back to 4.7. The conversion wasn't that hard, and now being back in 4.7 makes really appreciate how stable it is.

ASP.Net MVC on Linux/Mono

I am thinking of developing a website using the ASP.Net MVC framework on Linux. I would like to know:
what are the best practises for developing such a site (are they any different for mono/ Windows)?
any gotchas I should be aware of
any (material diffeences) - e.g. missing/proprietary libraries/componenst between Mono and .Net
are there any special directives, modules required to run Mono with Apache?
Are there any performance differences between a site hosted on Windows/IIS and Linux/Apache?
I intend to do most of my development using VS Studio - can the site be developed using VS and then deployed on Linux?
I am aware that this question has been asked several times here on SO. However, most of the questions date back to 2008 or 2009 - which is a very long time in internet time. Things may have moved on since those answers - so those answers may no longer be relevant.
I have to state that I am NOT interested in hosting the site on a Windows server - so I am only interested in what works for a Linux server deployment.
I'am currently working on a MVC 4 app and we are using Mono. If you are just planning to have a basic website, you should go for it. But for more complex flows, honestly, I think you should do a little bit of research first, to see if the features you want to implement are supported in Mono. Things you should consider:
only a set of restricted libraries are supported on mono ( for example, right now we are having some issues due to the fact that the mono libraries (Novell and DirectorySearcher) for LDAP do not support pagination)
the developing environment will be different than your server env ( I am using Visual Studio, we managed to pass this limitation by adding a lot of logs)
we do our publish using FTP, so yes, you can deploy it from VS, using a publish profile set up for FTP
it's free, but it will take a lot of time to research & do special thinks just for the sake of Mono
not a lot of documentation available, because not a lot of people use it, so if you have a specific problem, it will be more difficult to solve
My experience is from 2011, but I am pretty sure you will have to experiment to see works and what doesn't - that's my experience with Mono.
Most of your questions are extremely broad and I think your question will be soon closed.
As for your last question this was the way I did it and it worked (develop in VS->deploy to Linux), but you must be aware that:
just because your code will work in the VS debugger it doesn't mean it will work when deployed;
there is no one-to-one mapping between Mono and .Net. Even when things work it doesn't mean they will work the same way. For example the implementation of the encryption code used for http cookies was very different between mono and .net.

Using of F# in a game engine

I'm currently creating a roguelike game and have already started coding in C# but have not coded much (<1000 lines) so far...
Now again, I have had a look at F# and this language seems to be very cool...I'm considering now using F# for the game engine, which, I think, will be 90% of the codeline (A roguelike has a very 'lean' ASCII-UI).
Do you think, F# would be better suited than C# concerning writing coding for procedural content generation, complex AI and game logic? Do you see any traps (apart from that I have to master the language first, of course)?
I've some concerns if F# is not just a research project and will be abandoned by Microsoft or are there statements that it is now a major .NET language?
Thanks for your input.
I don't see any traps.
F# fully supports .NET and even though it's mainly a functional languague you can implement the OO paradigma without a problem.
Also interop with C# is very well possible, so you could even go back to C# without giving up your F# code.
And as for it's future :
It's now part of VS as a stable language, so it's going very much in the direction of being one of the main .NET languages together with VB and C#.
F# is now a full MS product, and functional programming will be increasingly important in the future, so I wouldn't worry about MS losing interest in it any time soon.
F# should be a great choice here. I suspect you'll have some interesting state machines and I've found F# to be particularly good for that.

How to handle legacy app?

I have inherited a legacy app written in C++ (VS2003) MFC that was not updated in years.
I have limited experience in C++, being mainly a Delphi developer. All other apps of the company are written in Delphi.
Going forward, I see a few choices:
1) Keep the app as is and become a C++ MFC developer. But I don't like the idea of using an outdated technology (MFC) for years to come, trying to keep up with new Windows versions and UI standards. It somehow feels like making several steps backwards and I don't think this is the best way to go (?)
2) Convert the app to any modern UI technology offered with C++ and become a C++ developer, but at least using modern technology. Might be a lot of work, not sure.
3) Rebuild the app from scratch in Delphi, where I will be a lot more productive thinking about the future. It's a lot more work right now, but it might pay off later.
Obviously, I personally prefer 3) but I would like to know from your experience which way is the best for the product.
It's a long term decision to make and I will have to stick with it, therefore I don't want to rush into one direction.
(I have intentionally not tagged this question as C++, trying to get answers from Delphi developers in similar situations)
EDIT:
Thanks to all for your answers.
After learning that it is possible to switch to C++ Builder with a MFC application, this seems to be the best solution.
It combines the least amount of modifications to the current app with the possibility to go forward using the VCL for future GUI improvements.
EDIT2:
It's not possible to combine MFC and VCL in one app, therefore C++ Builder won't be an option. (thanks David for pointing this out)
In general everything depends on how complex the application's logic is and what is the projected life time of the application. If it requires maintenance for another 20 years, then
I'd rewrite the UI in Delphi and move the business logic into C++ DLL (for beginning and possibly rewrite it in Delphi either). Then it can turn that the application can be maintained this way for another 10 years and relatively easily ported to other platforms if needed (less work would be required).
This is a hard question to answer generically. Can you provide any more information about your specific app? What sort of technologies does it use? How separated is the UI from underlying layers and logic?
Some general-ish points though:
Rewriting an app is generally a bad idea, for the following reasons:
It's surprisingly hard to get an accurate idea of the requirements. You're sure you know what it does (after all, it's right there in front of you!), but then you release your rewritten app and you get complains that functionality you didn't know was there is missing, that functionality is harder to access if you've changed something, etc.
It introduces bugs. The code, especially if it's old, is full of bugfixes, tweaks, etc. You will lose all that if you rewrite, especially if it's a different language and you can't reuse any code at all.
When using a different UI layer (MFC to something else) separating the UI can be very hard if the app wasn't written well in the first place. You will probably end up doing a lot of refactoring, even if you don't do a complete rewrite and simply move from MFC to 'something else'.
MFC is kept up to date (ish) - there is a MFC Ribbon control, for example, as well as modern controls and Windows 7 support. The least amount of work, probably, would be to upgrade to a modern version of Visual C++ and become a C++ developer. However, you're quite right that MFC is an old technology and is unpleasant to use, not only because of its design, but also because modern form designers etc are great to use.
You're a Delphi developer. Without rewriting the entire thing, you could consider migrating to C++Builder. Consider this:
You can use old versions of MFC with C++Builder. I've never done this, since the VCL is miles ahead, but it's possible and there are a number of people who do it. Check out this forum, for example. (Credit for that link: this thread.)
Once you have your app compiling and working with C++Builder, you can start migrating to the VCL. As a Delphi developer you'll find using this, even with C++, very familiar. It's the same form designer of course, and using it from C++ is pretty simple - it's a different language but code is often line-for-line translatable. Everything you're used to (DFM files, units, event handlers, etc) all translate.
Not only that, but Delphi code can be used in C++ projects. Just add the units to the project, and in your C++ code include the auto-generated unitname.hpp file. You can't (easily) use C++ code from Delphi, but you could create new modules in Delphi and use them from C++. As you do this, more and more of your app will slowly become Delphi code - ie, you don't need to rewrite in a different language all in one go.
As a Delphi developer, I'd suggest going the C++Builder route. Get it working with MFC, and then migrate your windows to the VCL. At that point, you could start rewriting modules in Delphi, or you may find yourself comfortable enough in C++ to continue developing as is.
Edit: I noticed in a reply above you like the idea above of making it a C++ DLL. The link I gave a paragraph or two above of using C++ object from Delphi might be more applicable than I thought. It would fit the RAD Studio (mix of C++ and Delphi) method as well.
Keeping the app as is, tying you to MFC, is likely not very productive - You'll need to learn a GUI toolkit you'll most likely never use for something else (Delphi is great for GUI, MFC doesn't even come close IMO), in addition to a new language.
That leaves you with the choice of rewriting it in a somewhat unfamiliar language using an unfamiliar GUI toolkit, which'll take a lot more time than rewriting it in a familiar language using a familiar GUI toolkit. So you should just get started porting this to Delphi.
Rewriting C++ code in Delphi isn't as easy as you think. A better way to rewrite it is by just redesigning it from scratch, without looking at the old code. Feel free to look how the old application worked, so you can rebuild it. Just don't look at the code. That way, you should get a more modern result.
Of course, if you use the RAD Studio then you have both the C++ as Delphi compiler, thus it should be able to continue to develop the C++ application, although this means you have to learn C++. Then again, any good programmer should be able to just move to another programming language and learn to use it within 2 weeks to a month. C++ can be complex but still, learning C++ and then maintaining the legacy app should take a lot less time than a complete rewrite.
Do keep in mind that any generic C++ application should be able to be compiled for any platform, although the MFC will probably restrict this to just Windows. Still, it's a language that has an even better backwards compatibility than Delphi!
But to keep in mind, will this app run on a different platform in the future? Should it become a .NET application? Or run on Linux? Should it support tablet computers? Android? Your choices today might be outdated again in two years. And since Delphi has a bit uncertain future right now, mostly because C#/.NET became so popular, you might have a more safe bet with C++. Try to replace the MFC libraries with a more modern UI technology, preferably one that's available for multiple platforms, and think very, very well about the future usages of this application.
In general I'd say:
If it's a tiny tool application, and it takes just a couple of days to do a full rewrite: go for it. Don't waste your time creating dll wrappers or to interface with the existing code in other ways. Just do a full rewrite and be done with it.
Otherwise: you'll probably be making changes in one specific area of the application at the time only. Unless the code is a complete spaghetti, you could even get away with making some local changes without fully understanding the implementation details of the rest of the code.
In any case, you need to invest some time into understanding the application and its language + frameworks.
You have a great opportunity to learn C++ and MFC. Take advantage of it. When Delphi goes astray you will have the required knowledge to keep on coding with a language that won't go away so easily, and you can even broaden your development horizons to areas Delphi (and C++ Builder) will never reach. MFC is no more outdated than the VCL is (although I agree the original design is worse).
Good UI programming has nothing to do with the ability to drop controls on a form visually. Many great applications are not built that way. Actually, trying to rewrite it in Delphi could bring you issue in the future, as long as Embarcadero delivers slowly, and without a credible roadmap.
I recommend
1) Keep the app as is and become a C++ MFC developer. But I don't like the idea of using an outdated technology (MFC) for years to come, trying to keep up with new Windows versions and UI standards. It somehow feels like making several steps backwards and I don't think this is the best way to go (?)
Since MFC is well supported and keeps going with the time. MFC is also a what-you'd-call intrusive framework, meaning that the framework dependencies are usually not easily refactored. (The author of CPPDepend published some nice stats on that IIRC, but I can certainly vouch for this from my own experience with large MFC applications).
If you're gonna rewrite to any modern UI framework, don't code the UI in C++ (judging from the fact that Delphi is an option, it is not about realtime visualizations or something like that).
(I'll unask the unasked question here: I you're gonna rewrite, XXXXXXXXXXXXX?) please gentle(wo)men, let's not do the flame
Does the app come with a descent amount of automated tests? If not you're pretty much stuck with option 1 and hope for the best. If there are many tests you can do a lot more with the code without breaking all kinds of things you didn't know were there.

Raudus vs ExtPascal: Delphi web developement alternatives that use ExtJS [closed]

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.
Delphi developers has several tools (several alternatives to ASP.NET) for building web applications.
While No.1 framework is Intraweb, there is a lot of interest around ExtJS, that has 2 incarnations:
1) the opensource ExtPascal
2) the closedsource Raudus
Now the products are different, Raudus never supports the latest ExtJS version (while ExtPascal does because as far as I read it "almost automatically updates itself to the latest ExJS version"), Raudus "seems" much RAD (much similar to Intraweb from the RAD point of view).
Anyway why chose one or the other?
Why Raudus (since it is free) cannot become Open Source? Or does Raudus use ExtPascal behind the scenes?
Comment: uniGUI seems at first sight to combine the good part of Raudus (the RAD part) and ExtPascal (being based on extPascal).
Talking about Raudus, I'd be careful! You can download it for free, indeed. I was about to start using it when I realized there's no single word on its usage license. There's no license in fact, or I was unable to find it under "standard" locations (website? no. installer? no. README / LICENSE file? no.)
Thus I'd be careful with using library which doesn't specify it's license. Especially if you're about to start some project which will use it intensely - just imagine what happens when it comes out that you need to pay big amount of money for using it ...
Why use any of them? RAD in the form of Intraweb and tools like it, is not appropriate for web programing. It doens't separate the GUI from bussines logic well. In other words there is no true MVC approach there. Maybe ExtPascal is different here, but the point is elsewhere.
ExtJS is a very well written RAI JS library. It feels almost like putting blocks of code together in a very object oriented way. You can easily build whole GUI with ExtJS without any backend support. This way your whole GUI is in javascript files and no backend is needed. Backend only processes the ajax call and provides data / processes data. This way you have a clear separation of concerns.
This can be easily done without any frameworks. Yes framework would come in handy but it would have to be done in a ASP.NET MVC or Ruby on Rails way. No RAD and no visual designers. New web developers often make those mistakes. But if you program for the web long enough you come to appreciate the separation of GUI and logic and the simplicity of HTML. Web programming is different from desktop programming at least to a degree.
To answer your question. From what I have seen, I like ExtPascal better. It seems a purer web development tool than Raudus. But I admit I have only seen both from the surface and from demo videos, so I cannot judge, only speculate :)
The Raudus developer put up a new blog post in late October and claims, well I'll let you read the snippet for yourself:
"Raudus license is freeware as written in license.txt. You CAN use Raudus in commercial projects. Raudus sources are not available yet."
Edit: There is a license statement at the bottom of the http://www.raudus.com/ page.
"License
Raudus is freeware. You can freely use Raudus for commercial purposes."
As to contacting the author, try this from the same page: E-mail: igor#klopov.com
After using Raudus for a few months I decided to post my own answer.
The framework is improving, Sencha touch support now it is not complete but sufficient to create usable web applications optimized for mobile devices.
RFE, a new front end, not based on Sencha Touch is under developement and in next Raudus release (that should be out soon) there will be a usable preview of the new controls set.
So while ExtPascal seems frozen, Raudus is in progress and promising.
Update: I stopped using Raudus, it dropped ExtJs support and now it ships with own controls, that will never match the beauty and richness of extjs components. I am now going for IW + cgdevtools components that are Jquery UI for IW.
user193655 --> Depending on what you do be carefull with both approaches. I am really a big fan on Delphi or Freepascal/Lazarus - I am not very certain if the approach of bringing 3GL bindings to the Javascript stuff is wise.
MVC - depending on what you do - in PHP you have the Yii Framwork or Prado. Maybe the second has some ideas from .net built in which are very easy to understand by Delphi developers. PRADO is an event driven approach while YII Framework is absolutely cool and unix like.
After using Raudus it seems that it is not practical for large scale of applications.
According to their documentation and I have also sampled, it serializes all client request into single main thread. However it process client request and response generation part in multi-threaded enviornment.
But main thread issue is quite important as it directly impact the response time if one action is taking more time in the main thread, others will keep waiting.
Any suggestions to resolve this issue?
Raudus:
Relies upon Delphi, in which:
Is verbose;
Relies upon Microsoft Windows;
High-cost to adapt to or to maintain;
Quote from raudus.com: "Raudus is freeware. You can freely use Raudus for commercial purposes. Raudus sources are not available yet." — This, to me, will be never a license. On the homepage, simply there is no documentation about Terms of Service or something like that. Hence I won't deal with their services.

Resources