Showing posts with label scripting. Show all posts
Showing posts with label scripting. Show all posts

Scripting in Java: Languages, Frameworks, and Patterns Review

Scripting in Java: Languages, Frameworks, and Patterns
Average Reviews:

(More customer reviews)
Are you looking to buy Scripting in Java: Languages, Frameworks, and Patterns? Here is the right place to find the great deals. we can offer discounts of up to 90% on Scripting in Java: Languages, Frameworks, and Patterns. Check out the link below:

>> Click Here to See Compare Prices and Get the Best Offers

Scripting in Java: Languages, Frameworks, and Patterns Review"Scripting in Java" is a great book to get started with using scripting languages that interact with Java. It is assumed the reader knows Java syntax, a reasonable assumption. The author does go into detail on dynamic vs static languages, the role of the JVM and other concepts. This is helpful as it highlights the important parts when thinking about scripting languages. When discussing any scripting language, the author includes a section on setting it up.
The description of scripting languages, benefits, syntax and libraries is all good. The author shows how to call scripting languages from Java and vice versa. I particularly like how the author pointed out concepts about each language such as how variables are handled. I also like how the author addressed concerns people, myself included, have about scripting languages. The end of the book covers advanced concepts about the scripting framework.
My only complaint is the formatting of the book. It has very large two inch margins. The text is only four inches wide. This makes the book seem heavier/thicker than it needs to be. More importantly, some of the code listings don't follow the huge margin requirement. On some pages, you see a code fragment that honors the two inch margin and another only a half inch from the edge of the book. This happens just often enough to be disorienting when reading.
Overall, the book is very good and I recommend it.Scripting in Java: Languages, Frameworks, and Patterns Overview

Want to learn more information about Scripting in Java: Languages, Frameworks, and Patterns?

>> Click Here to See All Customer Reviews & Ratings Now
Read More...

Simply JavaScript Review

Simply JavaScript
Average Reviews:

(More customer reviews)
Are you looking to buy Simply JavaScript? Here is the right place to find the great deals. we can offer discounts of up to 90% on Simply JavaScript. Check out the link below:

>> Click Here to See Compare Prices and Get the Best Offers

Simply JavaScript ReviewSimply Javascript by Kevin Yank and Cameron Adams lives up to the subtitle of Everything you need to learn Javascript from scratch. Javascript is a tricky subject to tackle. The Internet is full of Javascript snippets and code samples everywhere you look. Often times these code samples are less than satisfactory when you are addressing accessibility within your website. Many of the code samples contain outdated and proprietary code samples, making it a task to work out kinks and debug. The good news with this book is that they stick to a standard. All code used in this book uses object literal notation. Sticking to a coding style and format helps make this book an incredible read. Throughout this book you will learn the underpinnings of Javascript and how you can achieve different tasks.
Learning Javascript from scratch can be a daunting task. After all, there are several libraries and free scripts that you can essentially download and plugin to your website. But what happens when things go wrong? What happens when you need to modify the script to fit your needs? Having a solid foundation and understanding of Javascript will help you as you begin to develop for your own needs. This book gently walks you through the steps you need to take to achieve that solid foundation.Chapter 1 starts off with a brief primer of unobtrusive Javascript and it's role in the three layers of the web. HTML is your content. CSS is your presentation. Javascript is your behavior. These three aspects need to be separate from one another and also co-exist at the same time. Gone are the days of inline event handlers and functions. Using the power of the DOM you can rest assured your HTML will be pure and your applications will work flawlessly without Javascript enabled.
Chapter 2 spends some time setting up the foundation for beginners. This chapter walks you through statements, comments, variables and different variable types, conditions and loops, functions, and objects. Whew, that was a mouthful. This is where the standard of coding is introduced that will be used throughout the rest of the book. Things such as code indenting and formatting are touched on as well. This allows you to write clean code that is readable by you and other developers who may be working with your code. As stated earlier, all code uses object literal notation, and therefore this is explained in this chapter. A few examples are given and we are off to building some handy tools.

