This text is an introduction to Simulink ®, a companion application to MATLAB ®. It is written for students at the undergraduate and graduate programs, as well as for the working professional.

The author claims no originality of the content, and the description of the Simulink blocks is extracted from The MathWorks™ documentation without intent to infringe. The intent is to provide a complete reference text, and whenever necessary, the author refers the reader to The MathWorks™ documentation. Whenever there is a conflict between this text and The MathWorks™ documentation, the latter takes precedence.

Although some previous knowledge of MATLAB would be helpful, it is not absolutely necessary; Appendix A of this text is an introduction to MATLAB to enable the reader to begin learning both MATLAB and Simulink simultaneously, and to perform graphical computations and programming.

Chapters 2 through 19 describe the blocks in all Simulink Version 7.1 libraries. Their application is illustrated with Simulink models that contain the pertinent blocks, and some are supplemented with MATLAB functions, commands, and statements. Some background information is provided for lesser known definitions and topics. Chapters 1 and 20 contain several Simulink models to illustrate various applied math and engineering applications. Appendix B is an introduction to masked subsystems, and Appendix C introduces the reader to random generation procedures. Appendix D is an introduction to Weighted Moving Averages.

This text supplements our Numerical Analysis Using MATLAB and Excel, ISBN 978−1−934404−03−4. It is self-contained; the blocks of each library are described in an orderly fashion that is consistent with Simulink’s documentation. This arrangement provides insight into how a model is used and how its parts interact with each another.

Like MATLAB, Simulink can be used with both linear and nonlinear systems, which can be modeled in continuous time, sample time, or a hybrid of these. Examples are provided in this text. Most of the examples presented in this book can be implemented with the Student Versions of MATLAB and Simulink. A few may require the full versions of these outstanding packages, and these examples may be skipped. Some add−ons, known as Toolboxes and Blocksets can be obtained from The MathWorks,™ Inc., 3 Apple Hill Drive, Natick, MA, 01760-2098, USA, www.mathworks.com.

To get the most out of this outstanding application, it is highly recommended that this text is used in conjunction with the MATLAB and Simulink User’s Guides. Other references are provided in the reference section of this text.

The development of clinical computing systems is a rapidly growing priority area of health information technology, spurred in large measure by robust funding at the federal and state levels. It is widely recognized as one of the key components for reducing costs and improving the quality of care. At the same time as more and more hospitals and clinics are installing clinical computing systems, major issues related to design, operations, and infrastructure remain to be resolved. This book tackles these critical topics, including system selection, configuration, installation, user support, interface engines, and long-term operation. It also familiarizes the reader with regulatory requirements, budgetary issues, and other aspects of this new electronic age of healthcare delivery.

It begins with an introduction to clinical computing and definition of key terminology. The next several chapters talk about system architecture and interface design, followed by detailed discussion of all aspects of operations. Attention is then given to the realities of leadership, planning, oversight, budgeting, and employee recruitment. This invaluable resource includes a special section that talks about career development for students and others interested in entering the field.

*Provides a complete overview of practical aspects
*Detailed guidance on the design and operation of clinical computing systems
*Discusses how clinical computing systems relate to health care organization committees and organizational structure
*Includes numerous real-life examples with expert insights on how to avoid pitfalls

The awareness of the ideas characterized by Communicating Processes Architecture and their adoption by industry beyond their traditional base in safety-critical systems and security is growing. The complexity of modern computing systems has become so great that no one person – maybe not even a small team – can understand all aspects and all interactions. The only hope of making such systems work is to ensure that all components are correct by design and that the components can be combined to achieve scalability. A crucial property is that the cost of making a change to a system depends linearly on the size of that change – not on the size of the system being changed. Of course, this must be true whether that change is a matter of maintenance (e.g. to take advantage of upcoming multiprocessor hardware) or the addition of new functionality. One key is that system composition (and disassembly) introduces no surprises. A component must behave consistently, no matter the context in which it is used – which means that component interfaces must be explicit, published and free from hidden side-effect. This publication offers strongly refereed high-quality papers covering many differing aspects: system design and implementation (for both hardware and software), tools (concurrent programming languages, libraries and run-time kernels), formal methods and applications.

