The Angular Mini-Book is a
guide to getting started with Angular. You'll learn how to develop a bare-bones application, test it, and
deploy it. Then you'll move on to adding Bootstrap, Angular Material, continuous integration, and authentication.
Spring Boot is a popular framework for building REST APIs. You'll learn how to integrate Angular with Spring Boot and use security best practices like HTTPS and a content security policy.
For book updates, follow @angular_book on Twitter.
The JHipster Mini-Book is a
guide to getting started with hip technologies today: Angular, Bootstrap, and Spring
Boot. All of these frameworks are wrapped up in an easy-to-use project called JHipster.
This book shows you how to build an app with JHipster, and guides you through the plethora of tools, techniques and options you can use. Furthermore, it explains the UI and API building blocks so you understand the underpinnings of your great application.
For book updates, follow @jhipster-book on Twitter.
Below is the presentation I'm delivering at OSCON today. Unfortunately, I had to remove slides on GWT and Flex to fit w/in the 45 minute time limit. I hope to expand this presentation in the future, as well as continue to develop the side project I'm working on using these technologies.
Thanks to everyone who commented on my previous post and offered recommendations for RIAs to develop in 20 hours or less. In order to narrow down my choices, I've created a survey on SurveyMonkey.com. Here's a list of the application ideas I received from comments and e-mails:
I like #3 (Resume) and #9 (Status) because I may be able to tie those into LinkedIn's RESTful API.
Click here to vote for the application you'd like me to develop »
Voting ends at noon on Friday (Mountain Time).
Update: My co-workers had a good suggestion at lunch today: pitchersacrossamerica.com. It seems it's kinda difficult to find bars that serve pitchers these days (at least in Denver). Create an app that allows people to enter in bars and restaurants that serve pitchers and show them on a map. Seems simple and fun. If enough people like the idea, I'll restart the survey with this as an option. In the meantime, the current (Wednesday night) numbers are here.
Update 2: Here's the results as of Thursday night. Only 15.5 more hours to vote!
Update 3: Final Results. Thanks to everyone who voted! I'm traveling a lot next week (Mountain View followed by Boston), but I'll try to write an entry on next steps.
In less than two months, I'm making my annual trek to Portland, Oregon to speak at OSCON. To prepare for my talk, I'd like to develop the same application with two different combinations: Flex + Rails and GWT + Grails.
As luck would have it, I'm having a hard time coming up with a good application to write. I'd like to time-box it so I only spend 10 hours on the backend (for each) and 10 hours on the front-end, for a total of 40 hours for both applications.
Can you think of any good applications that would warrant a rich front-end and wouldn't take too long to create? I'd like to put both applications in production and generate enough traffic to be faced with scalability issues.
Over the next several weeks, I hope to start creating the applications and blog about what I've learned along the way. At some point, I hope to post an outline and a rough draft. With your help, I believe this can be an excellent presentation. If the presentation and applications are as good as I hope they'll be, it's likely I'll open source them for everyone to use.
Thanks in advance for any advice.
Update: Thanks for all the great feedback. I've posted a survey to narrow the choices.
From an e-mail I received earlier this afternoon:
We are pleased to accept the following proposal for OSCON 2008.
* Web Frameworks of the Future: Flex, GWT, Grails and Rails
It has been scheduled for 16:30 on 23 Jul 2008.
My Abstract:
What if the choices in web framework was reduced to 4? If RIA are the way of the future, it's possible that these 4 frameworks are the best choices for this development paradigm. This session will explore these frameworks, as well as entertain many other's opinions on the future of web development.
RESTful backends are easy to create with both Rails and Grails. Ajax frontends are simple to create and maintain with GWT. Flex gives you flash and a pretty UI. If you're an HTML developer, Rails allows you to quickly develop MVC applications. If you're a Java Developer, GWT + Grails might be a match made in heaven. This session is designed to help you learn more about each framework and decide which combination is best for your project.
I'm really looking forward to learning about GWT and Flex in the coming months. If you have any experience (or opinions) about the abstract above, I'd love to hear it. The louder the better.
For those who haven't been, OSCON is one of those truly special conferences. Possible reasons:
I'm going for all 4 reasons and even made a reservation to stay at The Kennedy School. Should be a fun show.
In a comment, Jared Peterson asked:
I'm curious if you have any thoughts on folks that might be trying to make a decision between Rails and Grails. I like the concept of "Allow Both", but what if you "have neither"?
If you were starting a new project, could choose either one, needed to interact with a lot of existing Java code (JRuby on Rails I guess), what would you pick?
A friend recently asked me "Can I solicit your honest, unadulterated opinion on Grails?" I think the e-mail I sent him may help Jared's question.
I think it's awesome. IMO, it's the same thing as AppFuse, but it has
a DSL that's much simpler to learn and remember. Less code -> faster
productivity. There does seem to be some maturity issues, but I think
it'll get there. The question is - how fast can Groovy become. It's
similar to Rails and Ruby in that you start using Grails and you
think "This Groovy thing is kinda cool, I'd like to learn more." One
of the reasons I really like it is the learning curve for experienced
open source Java Developers is virtually flat. You can learn enough
to be productive in a single day.
That being said, I think there's also a lot of cool stuff going on
with RIA. IMO, Flex or GWT + Grails would be a really fun set of
tools to develop with. Here's a excerpt from a write-up I recently
did when analyzing Rails and Grails at LinkedIn (in January):
--------
Comparing Rails and Grails
They're both excellent frameworks. Rails is definitely more mature,
but the environment is a pain to setup (esp. on Windows). Grails is
very easy to setup for Java Developers. Grails needs a lot of
improvement as far as hot deploy and stack traces. It's probably
Groovy's fault, but its stack traces are hideous - rarely pointing to
the class and line number in the first few lines.
As for hot deploy, it doesn't work nearly as well as it does with
Rails. Rails' "script/server" starts WEBrick in a few seconds, while
"grails run-app" can take up to 10 seconds (even on a brand new
application). Even with its warts, Grails is simply awesome. I
really, really enjoy writing Groovy code in IDEA and seeing immediate
changes. I don't like "test-app" as much as I like Rails'
"test:units" (or even better, "test:uncommitted"). It seems to be
widely realized that Rails has a better testing story.
Rails is immediate, Grails is immediate 70% of the time.
Groovy is extremely easy to learn for Java Developers. Ruby is easy
too learn, and possibly too powerful for OO rookies. Both are fun to
program in and very capable of allowing greater developer
productivity. If you know Hibernate, Spring, SiteMesh and JSP, you
owe it to yourself to look at Grails. If you know these technologies
well, you can learn Grails in less than an hour. You can be
productive in the next hour and have an application running by the
end of the day. That's not to take anything away from Ruby. I believe
that Rails is an excellent platform as well. It's pretty cool that
profiling and benchmarking are built into the framework and you can
easily judge how many servers you'll need to scale.
I used IDEA while developing with both frameworks. IDEA has Rails and
Groovy support available via plugins and they both worked quite well.
The support for Grails was much better than Rails. Grails offers code
completion, Ctrl+click on classes/methods, debugging and starting/
stopping the webapp from your IDE. Rails doesn't offer much in the
way of Ctrl+clicking on class names/methods or debugging.
--------
Is there anything that Rails can do that Grails can't? Not as far as I can tell. I think it really comes down to developer passion and team preference. If you have experienced Java Developers that like the ecosystem and its tools, Grails makes a lot of sense. If you have experienced PHP developers or frustrated J2EE developers, they might enjoy Rails more. One thing that's very cool about both frameworks - learning one actually teaches you things about the other. They're so similar in many respects that knowledge is transferable between the two.
Of course, this is all just my opinion after working with both frameworks for a few weeks. For anyone who has tried both, what do you think?
In closing, here's an excerpt from a recent comment I left on Javalobby:
Of course, the hard part now is deciding between Django, Rails, Grails and GWT for your web framework. Then again, that's like having to choose between a Ferrari, Porsche, Lamborghini and a Maserati. No matter which one you choose, it's unlikely you'll be disappointed.
As you might know, I've spent the last several months working for one of the coolest clients ever: LinkedIn. They hired me back in July 2007 and I was impressed on day one. I was originally hired to help them evaluate open source Java web frameworks and try to determine if moving from their proprietary one to an open source one would help improve developer productivity.
After looking at all the options, I recommended we look at Struts 2 and Spring MVC - primarily because they seemed to be the best frameworks for a LinkedIn-type of application. Another Engineer and I prototyped with Struts 2 for about 6 weeks and came up with a prototype that worked quite well. While our mission was successful, we found a couple issues with Struts 2 and standard JSP that might actually hurt developer productivity more than it helped.
Following this project, I worked on the New Homepage Team, which is now visible to everyone that logs onto LinkedIn. My role was minimal, but it was still a very fun project to work on. You know those widgets in the right panel? I did the initial UI and backend integration for those. All the business logic, Ajax/JavaScript, CSS, and optimization was done by other folks on the team. Shortly after this project went live in November, I started prototyping again with Spring MVC + JSP.
The reason I was asked to prototype with Spring MVC was because they were using Spring on the backend, Spring MVC in a couple other projects, and a new project was being kicked off that used Grails. Rather than add another framework (Struts 2) to the mix, they wanted to see if they could suppress any further framework proliferation.
After a month of prototyping with Spring MVC + JSP, my results weren't as good as Struts 2. With Struts 2, I was able to use OGNL to do all the things their current JSP implementation allows them to do (call methods with arguments, use statics in EL, etc.). With standard JSP, a lot of this wasn't possible. If it was - it required writing lots of tag libraries and made it more cumbersome for developers to do certain things. At the end of that project, I determined that using FreeMarker might solve these problems. I also determined that neither Struts 2 nor Spring MVC would solve the ultimate problem of developer productivity. Neither framework would allow developers to go from make-a-change-and-deploy, wait-3-minutes-to-see-change-in-browser to make-a-change, save and wait-15-seconds-to-see-change-in-browser.
I recommended that this be the ultimate goal - to get rid of the deployment cycle and to allow minimal turnaround when deploying modified classes. After that problem was solved, it's true that moving to an open source web framework would likely provide an easier-to-remember API. However, the problem with moving to a new web framework would be that everything used to construct the existing site would suddenly become legacy code.
In the end, we concluded that the best solution might be to enhance the existing framework to be more like the available open source options. This would allow existing applications to keep using their code -- and if we enhance properly -- new applications can use a simpler, less verbose API and a templating framework that's easier to understand. We can make LinkedIn's version of JSP more like standard JSP while allowing its powerful EL to remain. We can add support for JSP Tag Libraries and Tag Files.
One of the benefits of moving to an open source web framework is there's a community, documentation and books that describe the best (or most common) ways to solve problems with the framework. LinkedIn has this, but it's all in code and no one seems to have a high-level of confidence that the way that they did it is the "best" way. Developers communicate well, but all the knowledge is stuck in their heads and inboxes - there's no way for new developers to search this knowledge and figure it out on their own without asking somebody.
By adopting an open source web framework, it's possible to solve part of this problem, but I think it's still going to exist - where a few engineers know how to use the framework really well (for the specific application) and the rest don't. We determined that regardless of open source vs. proprietary framework, what was needed was a set of developers that acted as authorities on how to develop web applications at LinkedIn. A UI Frameworks Team if you will. This would be their only job and they would never get pulled from this to work on projects or complete tasks related to LinkedIn's products. Some developers mentioned that they'd been asking for this for years, and some folks had even been hired for this. However, the formulation of this group has never happened and it's obvious (now more than ever) that it'd be awesome to have them.
The UI Frameworks Team
At the end of 6 months, it seemed my work was done at LinkedIn. I liked the idea of a UI Frameworks Team and recommended they start it with the authors of the existing web framework. They agreed this was a good idea. A few days later, I was pulled into the CTO's office and he offered me the job. He offered me the challenge of building this team and told me I could do it remotely (from Denver) and hire my own people to help me with it. I gulped as I realized I'd just been offered the opportunity of a lifetime. I knew that while this might not be the best option for LinkedIn, it certainly was an excellent opportunity for me. I said I'd think about it.
In the meantime, I was given a project which you might've read about. They asked me to migrate a Rails application to Grails and try to determine if they really needed both frameworks. I spent 2 weeks coming up to speed on both and flew to Mountain View to deliver my conclusion. Here's an excerpt from an internal blog post I wrote.
As far as I know, Rails has been used at LinkedIn for well over 6 months and Grails has been used for a similar duration. Both projects that've used these technologies have enjoyed extreme success. Both projects have been fun for the developers working on them and both have improved the technologies/frameworks they're using.
Here's an interesting quote about the Rails application:
Another app you might want to look at is BumperSticker, our facebook app. Interestingly we heard through joyent that DHH (the creator of Rails) told them that BumperSticker is the biggest rails app in the world (in terms of page views) - we are closing in on 1 billion monthly page views and we have 1 million unique users per day (about 10 million installs on FB). It's a little trickier to setup in a dev environment since you need to be running on FB, but the code itself is pretty interesting since we've iterated on it a bunch of times and are making extensive use of third party libraries such as memcached.
This quote loosely translates to "We have some Rails Ninjas on staff and we've been quite successful in developing with it and making it scale".
Both platforms have allowed developers to iterate quickly and turbo-charge their productivity.
My Conclusion: Allow Both
Why?
If you have talented developers that can whip out kick-ass code with either platform, pay them and pay them well. Passion is the most important part of any job. If developers are passionate about the application they're developing and the language they're using (notice language is secondary) - they can do great things.
I know this probably isn't the answer you wanted to hear, but it's what I believe. I think both frameworks are very similar. I believe the knowledge you gain from learning one framework is transferable to the other. A lot of the things I learned about Rails worked with Grails. Ruby's syntax is similar to Groovy's.
There's a natural synergy between these two frameworks. The hard part is figuring out when to use which one.
The application that I was asked to port from Rails to Grails? The one that was launched last week - LinkedIn Mobile.
After doing this research, I stepped up to the plate and accepted the offer to start a UI Frameworks Team and recruited some kick-ass Java Developers I know to be the founding members. Last week, I flew out to Mountain View to do some kickoff meetings and start getting the infrastructure in place so we can document, support and release code like a well-oiled open source project. There's nothing saying we won't use an open source web framework as the underlying engine, but I think this should be an excellent chance to see the power of open source governance and development style in a corporate environment.
Director of Engineering, Core Experience
I should mention one last thing. If you're an experienced Java Developer/Architect with a passion and deep knowledge of UI development (JavaScript, CSS, HTML), we've got a Director of Engineering, Core Experience position with your name on it. I might even get to interview you if you apply for this job. Furthermore, whoever gets hired will likely work very closely with my team. What's not to like about that!? 
David Sachdev left the following comment in my post about the Java Web Framework Smackdown at TSSJS in Vegas:
The number of web frameworks out there is just astonishing, and in alot of ways I think that there is need for some consolidation in some way, shape or form. If you work in the Java world there is a sense of consolidation in the ORM space these days with JPA (the Java Persistence API). Sure if you are working strictly with JPA it is a bit more limiting then working directly with Hibernate, iBatis, or TopLink - but you no longer worry that you have made a critical misstep in your architecture by tying yourself do a particular ORM implementation. Similarly Spring gives you that similar "loosely coupled" feel that if Google's Guice because appealing to you, you don't feel like you've wasted all your framework foo on Spring. But web frameworks....that's another story.
I think if you had asked me a few months ago, I would have told you that the industry is promoting JSF (Java Server Faces). Everything from support in the IDEs to the availability of AJAX frameworks...and of course a flexible life cycle that allows for alternate implementations and various code to plug or be weaved in to the life cycle. And that while JSF on its own left quite a bit to be desired, the JBoss Seam project really has filled in the gaps in JSF, and in fact brought Java web development closer in agility to the Rails and Grails of the world that tout quickly built and deployed web applications.
But the thing that you continue to hear is that programming in JSF is painful. And you hear that EVERYONE used to use Struts. And that it is time to move past Struts. And given that, you have to consider Webwork and the merger of Struts2 into that framework - and their claims of rapid development. But you also have to consider Spring WebFlow and how that may help solve your JSF ills given that everyone is building off of the Spring Framework and they have been so good about keeping the framework updated and integrating the best of what is out there while innovating themselves. And then if you are looking at Spring WebFlow, you kinda have to go "Wait, but what about Spring MVC?"
Given its age, you might quickly dismiss Spring MVC until you realize that Grails is build upon it. Grails, that web platform that every java developer is either working with, or intends to work with soon. (Come on, you all have made the Ruby/Rails, Groovy/Grails, JRuby decision in favor of G2, right? I mean all the flexibility of what is out there in the Java world on top of the JVM, with a language that doesn't suck the life outta you....) And then you have to wonder that if you build upon Spring MVC as well as using Groovy and Grails where appropriate, might you be able to make that killer app in half the time.
But wait, you didn't think your choices were nearly that simple did you? There is this wonderful software company out in Mountain View that we need to pay attention too. In Google We Trust, right? And even if you don't worship at the Temple of the G (TOTG) like Sprout, you don't want to ignore them. And, if you've looked at the Google Web Toolkit (GWT) and weren't at least slightly impressed, I would be surprised. And if you are looking at the GWT, you can't totally ignore Yahoo's YUI - maybe with some of the what Prototype, Scriptaculous, or DoJo offer you. And then someone will come over and point out Echo2 to you, and well you have to admit, their demo looks nice. And well, there is Adobe Flex, and OpenLaszlo - I mean after all isn't Web 2.0 all about Rich Internet Applications. And surely you've heard that the performance of Swing is so much better these days and the "power of the modern Java applet"
So at the end of it all, you've got yourself alot of R&D to do, and just as you thing you've got a good grasp for the offerings out there, new and improved versions are out. And don't worry, someone else is also busy working on a new and greater web framework that you have to consider.
Wow - that's quite a mouthful David. Well written!
P.S. The Early Bird Deadline for TSSJS is today.
Two weeks ago, I mentioned a number of books I was hoping to read to get up to speed on Rails and Grails quickly. Over the last two weeks, I was able to polish off three of these (listed in order of reading):
Below are short reviews of each book.
Getting Started with Grails
The Good:
This is the perfect book to learn the basics of Grails quickly. At 133 pages, I was able to read this entire book in one sitting. The first couple chapters are very introductory, but likely necessary for beginners. The good news is you start writing your first Grails application on page 7 (Chapter 3).
Chapter 4 (Improving the User Experience) is good in that it shows you how to do warning, error and confirmation messages. This is something often overlooked in web frameworks and Rails and its "flash" concept seem to have made it important again. I remember way back in 2003 when I complained about frameworks not allowing messages to live through a redirect - everyone said it was something you didn't need. Now it's a standard part of most web frameworks.
The Bad: Uses Grails 0.3.1. This is understandable since the book was written in 2006 and published in 2007. Also, it doesn't cover testing that much (5 pages). If testing is so easy with Groovy and if Grails has Canoo WebTest support built-in, it should be shown IMO.
Rails for Java Developers
The Good:
This was an interesting book for me because it uses AppFuse for many of its Java-based examples. Unfortunately, it uses the Struts 1.x version which is cumbersome and verbose as far as Java web frameworks go. The most impressive part of this book is how Justin and Stu do an excellent job of walking the line and not insulting Java nor developers using it. They provide an easy to understand view of Rails from a Java Developer's perspective. There's detailed chapters on ActiveRecord (as it compares to Hibernate), ActiveController (compared to Struts) and ActiveView (compared to JSP). This book has excellent chapters on Testing, Automating the Development Process and Security.
The Bad: This book was published over a year ago, so it uses an older version of Rails. This means some commands don't work if you're using Rails 2.0. It's also a little light on Ruby, so I didn't feel I learned as much about the language as I was hoping to. That's understandable as it's more of a Rails book than a Ruby book.
Groovy Recipes (Beta from Jan 3, 2008)
The Good:
I really like the style of this book and that it shows you how to get things done quickly with code samples. It's very no-nonsense in the fact that it contains a lot of code and howtos. I really like Scott's writing style and found this book the easiest to read of the three. This may have something to do with my eagerness to learn Groovy more than anything. The most refreshing part about this book is how up-to-date it is. Because it's a Beta, it seems to contain the most up-to-date information on Groovy and Grails. After reading Getting Started with Grails and working with it for a couple weeks, the first Grails chapter seemed a little basic - but that's likely because I've figured out how to mix all those recipes already. The Grails and Web Services chapter definitely has some interesting content, but I've rarely had a need to implement these recipes in a real-world environment. I'd rather see recipes on testing the UI (with the WebTest plugin) and how to use GWT and Flex with Grails. If SOUIs are the way of the feature, this is a must.
The Bad: Not much information on testing with GroovyTestCase, mock objects or implementing Security. If one of Groovy's sweet spots is testing, why isn't there more coverage on this topic? The Java and Groovy integration chapter is especially good, but there's very limited information on Ant and Maven. It's likely the websites provide sufficient documentation, but the Maven section only fills 5 lines on an otherwise blank page. The biggest problem I have with this book is I really like the recipes writing style and would love to see more tips and tricks. At 250 pages, I was able to finish this book with pleasure in a few days.
What's Next?
Now I'm reading JRuby on Rails (Apress) and Programming Groovy (Pragmatic Programmers). Following that, I'll be perusing dead-tree versions of Struts 2 Web 2.0 Projects (Apress), Prototype and script.aculo.us (Pragmatics) and Laszlo in Action (Manning). If any publishers want to send me books on GWT and Flex, I'd be happy to add them to my list.
A couple of interesting things happened today that relate to my Grails vs. Rails quest for knowledge.
The first is that Grails 1.0 was released. This was apparently a huge event as it swamped Codehaus' servers for a couple hours. This morning, it was pretty cool to shake Graeme's hand and congratulate him on the release. I also got to meet Jeff Brown for the first time. Who needs to go to a conference when you get to talk to these guys at work?
Secondly, I found an article by Ryan Shillington that shows how to deploy a Rails application to WebSphere. To me Rails + WebSphere seems like the last thing a Rails advocate would want - but who knows. In my experience, most developers that use WebSphere don't do it by choice.
For companies that have invested a lot of time and money into the JVM as a platform, it seems like Grails is the clear winner over Rails. However, the line gets blurry when you start talking about JRuby. I think JRuby will get there, but I don't believe it's there yet. If you look at the two major JRuby on Rails success stories (from Oracle and Sun), they've had to fix performance issues as part of their projects. With big companies investing in the platform, it's highly likely performance will be fixed in the near future. I believe both the Groovy and JRuby teams have said performance enhancements are their top priority for their next releases.
I think the biggest news related to performance of dynamic languages on the JVM is the new Da Vinci Machine project.
This project will prototype a number of extensions to the JVM, so that it can run non-Java languages efficiently, with a performance level comparable to that of Java itself.
Dynamic languages on the JVM seem to have a very bright future.
I got involved with Struts and Spring just before their 1.0 releases. Is it simply a coincidence that I happened to start looking into Grails right before its 1.0 release?
What's the best way to learn Rails and Grails and satisfy one of my New Year's Resolutions (read more) at the same time? Books:
Thanks to connections with publishers, I was able to get PDFs of most of these for free. The only ones I paid for were the beta books (Groovy Recipes and Programming Groovy) from the Pragmatic Programmers. I doubt I'll read them all, but I've had fun so far.
I polished off Getting Started with Grails in a few hours. I expect to finish Rails for Java Developers this week. I used to hate reading PDFs, but I've enjoyed reading these books. A 30" monitor might have something to do with it.
After honing my Grails and Rails knowledge, I hope to become a GWT and Flex Ninja. For those GWT and Flex experts out there, what are the best books for those technologies? By "best", I mean the most advanced and up-to-date.