Chapter 3 gives you the necessary road map. This chapter is devoted to traversing the Document Object Model. A few helper classes are shown here that will allow us to retrieve elements by class name, add class names to an element, remove class names from an element, and check for the existence of class names within in an element. These will be used extensively throughout the book and are placed in their Core object. In addition to being able to traverse by class names, there is also the list of standard elements such as getElementById and getElementsByTagName. With these powerful tools at our finger tips we can now begin altering our pages as deemed necessary. The example given here is one of striping table rows. For those who don't do this on the server side, this simple task allows you to stripe your rows via the DOM.
Sure it's cool to add stripes to a table, but how can we do more? Chapter 4 is all about Events and the power they add to interacting with the DOM. The brief history lesson in this chapter helps us understand the different interpretations of different browsers and how we can use object detection to abstract these tasks into the Core object. Event Listeners and Event Handlers are both discussed in great detail. We move on to two working examples: Rich tooltips and Accordion. Rich tooltips are used to extract information from our title attribute and then apply them to a more stylish hover tooltip effect. Accordion allows us to save space on our pages by gradually showing the content as it is requested by either a click or keyboard event.
Chapter 5 gets us moving even more. This chapter is devoted to Animation and is probably one of the more complex chapters of the book. We are introduced to two methods, setTimeout and setInterval. Working mainly with setTimeout we are able to achieve our animation effects. This chapter looks at the principles of animation and an example of path-based motion with a soccer ball. We then use our new-found knowledge to extend our tooltip to show after a specified time, and our accordion is given a nice slide effect. We simply extend the code from our previous chapter to make these things happen. This is a good example of the benefits of working with objects and decoupling inside of your Javascript.
Chapter 6 gives use a few more tools to work with Forms. Forms are never easy to manipulate. Whether it be the style or the behavior. The beginning of the chapter starts with smaller scripts and examples of manipulating forms. This is done by specifying dependent fields and only showing them when necessary, and creating cascading menus from a select and it's optgroup. We then move on to some more advanced features for validation and creating a custom slider. These have been presented before in other areas, so nothing is really new in this area. However, this is all a part of understanding the bigger picture and the possibilities. It is about getting the creative juices flowing.
Chapter 7 discusses the inevitable testing for errors and debugging your application. We walk through the different types of erros: syntax, runtime, and logic. With each of these code samples are given with errors. We then use the tools of the browsers to make sense of their often cryptic error messages. In order to debug Javascript there is an invaluable tool in Firebug, a plugin for the popular Firefox web browser.
More interaction is still left as chapter 8 moves us to AJAX. Some very strong disclaimers are made as to when and where to use the right tool for the right job. Caution is also given in regards to assistive devices such as screen readers. With the warnings out of the way, we move to a some practical examples. The first is a small weather widget and the second is an extension to form validation.
The book finishes off by looking too the future of Javascript. Discussions of Rich Internet Applications and their place inside of the web help to stimulate your mind as you think about the possibilities. Not only about building applications on the web, but also using Javascript for such things as Dashboard Widgets and even browser development. In the hands of responsible developers, the future looks exciting for Javascript.
The Appendix is a very important part to this book, and I like its placement. The appendix goes through the Core methods used throughout the entire book. But why wait until the end of the book? Had this chapter shown up earlier it would have caused more confusion than necessary, and more explanation that necessary. As a reader you have the option to read this appendix first, but I felt it was well placed and covered thoroughly at the end of the book. By this point in the book you will have gained enough knowledge to dive in, whereas the beginning might have left you asking all the wrong questions.
If you have been developing Javascript for any amount of time, then you are most likely aware of the array of libraries available to us. These include Prototype, Scriptaculous, jQuery, Dojo, MooTools, and YUI to name a few. Each chapter of this book ends with a discussion of the libraries and how they can be used to help achieve the different tasks. Some libraries can achieve some tasks, while others still take a little work. The authors give a fair coverage to the libraries but do not dwell on them as the end-all-be-all of Javascript. If anything, the author's stress that you understand your Javascript at the core and know why you are doing what you are doing. This book sticks to unobtrusive principles and doesn't take shortcuts. The authors strive to make sure the code is of high quality and compatible cross-browser, but they never take the easy way out. Things such as innerHTML are put away in favor of building the DOM on the fly. This adds to the overall excellent quality of this book. The excellent code coupled with beautiful illustrations make this book easy to take small chunks at a time.Simply JavaScript Overview
Everything you need to learn JavaScript from Scratch!

