jerrylees2006的博客

Real-time web applications have traditionally been a challenging thing to achieve, relying on hacks and illusions. Many people avoid going real-time under the assumption of the complexity involved. This book will show you how to build modern, real-time web applications powered by Socket.IO, introducing you to various features of Socket.IO and walking you through the development, hosting, and scaling of a chat server.

This book covers all the important aspects of developing Hibernate OGM-MongoDB applications. It provides clear instructions for getting the most out of the Hibernate OGM-MongoDB duo and offers many examples of integrating Hibernate OGM by means of both the Hibernate Native API and the Java Persistence API. You will learn how to develop desktop, web, and enterprise applications for the most popular web and enterprise servers, such as Tomcat, JBoss AS, and Glassfish AS. You’ll see how to take advantage of Hibernate OGM-MongoDB together with many common technologies, such as JSF, Spring, Seam, EJB, and more. Finally, you’ll learn how to migrate to the cloud—MongoHQ, MongoLab, and OpenShift.

Unit testing is when you (a programmer) write test code to verify units of code. The size of a unit isn’t precisely defined, so we’ll view a unit as a small bit of code that exhibits some useful behavior in your system. A unit on its own usually doesn’t represent complete end-to-end behavior. It instead represents some small subset of that end-to-end-behavior. We’re coding in Java, so we write our unit tests in Java, too. We run these unit tests through JUnit, a tool that marks our tests as passing or failing.

There are already a few really good books devoted to developers’ tests in bookstores, so why write another one? Here are several reasons for doing so: The world keeps on moving forward. Progress never stops. There are still ideas emerging in the testing area. New frameworks. New approaches. New tools. Old techniques are being forgotten, rediscovered and mixed with newly invented ones. New concepts force us to rethink existing paradigms and come up with solutions that are better suited to the constantly changing IT environment. Lack of knowledge. In spite of all the books, seminars, JUG meetings, conferences, podcasts, articles, blog entries and forum discussions I deal with, I still meet many developers who have only a very vague idea of what developers’ testing is and how to do it. There is definitely still room for improvement in this area.

This is the second edition of the highly rated book Object-Oriented JavaScript by Stoyan Stefanov, Packt Publishing. After the release of the first edition, in the last five years, JavaScript has moved from being mostly used in browsers for client-side technologies to being used even on server side. This edition explores the "language side" of JavaScript. The stress is on the standards part of the language. The book talks about ECMA Script, Object-Oriented JS, patterns, prototypal inheritance, and design patterns. The book doesn't assume any prior knowledge of JavaScript and works from the ground up to give you a thorough understanding of the language. People who know the language will still find it useful and informative. Exercises at the end of the chapters help you assess your understanding.

When Node.js arrived in 2009, we knew something was different. JavaScript on the server wasn’t anything new. In fact, server-side JavaScript has existed almost as long as clientside JavaScript. With Node, the speed of the JavaScript runtimes, coupled with the eventbased parallelism that many JavaScript programmers were already familiar with, were indeed compelling. And not just for client-side JavaScript developers, which was our background—Node attracted developers from the systems level to various server-side backgrounds, PHP to Ruby to Java. We all found ourselves inside this movement. At that time, Node was changing a lot, but we stuck with it and learned a whole lot in the process. From the start, Node focused on making a small, low-level core library that would provide enough functionality for a large, diverse user space to grow. Thankfully, this large and diverse user space exists today because of these design decisions early on. Node is a lot more stable now and used in production for numerous startups as well as established enterprises. When Manning approached us about writing an intermediate-level book on Node, we looked at the lessons we had learned as well as common pitfalls and struggles we saw in the Node community. Although we loved the huge number of truly excellent third-party modules available to developers, we noticed many developers were getting less and less education on the core foundations of Node. So we set out to write Node in Practice to journey into the roots and foundations of Node in a deep and thorough manner, as well as tackle many issues we personally have faced and have seen others wrestle with.

