Following in the footsteps of Professional ASP 3. Developers who are new to server-side programming, or who are not completely comfortable with programming in general should look elsewhere. This book is not a tutorial guide to the basics of ASP. Although the chapter titles of this book correspond very closely to those in the SAMS book above, the authors of this book have adopted an entirely different attitude.
Instead of making it as easy as possible for the reader to learn the basics, this book delves deep into the technical minutiae of each ASP. NET feature covered, and leaves the applications for you to figure out. As in Professional ASP 3. The reasons for this are twofold: firstly, the book itself is geared heavily towards easy reference, so providing appendices could be viewed as redundant.
6 Java Web Frameworks to Build Scalable Applications - Developer Drive
Secondly, Wrox have just announced a new title, ASP. Well of course I think my own book is the best book on the subject! It assumes no prior programming knowledge, and guides you to a complete understanding of both PHP and MySQL, learning both of these exciting technologies "on the fly" as you build a database driven Website from the ground up. Check out the first four chapters online for free, and stay tuned for a more impartial 3rd party review on SitePoint. Attractively designed and very easy to read, this book was a pleasant surprise.
Although it relies on a familiarity with the basic concepts of programming statements, variables, if-statements, etc. Non-programmers may feel a little left behind, however; as the title suggests, the author does not waste much time teaching you the fundamentals of programming.
Topics in this book are logically organized to give you the information you need as you need it. String manipulation functions, for example, are covered in the same section as regular expressions, and are presented as "alternatives to regular expressions", a description that many seasoned PHP developer will nod along to. More advanced topics such as database interaction, session tracking, XML, and security are covered in sufficient detail for experienced developers to pick up the basics and learn the rest themselves, but beginners may struggle to put these tantalizing pieces together to produce a living, breathing Web application without additional guidance.
There are no reference appendices in this book, and the author clearly states from the start that the role of this book is to ease the learning process, not to regurgitate what can easily be found in the online reference. It lacks coverage of PHP4 features such as sessions, heredoc syntax, and Perl-compatible regular expressions, but most of these subjects can be picked up later by means of an online tutorial or two. For my complete review of this title, see this article.
Professional JSP, 2nd Ed. Wrox Press. This completeness comes with a big price tag, though, and developers looking only to get their feet wet or to learn the basics of JSP will be easily overwhelmed by the magnitude of this volume. Some readers may also be put off by the rather impersonal tone that a book written by so many different people invariably suffers from. If you plan to take it on as an introduction to the world of JSP, you had better be a very capable Java programmer boasting a strong grasp of Web application programming concepts, and with a penchant for learning new technologies by reading technically detailed reference material.
In fact, it is my best recommendation for an introductory JSP text. Without skimping on the details, this book provides a friendly introduction to the workd of JSP, tackling all the core aspects of the language, as well as some advanced topics like tag libraries, database interaction and email, with a consistent, task-oriented methodology. The methodology for enabling sessions in a page and making use of them is covered in passing in Chapter 4 "Basic JSP" , but beginners seeking a good introduction to sessions use will not even find them mentioned in the table of contents! The concepts involved are explained in detail, and several practical examples help drive home the fact that sessions are an integral part of JSP that should not be thought of separately, but used along with the rest of the power of the language.
Mastering ColdFusion 5 Sybex. This gigantic book it could easily break toes if dropped may appear to be an imposing read, which might put off beginners. More tech-savvy readers might see this as a sign of copious attention to detail and depth of coverage.
Built for productivity
Finally, those who need a reference they can stuff in their laptop bag to take on the road might also be put off by its bulk. Upon closer inspection, however, all three of these assumptions proved to be false. Of all the books I looked at, Mastering ColdFusion 5 offered the most newbie-friendly presentation and organization. With plenty of hand-holding, step-by-step guides that demonstrate how to accomplish various tasks, this book will provide a great tutorial introduction to ColdFusion for designers and other readers without a technical background.
Copious screenshots and use of larger fonts and margins pad out what could have been a much slimmer book; whether this is a good thing or a bad thing is up to you to decide. Unfortunately for advanced readers who may be enticed by the sheer heft of this massive volume, its size belies the relative lack of advanced material contained within.
- The Political Pundits (Praeger Series in Political Communication (Paperback));
- JavaServer Pages - AbeBooks - Larne Pekowsky: .
- Native Son.
- Religion and Law Review?
- Navigation menu?
Advanced topics tend to be covered only in passing in the final chapters of the book. The appendices in this book are attractively presented for easy reference and generally complete, though the two-column format may annoy some readers. The sheer bulk of the book might be a hindrance to its use as a handy reference, but the searchable PDF version of the book that comes included on the cover CD adds immensely to the portability of this book.
If you do CF development on the road, having this complete guide to ColdFusion on your laptop in electronic format might be the factor to sell you on this book. In the following JSTL, we show each of these cases in a c:out action, which is an action from the core library that spews the contents of its value attribute to the JSP's output:. The EL also defines a set of rules for coercing values in an expression to a type that corresponds to the context in which the values are used.
- Biological Functions of Microtubules and Related Structures.
- Space Exploration 2008 (Springer Praxis Books).
- Lectures on Fluid Dynamics: A Particle Theorist’s View of Supersymmetric, Non-Abelian, Noncommutative Fluid Mechanics and d-Branes!
- J2EE and Internet Application Development and Deployment.
- Families and Kinship in Contemporary Europe: Rules and Practices of Relatedness (Palgrave MacMillan Studies in Family and Intimate Life)!
We won't cover these rules in detail here; however, the approach is very similar to that defined in Perl. As with most things Perl, this approach works reasonably well, but, on occasion, gives results the language happily accepts, but may not be quite what you expect.
The EL provides support for accessing object properties and collection elements, a set of implicit objects, and using relational, logical, and arithmetic operators. For indexed properties, including arrays and java. List classes, elements can be accessed with syntax like the following:. Both JavaBean properties and java. In the first two expressions below, we can access a property named aProperty in a JavaBean or a Map entry with the key aProperty. In the third expression note I've left out the quotes , we access an element in anObject with a name held in the variable aVariableContainingPropertyName :.
The EL defines a full set of operators that corresponds closely to those you're familiar with in Java. I won't elaborate on these operators because they are all self-explanatory. I discuss the core library most since it's the one you'll certainly use; but I'll also cover the rest in enough detail to get you started. When you import any tag library into a JSP page, you define a prefix that designates a namespace corresponding to the tags in that library. The four standard tag libraries, with their JSTL spec-defined prefix conventions, are listed below.
Note that you could define your own prefixes, but there is absolutely no good reason for this. To use the EL core tag library in your page you're really just giving your page visibility into the namespace defined in the library , include the following example directive at the top of your page:. To use the tags in that core library, prefix each tag in your page with the prefix you've designated in your include statement:.
Let's examine the core tag library in more detail. We look at the most commonly used functionality first.
PHP Fast & Easy Web Development
The core library's most basic tag is the c:out tag, which displays an EL expression's value in a page. An example expression that uses c:out might look like this:. In the above, the value attribute is the expression we send to the page output.
Another commonly used core action is c:set , which sets a variable in a page. You can use c:set in two ways. The first way sets the variable defined in the var attribute to the value defined in the value attribute, as shown below:. The optional scope attribute above specifies that we want to set the variable customerID in the session scope; if scope is not specified, it defaults to page scope. Another powerful usage of c:set assigns the contents of the c:set tag's body to a specified variable:. In the above example, a c:set action defines a variable named cellContents in page scope that holds the contents defined in the tag's body.
In this case, the body defines an HTML table cell element. The c:out action in the body is evaluated, and that evaluation's results are included in the string literal in the body. As you might expect, JSTL has made exception handling a bit easier. JSTL offers a good alternative with the c:catch action, which provides an effective way to handle exceptions with a bit more granularity without embedding Java code in your pages.