Packed with numerous examples, Simply JavaScript is a step-by-step introduction to programming in JavaScript the right way. Learn how easy it is to use JavaScript to solve real-world problems, build smarter forms, track user events (such as mouse clicks and key strokes), and design eye-catching animations. Then move into more powerful techniques using the DOM and Ajax.
Learn JavaScript's built-in functions, methods, and properties. Easily integrate JavaScript in your web site. Use JavaScript to validate form entries and interact with your users. Understand how to respond to user events. Create animations that bring your web site to life. Start programming using the DOM and Ajax.
Unlike other JavaScript books, modern best practices such as progressive enhancement, accessibility and unobtrusive scripting are used from the very beginning. All the code in the book is also cross-browser compatible and downloadable for free, so you can get started instantly!


Want to learn more information about Simply JavaScript?

>> Click Here to See All Customer Reviews & Ratings Now
Read More...

Active Directory: Designing, Deploying, and Running Active Directory, Fourth Edition Review

Active Directory: Designing, Deploying, and Running Active Directory, Fourth Edition
Average Reviews:

(More customer reviews)
Are you looking to buy Active Directory: Designing, Deploying, and Running Active Directory, Fourth Edition? Here is the right place to find the great deals. we can offer discounts of up to 90% on Active Directory: Designing, Deploying, and Running Active Directory, Fourth Edition. Check out the link below:

>> Click Here to See Compare Prices and Get the Best Offers

Active Directory: Designing, Deploying, and Running Active Directory, Fourth Edition ReviewThis is a truly excellent book. Written by the person who headed up the largest Windows 2000 deployment (in Europe) to date, it not only covers the 'What' of Active Directory, but the 'How' and 'Why'. This includes not only the technical aspects of Active Directory but also the operational and business aspects that are all too rarely addressed in this kind of book,but that absolutely have to be dealt with if any kind of ROI is to be realised from this technology.
If that isn't enough, the last part of the book shows how to roll your own scripts for adding users, querying the Active Directory etc.. Or as I prefer to think of it, repetitive tasks that you don't really want to go near the gui for. I have this book down as having 585 pages of solid fact, no filler, all examples kept short and focussing on the point in question.
This is an example of how technical books should be written - lots of hard fact with unambigous examples in a well-written style. If you have to go near Windows 2000 & the Active Directory (and I suspect one or two people may be in this position) then buy this book.Active Directory: Designing, Deploying, and Running Active Directory, Fourth Edition Overview

Want to learn more information about Active Directory: Designing, Deploying, and Running Active Directory, Fourth Edition?

>> Click Here to See All Customer Reviews & Ratings Now
Read More...

WebSphere Application Server Administration Using Jython Review

WebSphere Application Server Administration Using Jython
Average Reviews:

(More customer reviews)
Are you looking to buy WebSphere Application Server Administration Using Jython? Here is the right place to find the great deals. we can offer discounts of up to 90% on WebSphere Application Server Administration Using Jython. Check out the link below:

>> Click Here to See Compare Prices and Get the Best Offers

