I'm thining about using symfony 2.0 for my new project. It's only preview a release at the moment, the final release is due in March which is around the same time I expect my project to go live.
Are there any reasons why I shoulnd't be using 2.0?
Reasons? Yes you shouldn't use it because Sensio who "make" Symfony tell you not to.
Even though it close to thier slated march release they could still make wholesale changes to the api which would leave you stranded and with a lot of rewriting on your hands. 1.4 is very stable and well documented and will be supported until at least 2012 and so unless there is something in the S2 technology that you cannot deliver you project without then stick with 1.4.
I was in two minds myself as i am developing app that will not get release until April or later and so was tempted. My plan is to build the apps in 1.4 but to build stripped down skeletons that match the 1.4 builds to see how they perform and to then build into later in 2011 when 2.0 has notched up a few revision numbers, and stabilised, and got a better body of documentation behind it.
The documentation for Symfony2 is really lacking at the moment, and seeing as it's so very different from symfony 1.4 (well of course, it's a total rewrite) it's rather hard to just pick up and use in its current state.
I'd say use 1.4 for now, and when the documentation picks up, give 2.0 a try. 2.0 does look exciting though, I can understand the temptation!
Related
We have a Symfony 1.4 application and want to upgrade to Symfony 4. Is it possible or do we have to reprogram the application?
We asked a software company near us and they told us that we have to reprogram the application.
Symfony 1 is a completely different codebase using different concepts both inside the framework (or application) and with some libraries. For example it uses Propel (Active Record-approach) rather than Doctrine (Data Mapper-approach) for mapping php-objects to a database. The difference between Symfony 2 to 4 is considerably smaller, because they share the same underlying codebase and are therefore closer to each other. Upgrading can still be a lot of work because of deprecations (changed and removed parts of the code), but overall the upgrade process can be done inside the same application. Besides that, you can choose the newest version available and I would argue, if you are starting now/soon, even Symfony 5 beta would be a good candidate.
Basically, if you want to upgrade Symfony 1 you will do a migration to a new system and it will not make much difference if you move to for example Zend Framework 3/Laminas vs. Symfony 4. At least you can directly "upgrade" from Symfony 1 to 4, instead of gradually upgrading from over versions 2/3. It will require a whole lot of manual work, though. Essentially you are migrating between different applications. The Symfony docs have some general advice on how to start a migration project like this: https://symfony.com/doc/current/migration
Basically the approach would be to wrap a new application around the old one (a concept commonly called strangler application) and then move functionality to the new application, e.g. route for route, and falling back to the old application when the new functionality does not yet exist. The main reason for choosing an older version of Symfony, say 3.4, would be restrictions on for example the shared PHP version being used. There are other ways around it, but that would mean substantially more work.
Symfony Framework developer here:
Symfony does provide upgrade steps between versions. e.g:
https://github.com/symfony/symfony/blob/2.1/UPGRADE-2.1.md
But upgrading from 1.4 to 4 is BIG and will require tons of work.
I agree: writing the whole app from scratch will be faster from my experience.
Upgrading can take years for stable outcome (depending on your application size of course)
Have a look here:
https://symfony.com/doc/current/setup/upgrade_major.html
The difference between Symfony 1 and 4 might be to important, therefore you might consider starting a new project and take some of your previous code for a nicer and cleaner project.
Upgrading from 1.4 to 4 is a miracle .
Even if you can upgrade to the version 2 and then 3 untill here it's
could be nice , but the version 4 is totally different , so i can
advice you to rewrite your code directly instead of wasting time
updgrading from version to the upper one.
Disclaimer: I wrote and maintain an open-source tool that handles automated instant migrations called Rector.
Since 2018 these migrations are much easier with help of abstract syntax tree (AST). This technology allows to change one pattern in unlimited amount of files at speed of readfile/printfile.
E.g. 1000 controller from Symfony 1 to Symfony 5 will takes similar amount of time as 1 controller. All you need to do is write migration rules. Some of them are ready in Rector, e.g. Symfony 2.8 via Symfony 5 - see Rector sets on Github.
You can learn more about migration of old Symfony Applications
Upgrade symfony 2.8 or php 5.4 first?
How to Upgrade Symfony 2.8 to 3.4
How we Upgraded Pehapkari.cz from Symfony 4 to 5 in 25 days
For anyone still interested in this task, migrating a Symfony 1.x app to a modern Symfony 4.x and up (including Symfony 5.x), we faced exactly this same task with our company and I found this GitHub project that details how to do it using the Strangler Fig design pattern and the Legacy Route Loader approach that Symfony suggests on their website:
https://github.com/dkusmierek/symfony_migration_example
I can vouch that this DOES work, although there are some tweaks here and there you will need to make to make it work for your specific environment. But it should be enough to get you 90% of the way there.
I have been reading a while on the subject and I came across an article which left me a little bit lost on software versioning/releases.
If you follow it you will see it's just a list of all Symfony releases with their respective dates. What prompted me to ask this question was the fact that I could not get why/how, for example:
Symfony 2.8.37 released | April 2, 2018
while
Symfony 4.0.6 released | March 5, 2018
Symfony is just the example, my question applies to software versioning in general looking for an explanation to the above.
I am (am I?) positive that 2.8.37 is older than 4.0.6 so this most certainly has nothing to do with me comparing them wrong, surely there is a fundamental aspect about the versions release process I'm unaware of.
Finally, just to be sure, if I were to compare two versions, how would I go about it, I don't need a computer-language-specific-solution, just an algorithm in general to compare two given versions like you could do even using paper and pencil (I know, what a heathen).
Typically, 2.8.38 would be a security or other patch to 2.8.37; and 4.0.6 is a patch to 4.0.5, where 4.0 is a newer, more powerful base version that requires a different license or runs only under Windows 10 or some other reason why some people would like to stay on the old version.
The patch to the current version would be published faster, and then the team adds the important security patch to the older versions.
Symfony has very good support for old versions of their framework. Basically Symfony 2 was released and went through various version changes similar to 2.1 -> 2.2 etc. All the while maintaining compatibility with previous Symfony 2 projects.
Further down the road Symfony 3 was released, and while a Symfony 2 project could be updated to a Symfony 3 project it involves some work and there can be project breaking coding changes required. Then Symfony 3 progress 3.1 -> 3.2 etc.
Just because Symfony 3 is out and available doesn't mean that all work or bug fixes are done on Symfony 2. So there will still be releases of Symfony 2, in addition to releases of Symfony 3. Here is a visual view from the Symfony Page to show the version overlaps.
This is common with most software, for example Microsoft Windows 10 is the current version but Microsoft still provides patches for Windows 7.
I am new to using Symfony, and I finally settled on it after trying both CodeIgniter and CakePHP for nearly month each.
I have a sufficient know-how with web frameworks but absolutely no idea for Symfony framework.
Now I am in a bit of confusion here since Symfony 2.0 beta is here.
I just wanted to know should I start learning Symfony 2.0 beta or Symfony 1.4, considering the future expectations. Symfony has a tough learning curve and hence, I don't want to go through it again later.
Why start to learn an "outdated" technology? Consider the following:
Symfony2 is not in beta anymore!
This means the code is (should be)
stable, and thus ready for
production.
Symfony 1.4 (although it is great, I
must say) has an end of maintenance
date of November, 2012.
Performance wise, Symfony2 is much,
much better than Symfony 1.4
Symfony2 uses Doctrine 2 as ORM
(although others can be used) and the
Twig template system, and both
of them are (in my opinion) the best
out there.
Symfony2 uses PHP version 5.3, which
has great new functionalities. This
should be the only point to watch
carefully, since many
production servers still don't
support PHP 5.3, but I guess this
should change over time.
Since you quote "future expectations", I wouldn't think it twice and jump into Symfony2.
Can anyone tell me main steps to consider while migrating 1.1 to 3.5 windows based application?
What are the steps need to consider at initially while planing for migration?
as per i know this applicatin i need to migrate like wsf and wpf and soo on.
You'll need to upgrade the projects to .NET 3.5 Framework and then build the solution. Fix any compilation errors (there will likely be a few), and then you will need a large QA effort to make sure you didn't break anything. It's really more of just a time sink than anything you need a specific plan for.
If you can manage it, see if you can write unit tests for your app, and then after the upgrade, make sure all those unit tests pass.
http://www.codeproject.com/KB/books/net2_cs2_newfeatures.aspx
http://www.simple-talk.com/dotnet/.net-framework/.net-3.5-language-enhancements/
I guess you should look through new features and check whether a change in code is necessary for that new feature.
With the amount of effort involved and the changing to newer technologies like WPF, I think you are better off doing a re-write of the application in 3.5. We have had some ugly upgrades done at my place of work that may compile and run as 3.5 but are really just hacked 1.1 applications.
Closed. This question is opinion-based. It is not currently accepting answers.
Want to improve this question? Update the question so it can be answered with facts and citations by editing this post.
Closed 6 years ago.
Improve this question
Well, I know it's a preview, and I know it says that it's not yet ready for production, and yet I dare ask the question.
I need to start building a pretty big application, which is planned to go live at around sep-oct 2010.
Lets say I will not release the application to production until the stable version of symfony 2.0 will be released - is it a good idea (well, I'll settle for a viable idea) for me to start building the application using the 2.0 version ?
How big is the chance I will need to rewrite/replace code I've written due to core changes in the framework ?
Thanks.
Edit: the other option right now, is to use symfony 1.4.
I have thought and tried Zend Framework, but I refuse to re-invent each and every module, which will cost me a lot of programming hours (if not days/weeks).
From Fabien's presentation of Symfony 2 at symfony live: use symfony 1.4 for your next project.
From Symfony 2 github page: things WILL change.
Now consider the following:
symfony 1.4 will be supported until late 2012, that's 2 years after your project's release
Symfony 2 does not have code generation, forms, unit tests, etc so everything that you'll do to cover up these fields, you'll have to redo when the official ways are coming (that answers your second question)
so as everyone already said here, go for 1.4
symfony 1.3 or 1.4 is the right choice for now. 1.3 if you've used symfony 1.0 before, 1.4 if not. I am personally not a fan of the from sub-framework in symfony 1.1+ for many reasons, but you may find it entirely agreeable. That's a personal choice, then.
symfony 2.0 is not stable, and many of the features it is introducing are not those which would really interest a developer, I feel, at this stage at least. sf2.0 is however a impressive exercise in making the next generation of web frameworks; but, not in making the sites you make more feature-rich or easier to develop. It may make them faster and more elegant under the hood, but this is not necessarily the primary advantage of a framework to a developer. An example of this is dependency injection. It's a further abstraction of the already excellent symfony core code components, and its inclusion only increases my respect for the symfony core team and their advances - but for an end-user it probably leaves many scratching their heads over the advantage.
The main advantage of symfony once you appreciate the basic framework is the community and its plugins, and this I think is the dealbreaker for sf2.0 right now. Yes, I know it is essentially built from 'plugins', but you will lack several crucial plugins I'm sure, and either have to write them yourself or adapt existing to suit. This is the reason you reject Zend Framework.
Still, just my opinion. I've been a symfony 1.0 and 1.1 developer (mostly 1.0) for over 3 years, and it still hasn't let me down.
That's a million dollar question my friend. It's a gamble, plain and simple. I've used a number of php MVC's (cake,zend, and symfony) and they all operate roughly the same way. What's nice about symfony is it's focus on being modular, not reinventing the wheel and it's ease of use.
I can't cite any examples of larger companies using it, however I personally would use it over cakePHP or Zend at this point. I feel like it has a strong community, it's not in danger of being abandoned (at the moment) and I generally enjoy working with the framework. Which, at the end of the day, is usually all that matters.
Like I said, I don't know how well is scales up or out but it's faster than cakePHP or Zend. It's a gamble regardless of which framework you pick, so, good luck.
Unless there is something specific in Symfony 2.0 that you need for your application, I would suggest that you go with 1.4 and work with a stable version from the get-go. From what I understand, Symfony 2.0 might not be out until the very end of the year. Symfony 1.4 will be officially supported until end of 2012, leaving you plenty of time to upgrade/rewrite for 2.0 later, if you wish to do so.
I have tried Symfony 2 for a week now (I'm a full-time symfony developper) and here are the main reasons why you should continue using symfony 1.x before migrating to 2.0:
Twig is unstable. You can't use form_render, form_error, etc. But it's pretty easy using a PHP view!
Get user's culture (locale) is a pain in the a**.
PHP templates are not fun as Twig to code. Example with this translation function:
PHP: <?php echo $view['translator']->trans('text') ?>
TWIG: {% trans 'text' %}
Bad documentation
It seems not so bad like this, but trust me... it takes me so much time to debug those stuff to realize in the end that it was wrong inside Symfony 2 himself.
By the time you release your project, version 2.0 is most likely will not be stable anyway. And consider that version 1.4 has long terms support for 3 years, which you can count on if you are starting up a new project. Other than that, with symfony 2.0, things are not going to be same :) it is going to be so much different than current versions. You might not like it :) or it might not be suitable for your project.
Or you can just use Lithium...you know, it's better than all of the frameworks on the page mentioned... BUT the question IS about v2.0 readiness not about cake or other frameworks (as mentioned by other posts, though I figured I'd get my jab in too).
I personally wanted to use 2.0 on a major project, but will likely turn out not because of fear (always a bad reason).
My point is this. Nothing is stable. Not even 1.4. EVERYTHING in this world is subject to change and there's always patches and fixes for everything. If we didn't use beta/alpha software, ESPECIALLY in an open source community, we'd never progress.
So. It's a risk. The trick is you gotta be good enough to handle any problems that may crop up. I think that's just the name of the game. You're either the type of developer who goes off and installs Wordpress and Drupal and says look at me mommy grown up pants...Or you're the type that goes out and is on the cutting (or bleeding) edge and sucks it up and gets it done. Rolls with the bad times and smiles (from ear to ear) during the good.
End of the day it's your job. Don't ever let anyone tell you how to do it. You do it how you want.