Get Your Quote

Awesome! We’re just about ready to put together a quote for you. We just need your email, and for you to check out a couple savings you can take advantage of.

Optionally tell us a bit more about yourself

Take Advantage of extra Savings!

Pre-activation includes professional edition.
Your Quote hase been successfully submited.

Code Generation and the Developer Workflow

Posted on Jun 14th 2011

Recently, I had an interesting discussion with a MyEclipse for Spring (ME4S) customer regarding the integration of code generation tools into the software development process.  The IT Director highlighted for me how ME4S fits into their development workflow, sharing several diagrams that he uses to illustrate the software development lifecycle (SDLC).  The diagrams were very elaborate and encompassed everything from requirements gathering to application maintenance.  ME4S was listed as a sanctioned tool in several sections, the most notable sections being design (prototyping) and implementation.
One of the things that I found particularly interesting was how the decision to hand-code versus generate was illustrated.  The concept is very simple, and I’ve discussed it over and over again in various places (webinars, screencasts, blog posts), but until I saw the diagram, I never really considered it something that needed to be illustrated.  But now that I’ve seen it, I see the value.  I’ve recreated the diagram (with permission of course), and I modified it slightly to make it more general.
This first diagram illustrates a completely hand-coding approach to producing software code artifacts.  The basic idea is that at some point during application development you will identify a set of source code artifacts that are required to satisfy the requirements.  Depending on the size of the project or the methodology being used, the set of source code artifacts could come from designers during the design phase or from developers.  In either case, the required set of source code artifacts are identified, coded and delivered.
This second diagram illustrates the process when code generation tools like ME4S are available.  Just like the first diagram, a required set of source code artifacts are identified.  The difference is that you have various options for producing them.  The first option is to use code generation tools to fully produce the required artifact.  After all, why would you hand-code something if it can be completely generated? The second option is to use code generation tools, too; however, it acknowledges that in some cases the artifact can’t be fully generated.  The code generation tools will get you close, but the developer will need tailor the generated artifact.  For example, the developer may remove unnecessary code, add missing code or just copy-and-paste a few code fragments.  Finally, if the source code artifact can’t be completely or partially generated, then the third option is to just hand-code it.
To achieve the benefits of code generation in the manner illustrated, a developer needs to be very familiar with all of the artifacts that can be generated.  ME4S 9.0 is the present version, and it can generate software components for Spring MVC, Spring Web Flow, Spring Security, REST, JAX-WS, Adobe Flex, Google Web Toolkit (GWT), iPhone w/ iWebKit, JPA, DAO and JSF 2.0/Primefaces.  The thing that differentiates a ME4S expert from a beginner is that the expert knows how to squeeze everything they can out of code generation.  Code generation is always their first option, and they will only revert to hand-coding when code generation options don’t exist. I hope this post is helpful to current and future ME4S users.  I realize that some ME4S users don’t view the code generation functions of ME4S in this manner.  The primary ME4S use case for many developers is to use the code generation functions to quickly a generate a fully implemented, ready-to-run application.  Just remember that generating fully-implemented, ready-to-run applications is a testament to the completeness and quality of the ME4S code generation functions, but it’s not the only use case. :-)

Software Component Generation – The Value Proposition is Simple

Posted on Jun 6th 2011

MyEclipse for Spring 9.0 (ME4S) was released almost two months ago, and the feedback has been excellent. We’re happy to see so many developers and corporate IT shops share our belief that MyEclipse for Spring is the best IDE for Spring development. Frankly, there just isn’t any other IDE in the market that packs in as many Spring development tools into one bundle. One of the exclusive tools in ME4S is Software Component Generation, and the value proposition is very simple...the more software components you can generate, the less code you’ll have to write by hand.

ME4S has an extensive set of the basic tools that all Spring developers need in an IDE, including editors, content assist, and refactoring support. While these basic tools are important, these tools are only focused on code editing. Granted....these tools will save the developer a few steps here and there, but that hardly represents the peak of productivity. That’s where the advanced tools in ME4S come in to play. ME4S can generate custom software components a lot faster than writing them by hand. The software components reflect best practices, don’t introduce any additional runtime dependencies, and look exactly like they were written by hand. An IT shop recently shared with us their experience with using ME4S to migrate a homegrown PHP/MySQL web application (~150 tables) to an Adobe FLEX application with a Spring backend. Using the ME4S software component generation tools, the IT shop was able to produce, among other things, the data access components (JPA/Hibernate), the service components (Spring), and the user interface list/view/edit components (Adobe Flex) for all 150 tables in less than one day. That’s over 800 java classes, 500 mxml files, and 300 actionscript files. Needless to say, they are extremely happy the amount of time (and money) that ME4S has saved them. ME4S 9.0 is the present version, and it can generate software components for Spring MVC, Spring Web Flow, Spring Security, REST, JAX-WS, Adobe Flex, Google Web Toolkit (GWT), iPhone w/ iWebKit, JPA, DAO and JSF 2.0/Primefaces. If you haven’t tried ME4S, we encourage you to check it out with a free 30-day trial. And, let us know if you have an idea for additional software components that you would like see generated.