WebSphere Application Server Administration Using Jython ReviewI was introduced to this book during a Jython class taught by Keven McGrath. He kept referring to the book in the classroom, and bringing up sample pages for examples. I was favorably impressed during the class, and even more so when the book finally arrived. They take a very important subset of Jython code for WebSphere and give concrete examples of how to configure and administer WebSphere through scripting.
This is not only an awsome resource for Jython programming, but having a fundamental knowledge of the contents has improved my understanding of many aspects of IBM WebSphere itself. Things that are not terribly clear in other books become very clear when working through the examples and reading explainations for why things work the way they do.
I would strongly recommend this for anybody who administers WebSphere, not just adminstrators trying to maintain it through scripting. My only complaint is that they've not announced a followup yet to cover some of the stuff they were forced due to time and space constraints to leave out. Given the nature of WebSphere, to cover everything in one book would be impossible.WebSphere Application Server Administration Using Jython OverviewSave Time and Money: Streamline WebSphere Application Server Management with Jython Scripting!Utilizing Jython scripting, you can dramatically reduce the effort, resources, and expense associated with managing WebSphere Application Server. WebSphere Application Server Administration Using Jython will show you how. The first start-to-finish guide to Jython scripting for WebSphere administration, this book's practical techniques and downloadable scripts can help you improve efficiency, repeatability, and automation in any WebSphere environment. This book's expert authors begin with practical introductions to both WebSphere Application Server administration and Jython, today's powerful, Java implementation of Python. Next, they cover a broad spectrum of WebSphere management tasks and techniques, presenting real, easy-to-adapt solutions for everything from server configuration and security to database management. These are powerful solutions you can begin using immediately–whether you're running WebSphere in production, development, or test environments.Coverage includesMastering the Jython rules, characteristics, and properties that are most valuable in WebSphere scripting

Want to learn more information about WebSphere Application Server Administration Using Jython?

>> Click Here to See All Customer Reviews & Ratings Now
Read More...

Beginning Lua Programming (Programmer to Programmer) Review

Beginning Lua Programming (Programmer to Programmer)
Average Reviews:

(More customer reviews)
Are you looking to buy Beginning Lua Programming (Programmer to Programmer)? Here is the right place to find the great deals. we can offer discounts of up to 90% on Beginning Lua Programming (Programmer to Programmer). Check out the link below:

>> Click Here to See Compare Prices and Get the Best Offers

Beginning Lua Programming (Programmer to Programmer) ReviewI'd like to give this book 4.5 stars, but that doesn't seem to be an option. I think quite highly of Lua and use it a lot. So I like to keep a collection of references that I can loan out to my colleagues and my students in a nut-so-subtle attempt to get them hooked. This book fulfills that role quite nicely.
I think this is an excellent book for several reasons: 1) I can loan it out both to intro students (who have not had much experience in compiling/installing software, coding anything other than toy programs, etc.) and I can loan it to colleagues who can skip all the fundamental material and yet still learn something interesting about Lua, and programming in general; 2) although it's close to 650 pages, it's 650ish pages of useful material, it doesn't achieve its bulk by being filled with gazillions of pages of on-line API documentation, and other fluff like many other intro books; 3) it has exercises (with answers in the back) for each chapter.
There are only two complaints I have with the book and neither are major. In Chapter 18 (Carrying Lua with you) there is no mention of the Lua port for PocketPC and a handful of other platforms. Although I don't use Windows much, there is a nice port of Lua that I use on an HP iPAQ. The other complaint is perhaps a little curmudgeonly: I don't like the authors' usage of the term "side-effect". While technically correct, it doesn't really align well with how most people, particularly in an intro setting, use the term.
That said, I think this is an excellent intro to Lua, contains good examples of programming in general, and I'm quite pleased to have a copy on my book collection.Beginning Lua Programming (Programmer to Programmer) OverviewThis book is for students and professionals who are intrigued by the prospect of learning and using a powerful language that provides a rich infrastructure for creating programs. No programming knowledge is necessary to benefit from this book except for the section on Lua bindings, which requires some familiarity with the C programming language. A certain comfort level with command-line operations, text editing, and directory structures is assumed.

Software developers who have experience with functions, strings, and associative arrays can skim Chapters 2 through 5 with the caveat that certain Lua colloquialisms are introduced there along with programming concepts.

Throughout the text, sections pertaining to a particular operating system are clearly marked and can be skipped by readers working on a different platform.

This book is organized to guide you through the basics of using Lua. Its structure is as follows:

Installing Lua on your system (Chapter 1)
Learning the fundamentals of programming in Lua (Chapters 2 through 10)
Reviewing standard Lua functions (Chapter 11)
Exploring application development with Lua using packages contributed by the community (Chapters 12 through 18)
Using Lua's many community resources (Chapter 19)

Chapters 2 through 10 each build on concepts that are presented in its predecessors, so a sequential reading of this part of the book is advised. The summary of Lua's built-in libraries contains examples that assume you have a good grasp of the materials presented in the first 10 chapters.

Some of the libraries and techniques presented in Chapters 12 and 13 are needed in the remaining chapters of the book. Chapters 14 through 19 are relatively independent of one another and can be read out of sequence.

You need surprisingly little in the way of computer resources to learn and use Lua. This book focuses on Windows and Unix-like (including Linux) systems, but any operating system that supports a command shell should be suitable. You'll need a text editor to prepare and save Lua scripts.

If you choose to extend Lua with libraries written in a programming language like C, you'll need a suitable software development kit. Many of these kits are freely available on the Internet but, unlike Lua, they can consume prodigious amounts of disk space and memory.

Chapter 18 discusses using Lua on a Palm Pilot. Even if you don't own or have access to one of these devices, this chapter shows how you can simulate one on the major desktop systems.


Want to learn more information about Beginning Lua Programming (Programmer to Programmer)?

>> Click Here to See All Customer Reviews & Ratings Now
Read More...

Beginning Groovy and Grails: From Novice to Professional Review

Beginning Groovy and Grails: From Novice to Professional
Average Reviews:

(More customer reviews)
Are you looking to buy Beginning Groovy and Grails: From Novice to Professional? Here is the right place to find the great deals. we can offer discounts of up to 90% on Beginning Groovy and Grails: From Novice to Professional. Check out the link below:

>> Click Here to See Compare Prices and Get the Best Offers

Beginning Groovy and Grails: From Novice to Professional ReviewLet me start by saying "Beginning Groovy and Grails" is the book that the Grails community has been clamoring for. Two very good books kicked off the Grails revolution ("Definitive Guide to Grails" and "Getting Started with Grails"), but both predate the 1.x version of Grails by many dot-versions and many years (as of the time of this review, August 2008). BGG will certainly have worthy competition on the bookshelf before long, but right now it is the book that we all have been waiting for. Luckily, it easily lives up to the heightened expectations.
After reading BGG cover to cover, it seems to break naturally into three sections: Core Groovy, Core Grails, and Ancillary Grails. This division is mine, not the authors; the table of contents lists 13 chapters with no explicit section breaks. (Whether the three sections correspond to the three authors is an interesting question -- the tone of voice and writing style is consistent across the entire book.)
The first three chapters do an admirable job of covering the Groovy language from the basics to advanced topics. Groovy offers lots of syntactic sugar that might initially catch a Java programmer off-guard. These features, once you've seen them, dramatically reduce the lines of code you have to write. But more than that, there are some fundamentally new features in Groovy that don't have an easy match in Java. Builders, Expandos, metaprogramming, and DSLs are all discussed in these early chapters. While you don't have to use these features yourself to be successful in Grails, it certainly helps the reader understand how much of the Grails "magic" occurs under the covers.
The next three chapters (Introduction to Grails, Building the User Interface, and Building Domains and Services) hit the Core Grails features hard. These 150 pages do a great job of walking you through the basics of getting a Grails application up and running with a minimum of effort. They also make testing feel like a natural part of the development process (which it should be!). Rather than having a single chapter dedicated to testing, each new topic organically includes testing as a way to validate that the new code does what it promises to do.
The remaining chapters (Security, Ajax, REST, Reporting, Batch Processing, Deploying, and Alternative Clients) make up close to half the book. Each chapter covers the subject material as advertised, including working sample code. Not every Grails application will use every feature discussed here, but I still found a clever snippet of code here or a nice explanation of a general concept that rewarded me for reading every chapter.
Overall, "Beginning Groovy and Grails" delivers on its title -- if you are new to either (or both) technologies, you will be up and running before you know it. But don't be fooled by the title; even though it has "Beginning" in it, this book doesn't shy away from the advanced topics, either. This isn't a completist volume. Rather, it is a broad survey of the Groovy and Grails ecosystem. Christopher, Joseph, and Jim covered a lot of ground in an easy, readable way. I highly recommend it.Beginning Groovy and Grails: From Novice to Professional OverviewThe Rails web framework has taken the software industry by storm, offering legions of web developers the ability to create web sites faster and more efficiently than ever before. But taking advantage of Rails means learning an entirely new paradigm, in addition to the language Rails is built upon: Ruby. Accordingly, other developer communities have implemented their own versions of Rails, but built using their preferred language. For millions of Java developers, this native framework is Grails, and the Java-centric scripting language its built upon: Groovy.Beginning Groovy and Grails introduces Java developers to this popular framework and scripting language by guiding readers through the creation of a series of real-world projects. Each project introduces a new facet of Grails and Groovy, and affords readers the ability to download and experiment with the code. Authored by industry veterans Christopher Judd, Joseph Faisal Nusairat, and Jim Shingler, readers are treated not only to profound knowledge of the topic, but also to considerable insight shared as a result of the authors' combined decades of Java experience.See the following resources for more information on Grails and Groovy:Grails project website: http://grails.codehaus.org/Groovy project web site: http://groovy.codehaus.org/