Get the definitive guide on all the fundamentals of Terracotta as well as user secrets, recipes, and prepackaged frameworks.

Written by Terracotta CTO Ari Zilka and his team, The Definitive Guide to Terracotta: Cluster the JVM for Spring, Hibernate and POJO Scalability covers the following:

• High Availability (HA) nth degree scaling and clustering for traditional J2EE and Java EE 5 applications (using Seam or other application) as well as Spring–based enterprise applications
• Everyday Terracotta using its prepackaged frameworks and integration recipes, including configuration and customization for your application tuning, no matter the scale
• Power user secrets available, including config modules, customized advanced performance tuning, SDLC, Maven, and more

What you’ll learn

• See how Terracotta works fundamentally, and the user pieces and parts necessary for using Terracotta and its open source options.
• Learn and apply case studies involving distributed cache, Hibernate, Master/Worker, and HTTP Session.
• Understand thread coordination and advanced performance tuning.
• Use more advanced case studies involving Spring, POJOs, FOO, and more.
• Configure and create your own modules using the software development and deployment life cycle.

Who is this book for?

This definitive book from the Terracotta team is for both developers and architects who want to learn the “whats, wheres, whens, and whys” of the Terracotta scaling engine.

About the Author

Terracotta, Inc. delivers plug–in capacity and availability for Java applications at runtime with no application code changes. Terracotta simplifies development, deployment, testing, and management by moving clustering and caching services to the JVM instead of the application. With Terracotta, Java applications are highly available, have linear scale, and improved performance. Terracotta customers include industry leaders in the financial services and telecom sectors. Founded in 2003, Terracotta is a private firm headquartered in San Francisco.

One might think that the software industry is performing very well because it is armed with object-oriented approaches, Web services, Java and .NET technologies, and so forth. Unfortunately, this is not true.

There may be something wrong with the way we write programs. The process has not changed much during the past twenty years, except that applications and tools are getting bigger. Yet are they better and more scalable? Do they require any common sense? Can they be reused in different circumstances?

If these things were true, I do not think we would be rewriting the address book, schedule, order, and inventory applications over and over again instead of moving to new, untouched tasks. We would be able to accumulate the professional knowledge gained by millions of knowledge workers (everyone who manages information flow on a daily basis) instead of routinely losing it, as we do today. We would also not be facing the current IT crisis.

We could even have had more precise and direct access to the market’s supply and demand, which would have reduced the glaring inefficiencies of the software marketplace of the 1990s. A big change is required to return investors’ confidence to IT, and, hopefully, the change is coming.

Yes, technology can help economic stability if applied with precision. Sometimes I wonder why big companies are constantly growing bigger while small ones tend to disappear. Why do corporations prefer doing business with a few vendors, or often a single vendor, even when it is an expensive one? One of the reasons is that the integration of multiple vendors’ products would be even more expensive.

Build a django content management system, blog, and social networking site with James Bennett as he introduces the popular Django framework. You’ll work through the development of each project, implementing and running the applications while learning new features along the way.

Web frameworks are playing a major role in the creation of today’s most compelling web applications, because they automate many of the tedious tasks, allowing developers to instead focus on providing users with creative and powerful features. Python developers have been particularly fortunate in this area, having been able to take advantage of Django, a very popular open source web framework whose stated goal is to “make it easier to build better web applications more quickly with less code.”

Practical Django Projects is the first book to introduce this popular framework by way of a series of real–world projects.

What you’ll learn

• Capitalize upon Django’s well–defined framework architecture to build web applications faster than ever before.
• Learn by doing by working through the creation of three real–world projects, including a content management system, blog, and social networking site.
• Build user–friendly web sites with well–structured URLs, session tracking, and syndication options.
• Let Django handle tedious tasks such as database interaction while you focus on building compelling applications.

Who is this book for?

Web developers seeking to use the powerful Django framework to build powerful web sites.

Related Titles

• The Definitive Guide to Django: Web Development Done Right
• Beginning Python: From Novice to Professional

About the Author

James Bennett is a web developer for the World Company of Lawrence, Kansas, and is a major contributor to the Django project. His current role within the Django community is as the software project’s release manager.