In Chapter 1 we provide background about MongoDB: why it was created, the goals it is trying to accomplish, and why you might choose to use it for a project. We go into more detail in Chapter 2, which provides an introduction to the core concepts and vocabulary of MongoDB. Chapter 2 also provides a first look at working with MongoDB, getting you started with the database and the shell. The next two chapters cover the basic material that developers need to know to work with MongoDB. In Chapter 3, we describe how to perform those basic write operations, including how to do them with different levels of safety and speed. Chapter 4 explains how to find documents and create complex queries. This chapter also covers how to iterate through results and gives options for limiting, skipping, and sorting results.

This book endeavors to provide you with as much up-to-date information as possible regarding jQuery that can be reasonably included in a book consisting of roughly 200 pages. You need some familiarity with HTML Web pages and JavaScript, but no prior knowledge of jQuery is required.

程序员测试并不是对程序员进行测试，而是有关程序员所进行的测试工作。近几年，一些编程人 员发现如果自己去编写测试程序会带来很多好处，这种好处是以前“让测试部门来管”所 没有的。修 正错误非常困难，主要是因为花时间太多：不仅测试人员需要花很多时间来发现错误，并且要给程 序人员提供足够的信息来重现这个错误；编程人员也要 花费很多时间，从几个月前看过的代码中找 到错误产生的原因。还有很多时间花在讨论这些究竟是不是一个错误，弄清楚为什么程序员会犯如此 幼稚的错误，是不是 测试人员干扰了他们的工作？是不是需要让测试人员远离程序员而不去打扰他 们等等。如果程序员自己测试他们自己的代码，那么就可以节省很多时间。

This book is suitable for beginner to intermediate level web designers and developers. Experience of HTML and CSS is assumed, and some knowledge of JavaScript is helpful.

JavaScript is the language of the Web. It started as a way to manipulate a few selected types of elements in a web page (such as images and form fields), but it has grown tremendously. In addition to client-side browser scripting, these days you can use JavaScript to program for an increasing variety of platforms. You can write server-side code (using .NET or Node.js), desktop applications (that work on all operating systems) and application extensions (e.g., for Firefox or Photoshop), mobile applications, and command-line scripts. JavaScript is also an unusual language. It doesn’t have classes, and functions are firstclass objects used for many tasks. Initially the language was considered deficient by many developers, but in more recent years these sentiments have changed. Interestingly, languages such as Java and PHP started adding features such as closures and anonymous functions, which JavaScript developers have been enjoying and taking for granted for a while. JavaScript is dynamic enough that you can make it look and feel like another language you’re already comfortable with. But the better approach is to embrace its differences and study its specific patterns.

After the platform began to get faster, and developers learned some of the tricks of writing faster applications, Java transformed into the enterprise-grade software powerhouse it is today. It began to be used for the largest, most important systems anywhere. However, as this started to happen, people began to realize one part was still missing. This missing piece was observability. When these systems get larger and larger, how do you know if you’re getting all the performance you can get? In the early days of Java we had primitive profiling tools. While these were useful, they had a huge impact on the runtime performance of the code. Now, modern JVMs come with built-in observability tools that allow you to understand key elements of your system’s performance with almost no performance penalty. This means these tools can be left enabled all the time, and you can check on aspects of your application while it’s running. This again changes the way people can approach performance.

A “lambda expression” is a block of code that you can pass around so it can be executed later, once or multiple times. Before getting into the syntax (or even the curious name), let’s step back and see where you have used similar code blocks in Java all along.

In the computer world, when we talk about concurrency, we talk about a series of tasks that run simultaneously in a computer. This simultaneity can be real if the computer has more than one processor or a multi-core processor, or apparent if the computer has only one core processor

We are currently facing an avalanche of data, and this data contains many insights that hold the keys to success or failure in the data-driven world. Next generation Hadoop (v2) offers a cutting-edge platform to store and analyze these massive data sets and improve upon the widely used and highly successful Hadoop MapReduce v1. The recipes that will help you analyze large and complex datasets with next generation Hadoop MapReduce will provide you with the skills and knowledge needed to process large and complex datasets using the next generation Hadoop ecosystem.