Want to learn more information about Beginning Groovy and Grails: From Novice to Professional?

>> Click Here to See All Customer Reviews & Ratings Now
Read More...

Professional JavaScript for Web Developers (Wrox Professional Guides) Review

Professional JavaScript for Web Developers (Wrox Professional Guides)
Average Reviews:

(More customer reviews)
Are you looking to buy Professional JavaScript for Web Developers (Wrox Professional Guides)? Here is the right place to find the great deals. we can offer discounts of up to 90% on Professional JavaScript for Web Developers (Wrox Professional Guides). Check out the link below:

>> Click Here to See Compare Prices and Get the Best Offers

Professional JavaScript for Web Developers (Wrox Professional Guides) ReviewThe key to knowing about this book is the word "Professional" in the title. There are other books aimed at the complete beginner that will start off with a much simpler "Here's How" approach to get you started. This book instead starts off with the history, the basic ECMAScript standards and a discussion on the Object nature of JavaScript. It's written by a working programmer to fill the real world needs of other working programmers. It does this job very well.
Further, the book is new and up to date. JavaScript is an evolving language as the web grows to demand increasing capabilities. Some of these features that now get full chapters in this book include: XML, Client-Server communications, Web Services, interacting with Plug-Ins.
The last chapter talks about the next step in the development of JavaScript, with cautions that this material is still preliminary and subject to change.
Excellent book for the intermediate to advanced JavaScript programmer.Professional JavaScript for Web Developers (Wrox Professional Guides) Overview
Dispels the myth that JavaScript is a "baby" language and demonstrates why it is the scripting language of choice used in the design of millions of Web pages and server-side applications
Quickly covers JavaScript basics and then moves on to more advanced topics such as object-oriented programming, XML, Web services, and remote scripting
Addresses the many issues that Web application developers face, including internationalization, security, privacy, optimization, intellectual property issues, and obfuscation
Builds on the reader's basic understanding of HTML, CSS, and the Web in general

This book is also available as part of the 4-book JavaScript and Ajax Wrox Box (ISBN: 0470227818). This 4-book set includes:
Professional JavaScript for Web Developers (ISBN: 0764579088)
Professional Ajax 2nd edition (ISBN: 0470109491)
Professional Web 2.0 Programming (ISBN: 0470087889)
Professional Rich Internet Applications: Ajax and Beyond (ISBN: 0470082801)


Want to learn more information about Professional JavaScript for Web Developers (Wrox Professional Guides)?

>> Click Here to See All Customer Reviews & Ratings Now
Read More...