Modernizing a Legacy Application

Excellent talk. Lots of invaluable information.

The only critique I'd make is to either consolidate some of the information, or consider splitting into a two part tutorial. Because there was so much to cover, a lot of useful information had to be skipped. I'd definitely consider adding the code samples to the slide deck. A lot of time is wasted switching between the slide deck and the code.

Overall though, excellent, excellent tutorial.

A very good talk going through practical means by which one can incrementally improve a legacy application. It was also a valiant effort to cover all the information in his book, though three hours was a little too short to go through every aspect. Still, it was definitely a LOT of good information from a dynamic speaker.

Spot check, commit, push, notify QA.

This talk was quite the whirlwind as it was covering a ton of material in a short amount time. Mr. Jones does a great job of summarizing his "Modernizing Legacy Applications In PHP" book in the time provided as well as answering and asking questions throughout the talk, which is a very difficult thing to do while staying on topic of the talk.

I felt that showing the code example throughout the talk also helped me personally to see the steps he recommends to moving forward and honestly feel that instead of this monolithic task of modernizing a legacy system, we as a team are able to take bite sized tasks and complete them as we are working on portions of the application.

Thanks for the talk!

We knew we wanted to modernize our legacy app, but now we have a game plan. Thanks Paul!

-1 for going over time, but understandable considering the amount of content to cover.

Way too much information in way to little time, however it was very interesting and without a doubt important information when it comes to refactoring legacy code.

Pros: Lots of very good advice from the trenches, about how to relatively safely, incrementally change a legacy code-base into a more modern code base.

Cons: Anal regarding code simplification for comprehension (but sometimes at the expense of much more source which seems counter-intuitive) (and sometimes at the expense of run-time code efficiency). Nothing regarding code comprehension of larger, inherited legacy code-bases :-(

Did a great job. You can tell Paul is a zealot about the topic, which reflects well in how he delivers material. I feel extremely motivated to modernize my code base - which is the highest praise I can possibly give.

Some thought its a possible negative he went over time limit - I consider it getting more value out of the ZendCon experience.

Great talk. Lot's of great information

Great talk, should have been multiple part though -- this is a big one for PHP devs, and it was nice seeing that acknowledged.

Pros - Engaging and passionate presenter. Great topic. Breaking a terrifying monolithic task into easy to handle steps.

Cons - Not enough time to cover everything in the slides. Hard to see code samples from the back of the room.

Overall, definitely a helpful presentation. I came away with a lot of good ideas and good resources for digging into the topic deeper.

Excellent topic and content. Broken down into logical chunks that anyone should be able to consume.

Just wished we had more time.



Spot check, commit, push, notify QA.
FTW

Lots of great information. We ordered the book and are fully planning to follow this process for our app.

By far the best talk I've attended so far (Now its wednesday morning)
It was full of good advice, and delivered in a very engaging way.
Thanks!

Focus from the surface is very useful. Opens the mind to look at legacy codebase differently. Might save some bucks in attempting to rewrite a codebase. Requires in depth understanding to make real changes into a working team.

What if your legacy codebase is not PHP?

Good content, but a little much to consume in 3 hours. Many of the concepts could be summarized in much more brevity. I feel the room grasped each section in a shorter time than was spent describing it.

An excellent tutorial that suggested great solutions for legacy problems that I'm sure a disproportionate number of developers face. The first half of the talk outlined SOLID principles that you should apply to your legacy code, and while it would seem impossible to know where to start with SOLID in a legacy codebase, Paul gave a step by step guide to apply it. The second half was more about fixing up db queries and views/templates, which seemed marginally less important, especially if you plan at that point to get the code into a proper framework. The only point of disagreement I had is that Paul is reluctant to move to a framework after you have effectively created your own after the SOLID steps are followed, but it's hard to argue when I'm still sitting on a mountain of bad code and he's properly converted other systems before. Nevertheless, the talk gave great direction on how to fix up ancient code, and it was pretty striking how spot on his description of what our codebase looks like (includes everywhere, procedural, non-OO, etc). Highly recommended.

Very good tutorial. Covers all the aspects one has to have in mind when working with a dated application. Some topics were skipped, but that was to be expected.

Tons of great info. A bit too mind boggling for it all to sink in inside the time slot.

A tad overstuffed, but overall, really great
presentation delivered by a real pro. i will buy his book!

This was a great presentation.

This presentation demonstrated a coherent method of migrating your production application to more modern and easier to maintain code. Each incremental change kept the application running, while moving to better code.

As others have mentioned, there was a lot of information, some of which the Paul had to skip, but I preferred this to him not answering questions.

I highly recommend this program to anyone.