Functional programming is a style that emphasizes and enables the writing of smarter code, which minimizes complexity and increases modularity. It’s a way of writing cleaner code through clever ways of mutating, combining, and using functions. JavaScript provides an excellent medium for this approach. JavaScript, the Internet’s scripting language, is actually a functional language at heart. By learning how to expose its true identity as a functional language, we can implement web applications that are powerful, easier to maintain, and more reliable. By doing this, JavaScript’s odd quirks and pitfalls will suddenly become clear and the language as a whole will make infinitely more sense. Learning how to use functional programming will make you a better programmer for life.

Domain-specific languages have been a part of the computing landscape since before I got into programming. Ask an old Unix-hand or Lisp-hand and they'll happily bore you to tears on how DSLs have been a useful part of their bag of tricks. Despite this, they've never become a very visible part of the computing landscape. Most people learn about DSLs from someone else, and they often learn only a limited set of available techniques.

Long gone are the days of the mobile apps with a static UI squished onto a tiny screen. Today's users expect mobile apps to be dynamic and highly interactive. They expect an app to look fantastic when they're looking at it on their medium-resolution smartphone, and that same app needs to look just as fantastic when they switch over to using it on their high-resolution tablet. Apps need to provide rich navigation features. Also, apps need to be adaptive and responsive. Trying to meet these demands using Android's traditional activity-centric UI design model is difficult. As developers, we need more control than that afforded by activities. We need a new approach: fragments give us that new approach. In this book, you'll learn how to use fragments to meet the challenges of creating dynamic UIs in the modern world of mobile app development.

Many titles include programming code or configuration examples. To optimize the presentation of these elements, view the eBook in single-column, landscape mode and adjust the font size to the smallest setting. In addition to presenting code and configurations in the reflowable text format, we have included images of the code that mimic the presentation found in the print book; therefore, where the reflowable format may compromise the presentation of the code listing, you will see a “Click here to view code image” link. Click the link to view the print-fidelity code image. To return to the previous page viewed, click the Back button on your device or app.

Welcome to Java. This chapter launches you on a tour of this technology by focusing on fundamentals. First, you receive an answer to the “What is Java?” question. If you have not previously encountered Java, the answer might surprise you. Next, you are introduced to some basic tools that will help you start developing Java programs, and to the NetBeans integrated development environment, which simplifies the development of these programs. Finally, you explore fundamental language features.

This work is subject to copyright. All rights are reserved by the Publisher, whether the whole or part of the material is concerned, specifically the rights of translation, reprinting, reuse of illustrations, recitation, broadcasting, reproduction on microfilms or in any other physical way, and transmission or information storage and retrieval, electronic adaptation, computer software, or by similar or dissimilar methodology now known or hereafter developed. Exempted from this legal reservation are brief excerpts in connection with reviews or scholarly analysis or material supplied specifically for the purpose of being entered and executed on a computer system, for exclusive use by the purchaser of the work. Duplication of this publication or parts thereof is permitted only under the provisions of the Copyright Law of the Publisher’s location, in its current version, and permission for use must always be obtained from Springer. Permissions for use may be obtained through RightsLink at the Copyright Clearance Center. Violations are liable to prosecution under the respective Copyright Law.

当面向对象编程（OO）首次出现时，它是一种启示。OO使开发人员能够创建更灵活、更健壮的软件。但随着时间的推移，应用程序变得更复杂，人们发现“传统的”OO体系结构在某些领域不能胜任。面向方面编程（AOP）通过进一步扩展OO方法，解决了这些问题。 许多开发人员都对AOP感兴趣 —— 特别是对AspectJ感兴趣，这个Java编程语言的开源扩展明确支持AOP方法。然而，尽管AspectJ纳入在Eclipse这个日益流行的Java开源IDE之内，但是找到一种实用、非理论的方式来学习这种语言及其他AOP工具和技术已经成为一个实际的问题。 迄今为止，本书提供了实用的解决方案以及大量的代码和秘诀，便于使用AOP的独特方法来解决日常设计和编程问题。本书包括以下内容： ● 初识AOP ● 集成AspectJ与Eclipse、Ant和Java命令行工具 ● 将面向方面的应用程序部署为servlet、JSP、Web服务等 ● 关于方面、切入点、通知以及核心AOP构造的每个方面的秘诀 ● 在Java和J2EE设计模式实现中使用方面 ● 使用AOP特有的设计模式，增强现有的Java应用程序 本书展示了为什么以及如何使用AOP技术来解决常见的Java开发问题。本书利用受欢迎的问题/解决方案/讨论格式，介绍了许多现实的示例，不仅仅从概念角度演示AOP；它是一个开发过程，让用户以一种即时、可见的方式受益。如果想了解AOP如何改变软件开发的方式，如何使用AspectJ使代码更加模块化，更易于开发、维护、演进和部署，那么本书确实很适合你