This comprehensive resource offers professionals detailed guidance on the engineering aspects of building software for wireless communications. From design and architecture to security and testing, the book shows how to overcome every engineering challenge encountered in successfully developing wireless software. Filled with open-source code examples, this handy reference provides practical, ready solutions for building software applications that make wireless networks work. It covers such hot applications as wireless information systems, wireless advertising and marketing, wireless payment systems, location-based portals, and mobile trading and sales systems. The book also explains how to integrate these applications into wireless LANs, personal wireless networks, and 3G and 4G wireless networks. Written for software developers and architects at all levels, this volume includes hands-on tutorials that take readers through each phase of wireless software development and implementation.

About the Author

Jerry Zeyu Gao is an associate professor of the department of computer engineering at San Jose State University. He has published two other software engineering books, including Testing and Quality Assurance for Component-Based Software (Artech House, 2003), and 55 technical papers in IEEE/ACM journals, magazines, and international conferences. He is the co-chair for the First and Second IEEE International Workshops on Mobile Commerce and Services. He received his M.S. and Ph.D. in computer science from the University of Texas at Arlington

Simon S.Y. Shim is an associate professor of the department of computer engineering at San Jose State University. He has published more than 40 technical papers in IEEE/ACM journals, magazines, and international conferences. He co-chaired IEEE International Workshops on Mobile Commerce and Services.

Xiao Su is an assistant professor in the Computer Engineering Department, San Jose State University. She received her B.E. in computer science and engineering from Zhejiang University in China, and her M.S. and Ph.D. in computer science from the University of Illinois at Urbana-Champaign. She has published over 20 articles in IEEE and ACM sponsored journals and conferences. She has served as publication chair, publicity chair, and technical program committee member for several well-respected international conferences.

Hsing Mei is an associate professor in the department of computer science and information engineering at Fu Jen Catholic University, Taiwan. He is also a visiting professor at Inter-University Institute of Macau. His research interest includes web computing, mobile wireless software, and distributed systems. He received his M.S. and Ph.D. in computer science and engineering from the University of Texas at Arlington.

The year 2005 was a traumatic year for the Java web application development community. It was under fire for the unnecessary “fat” architecture of Java Platform, Enterprise Edition (Java EE) systems compared to the new kids on the block like Ruby on Rails and Django. The search began for Java’s answer to these frameworks. I had an existing product that was heavily invested in Java frameworks such as Spring and Hibernate, but because I had been involved with the Groovy team for a while, I knew we could create the solution that people were looking for. Hence, Grails was born.

I knew Groovy itself was a phenomenal piece of technology that combined the best of the dynamic language worlds and Java. Innovation has been rife within the Groovy community since the early days with its builder concept. It had inspired other languages, and more recent languages such as ActionScript 3 and ECMAScript 4 had adopted its support for mixed typing. Groovy had proven to me that you can mix a dynamically typed language like Groovy with a statically typed language like Java in the same code base and get the best of both worlds without incurring the cost of context switching.

In addition, I knew that the Java community has invested years in building the largest amount of open source software in the world. Thousands of libraries exist for Java, built by years of best practice. Reinventing the wheel seemed like a crazy idea. Building Grails on top of existing technologies like Spring and Hibernate has proven to be one of the best decisions we have made. For me, Grails is the natural next step for Java EE developers. If Spring and Hibernate provided an abstraction over Java EE and simplified development, then Grails is an abstraction over Spring, Hibernate, and Java EE that can take you, the developer, to the next level.

Through the use of domain-specific languages and higher-level abstractions, Grails dramatically simplifies web development on the Java platform. By bundling a container and a database, we eliminated all barriers, and by supporting hot reloading during development, agile development became a reality. However, even with all this simplicity, as Grails has matured it has become much more than a web framework. It has become a web platform that participates in your entire project life cycle. Grasping all the concepts and conventions and applying them to your projects can be a challenge.

Fortunately, books like Beginning Groovy and Grails can help you get a grasp on the technology and guide you through the steps to make your application a reality. Chris, Joseph, and Jim do an excellent job of guiding you through the basics and then plunging headfirst into advanced topics like security, Asynchronous JavaScript and XML (Ajax), and deployment.