Spring in Practice is a practice-oriented book. The first three chapters are background, but are still quite substantial, and we expect most readers will find some new information in them. Chapter 2 and the final 11 chapters use a cookbook format to tackle a given problem with incremental recipe-by-recipe, or technique-by-technique, solutions. There are 66 techniques covered in this book.

I have fond memories of Wrox books. The Spring story started 12 years ago from a Wrox book. Before that, I’d contributed chapters to several Wrox books and served as a reviewer on many others. Some of these memories concern what the imprint has meant to me, but many relate to its philosophy and format, a key reason I was excited to become a Wrox author in 2000. The distinctive format offers an effective structure for imparting knowledge, encouraging the author to highlight important points, and promoting systematic explanation. It emphasizes practical code examples— the most valuable tool for teaching programming. These virtues are evident in Mert Çalıskan’s and Kenan Sevindik’s Beginning Spring. It’s well structured, with plentiful examples that include clear instructions on getting the code running and stepby‐ step explanations.

When we think of the community of Java developers, we are reminded of the hordes of gold rush prospectors of the late 1840s, frantically panning the rivers of North America, looking for fragments of gold. As Java developers, our rivers run rife with open source projects, but, like the prospectors, finding a useful project can be time-consuming and arduous. A common gripe with many open source Java projects is that they are conceived merely out of the need to fill the gap in the implementation of the latest buzzword-heavy technology or pattern. Having said that, many high-quality, usable projects meet and address a real need for real applications, and in the course of this book, you will meet a subset of these projects. You will get to know one in particular rather well—Spring. Throughout this book, you will see many applications of different open source technologies, all of which are unified under the Spring Framework. When working with Spring, an application developer can use a large variety of open source tools, without needing to write reams of code and without coupling his application too closely to any particular tool.

This book is about HTML5 Programming. Before you can understand HTML5 programming, however, you need to take a step back and understand what HTML5 is, a bit of the history behind it, and the differences between HTML 4 and HTML5. In this chapter, we get right to the practical questions to which everyone wants answers. Why HTML5, and why all the excitement just now? What are the new design principles that make HTML5 truly revolutionary—but also highly accommodating? What are the implications of a plugin-free paradigm; what’s in and what’s out? What’s new in HTML, and how does this kick off a whole new era for web developers? Let’s get to it.

Working for several years across several industries on various RAC projects, there have been several occasions to troubleshoot performance issues in a production environment.

This mini book is a collection of four chapters pulled from Android Application Development for the Intel Platform, designed to give developers an introduction to creating great user interfaces for their Android applications. These chapters cover topics ranging from the differences between developing UIs for desktop systems and embedded systems to optimizing the UI of applications for touchscreens.

The Java programming language was introduced in 1995 by Sun Microsystems Derived from languages such as C and C++ Java was designed to be more intuitive and easier to use than older languages specifically due to its simplistic object model and automated facilities such as memory management At the time Java drew the interest of developers because of its object oriented concurrent architecture; its excellent security and scalability; and because applications developed in the Java language could run on any operating system that contained a Java Virtual Machine JVM Since its inception Java has been described as a language that allows developers to “write once run everywhere” as code is compiled into class files that contain bytecode and the resulting class files can run on any compliant JVM This concept made Java an immediate success for desktop development which later branched off into different technological solutions over the years including development of web based applications and rich Internet applications RIAs Today Java is deployed on a broad range of devices including mobile phones printers medical devices Blu ray players and so on ">The Java programming language was introduced in 1995 by Sun Microsystems Derived from languages such as C and C++ Java was designed to be more intuitive and easier to use than older languages specifically due to its simplistic object model and automated facilities such as memory management At th [更多]

jQuery is a multi-browser, lightweight, and extensible open source JavaScript library that can be used to simplify client-side and client-to-server communication scripting. It simplifies coding by replacing many lines of JavaScript code with fewer lines by using jQuery built-in methods. Some of the main features of jQuery include: • Dynamic HTML creation and manipulation • HTML events handling • Effects and animations • Client to server communication

Axure has rapidly become one of the leading tools for rapid prototyping in use today. There are many reasons for Axure's popularity. You can easily create wireframes as well as generate specification documentation. Axure also provides the ability to quickly develop prototypes that can be leveraged in web browsers or as native Android, iPhone, or iPad applications. It is no wonder that Axure has become the tool of choice for a large percentage of the Fortune 100 corporations as well as User Experience professionals worldwide.

Mobile app and responsive web design are some of the most important topics in software development today. One of the key aspects of high-quality user experience design is prototyping, as a means to test our ideas and see where they work and where they don't. In this book we look at one of the latest prototyping tools, Axure RP 7. This book is not meant to be an exhaustive look at the many features in Axure 7, but rather is intended to introduce experienced Axure users to some of the mobile prototyping features in the latest version of this widely-used tool.

Axure RP 7 was one of the most significant product releases we've had to date. It reminded me a lot of Version 2, which was released in late 2003. In Version 2, we switched from an HTML-based editor to a diagram editor and laid the foundation for prototype generation. We were able to build upon Version 2 for the following 10 years to add milestones such as the dynamic panel, conditional logic, and shared projects. In Axure RP 7, we completely rearchitected the generated HTML with an eye towards the next 10 years of software and user experience design.

Book Description Cloud Computing Basics covers the main aspects of this fast moving technology so that both practitioners and students will be able to understand cloud computing.

Book Description There is an ongoing data explosion transpiring that will make previous creations, collections, and storage of data look trivial. Big Data, Mining, and Analytics: Components of Strategic Decision Making ties together big data, data mining, and analytics to explain how readers can leverage them to extract valuable insights from their data. Facilitating a clear understanding of big data, it supplies authoritative insights from expert contributors into leveraging data resources, including big data, to improve decision making.

Book Description Go ahead, be skeptical about big data. The author was—at first. When the term “big data” first came on the scene, bestselling author Tom Davenport (Competing on Analytics, Analytics at Work) thought it was just another example of technology hype. But his research in the years that followed changed his mind. Now, in clear, conversational language, Davenport explains what big data means—and why everyone in business needs to know about it. Big Data at Work covers all the bases: what big data means from a technical, consumer, and management perspective; what its opportunities and costs are; where it can have real business impact; and which aspects of this hot topic have been oversold.

Book Description In practice, the design and architecture of a cloud varies among cloud providers. We present a generic evaluation framework for the performance, availability and reliability characteristics of various cloud platforms. We describe a generic benchmark architecture for cloud databases, specifically NoSQL database as a service. It measures the performance of replication delay and monetary cost.

Book Description This book examines the present and future of soft computer techniques. It explains how to use the latest technological tools, such as multicore processors and graphics processing units, to implement highly efficient intelligent system methods using a general purpose computer.

《移动应用UI设计模式》是一本移动应用UI设计模式参考书，分10大类介绍了70个移动应用设计模式(包括反模式)，用400多个屏幕截图和图解帮助读者理解和利用UI设计模式，以解决常见的设计难题，同时提供了“即学即用”式的技巧和经验。　　《移动应用UI设计模式》适合移动应用开发人员、UI设计师阅读。

Book Description C# Deconstructed answers a seemingly simply question: Just what is going on, exactly, when you run C# code on the .NET Framework? To answer this question we will dig ever deeper into the structure of the C# language and the onion-skin abstraction layers of the .NET Framework that underpins it. We’ll follow the execution thread downwards, first to MSIL (Microsoft Intermediate Language) then down through just-in-time compilation into Machine Code before finally seeing the results executed at the hardware level.