user error: The table 'cache' is full
query: INSERT INTO cache (cid, data, created, expire, headers) VALUES('archive:calendar:11-3-2010', '
<!-- calendar -->
<div class=\"calendar\"><table summary=\"A calendar to browse the archives.\">
<tr><td colspan=\"7\" class=\"header-month\"><a href=\"archive/view/2010/02/11\">«</a> March 2010 </td></tr>
<tr class=\"header-week\"><td>Su</td><td>Mo</td><td>Tu</td><td>We</td><td>Th</td><td>Fr</td><td>Sa</td></tr>
<tr class=\"row-week\"><td class=\"day-blank\" colspan=\"1\"> </td>
<td class=\"day-normal\"><div>1</div></td>
<td class=\"day-normal\"><div>2</div></td>
<td class=\"day-normal\"><div>3</div& in /usr/local/apache/vhosts/cmsstaging.developers.net/htdocs/cms/includes/database.mysql.inc on line 105.
|
|
Page Not Found |
|||||||||||||||||||||||||||||||||||||||||||||||||||||
about usResources
|
|
|
|
ResourcesBrowse archives
|
|||||||||||||||||||||||||||||||||||||||||||||||||
|
|
Page Not Found |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
about usResources
|
|
Software convention models using ELF visibility attributes
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Figure 1. Code that tries to allocate a block of memory.
Figure 2. Code written with an OSI library.
With an OSI library such as CompLib, developers can now write most or all of their drivers and applications independent of the operating system. Once they implement CompLib functions in the base code, they can move between platforms fairly quickly.
The Intel OSI reference implementation, CompLib, currently supports four OSes: Windows, Linux, EFI (Extensible Firmware Interface), and VxWorks. The Linux version of CompLib is now available (free) online for developers to use.
Advantages to porting code
Although portable code is not appropriate for all projects, it does have its advantages, including:
The Intel® Software Development Products are a full suite of tools that can help developers easily create the fastest software possible on Intel architecture. Our tools are compatible with the leading development environments available today, and are easy to use with the tools developers are already utilizing to tune their software.
Get the whole story on Intel Trace Collector, VTune Performance Analyzer, threading tools, MPI Library, and more by clicking link below.
© 2004 Intel Corp.
by Michael Hebenstreit
The power of the modern HPC Cluster is brought to the end user more often than not through software like StarCD* or Fluent*, two typical applications in the area of computational fluid dynamics (CFD). As long as everything works correctly – or at least as expected – neither the engineer setting up the computations nor the administrator ensuring the smooth work of the cluster actually knows what goes on inside the binary package doing all the calculations.
Unfortunately things tend to go wrong. At this point, the question "What is going on?" is fundamental to answering "How can I fix this problem?". If you are not able to answer the former question, everything you do is akin to feeling around in the dark. Even if you are able to solve the issue, you might still be wondering exactly why your fix worked, and if it is going to be an only temporary solution. Here we will speak about the Intel Cluster Tools, specifically the Intel Trace Collector, Intel Trace Analyzer and Intel MPI Benchmarks, which should be able to shed some light into this binary darkness.
At a customer visit, the author was faced with an Hewlett-Packard (HP)*/Intel Itanium 2 1.5GHz cluster running StarCD* over a Gigabit Ethernet switch. The customer was very dissatisfied with the performance of the system, pointing out that they were neither able to run a simple 32-thread job with high efficiency nor could they reproduce the benchmark results originating from the time of purchase. The author quickly verified during the visit that the main problem was the CPU utilization of each node – showing only around 60% instead of the usual mark of 95-100%
Introduction
By: Sergey N. Zheltov and Stanislav V. Bratanov, Senior Software Engineers, Intel Corporation
From a hardware point of view, multi-core processors are simply single-die physical packages that provide capabilities similar to traditional symmetric multiprocessing (SMP) machines, and inevitably inherit most of the performance monitoring problems a programmer typically faces while working with SMP.
We will address such performance estimation problems and advocate a thread-oriented approach to performance monitoring as an efficient way of dealing with multi-threaded code. At the same time, we will also address this as a basis for solving the particular task of monitoring Hyper-Threading Technology (HT Technology)-enabled multi-core systems.
This article discusses several methods and provides solutions to the problems which cannot be solved without the notion of the actual thread layout over time, thread activity, and interaction.
The problem of monitoring the utilization of resources shared between multiple cores or CPUs is discussed in an example of measuring bus utilization. A solution based on per-thread monitoring is suggested, and compared with sampling-based approaches.
Introduction
By Khang Nguyen
Contributors: Bob Valentine, Erik Niemeyer, Paul Lindberg
Currently, optimizing applications for a desktop platform is not the same as doing it for the mobile platform due to differences in the usage models for each platform. Intel® Core™ microarchitecture combines the best of the desktop Intel NetBurst® microarchitecture and mobile Pentium® architecture. As Intel will be using a single architecture for both the desktop and mobile platforms, the challenge is how to prepare your applications so that they can run well on Intel Core microarchitecture. What can we do with existing and new desktop and mobile applications to make them ready when the new Intel processors hit the market? This paper is not intended to show users everything they can do to improve the performance of existing applications on the Intel Core microarchitecture. It only suggests some techniques to either improve or maintain the performance of an existing application when running on systems with these new Intel® processors.
Techniques
Cache
Data in cache is accessed much faster than that in the main memory. Therefore, always try to load data in cache as much as possible. One of the features of Intel® Core™ microarchitecture is that level 2 cache is shared among cores. The primary benefit of a shared L2 is L2 data-sharing between threads running on different cores on the same die. This necessitates reevaluation of the mapping of hot data sections to threads in an application to ensure maximum hits in the L2. The other advantage of shared L2 cache is that if one core is disabled, the remaining core can make use of the full L2 cache. In order to get the number of threads that share the level cache, you need to execute instruction cpuid with eax = 4 and ecx = 0, 1, 2... (0, 1, 2 corresponding to the cache level 1, 2, and 3 if it exists, respectively.) The number of threads will be obtained by adding 1 to the return value in eax[25:14].
Note that in some systems, there is an option in the bios to toggle the “maximum input value”—you need to disable it. This option is used to limit the maximum value returned by executing cpuid with eax=0 to 3. This option is needed to boot Windows* NT 4.0. Without setting the limit of this value, Windows NT will hang up with a blue screen (screen of death). With this setting, executing cpuid with eax=4 will result in an error. Make sure that the "maximum input value" is the same in all processors.
Intel® C++ Compiler for Linux accelerates your software development, shortens your configuration time and improves your software performance while preserving your development investment. The compiler also provides these benefits:
Here are some of the new features:
Introduction
by Rahul Sathe and Oliver Heim
The GMA X3000 is the fourth generation of Intel Integrated Graphics. As with previous generations, the GMA X3000 chipset continues to add features that enable consumers to have a wealth of features at much lower cost than discrete graphics solutions. As these integrated solutions become more commonplace in the market, it becomes ever more important for 3D developers to support and target the feature set of Intel’s Integrated Solution. Intel Graphics is designed to meet the display needs for the majority of the business and consumer users. The graphics core is built into the chipset. It shares system memory with the CPU to keep the system architecture balanced at a compelling cost for the customer. Intel’s GMA capabilities match or exceed many more expensive graphics card solutions. PC buyers have appreciated this balanced approach to system design, and Intel Graphics is currently the number one graphics solution chosen by new PC purchasers. This can be seen in the second quarter 2006 data from Mercury Research which shows Intel Integrated Graphics to have a 34% of the market in 2006.
This document describes the Intel® Graphics Media Accelerator (Intel® GMA X3000) and provides development hints and tips to ensure that your customers will have a great time playing your games and running other interactive 3D graphics applications. We welcome feedback from ISV community and our customers.
Introduction
by Gail Lyons
Recent advances in silicon technology have changed the trade-offs in micro-processor architecture. Larger transistor counts have facilitated the design of Hyper-Threading Technology (HT Technology) and multi-core processors. A processor with HT Technology can provide two logical processors in one physical core. The physical resources of the core are shared between the two logical processors, and the state information that is needed to support each logical processor is duplicated. Applications rarely consume all of the physical resources of a core, so HT Technology enabled cores can improve the performance of many applications.
Multi-core technology places more than one core in a physical package. Multi-core processors may have a shared cache between its cores, or have a dedicated cache topology for each core. The performance characteristics of HT Technology and multi-core processors depend on processor topology and its cache topology on the platform. Optimal performance of multithreaded software requires effective management of shared and dedicated resources available to each logical processor.
Although the processor and cache topology in a modern platform are more complex than those of a traditional symmetric multi-processor design, this paper will demonstrate a detailed algorithm of enumerating processor topology. It will also show how to bind a thread to a specific processor under a Linux environment.
Message passing is an important tool for sites relying on high-performance computing (HPC) on Linux systems. It enables large data sets to be tackled with ease and often represents an important adjunct or alternative to thread-based solution design. Integrating message passing and threading has its challenges, however.
High-performance computing is characterized by running multiple tasks in parallel. These tasks tend to be similar in nature and can be run on different systems (as in a cluster or a grid), different processors (on a single system) or even different execution pipelines (as on processors with Hyper-Threading Technology). HPC systems add computing power by the addition of discrete computing engines (be they blades, nodes, or processors) rather than by upgrading existing processors. This aspect underscores one of the salient aspects of HPC: the number of executing processes can vary, and so software must be architected to scale dynamically across the number of available execution units.
One way to write software that dynamically takes advantage of a variable number of execution resources is to use OpenMP, a set of threading interfaces and tools that greatly simplifies threaded programming. Using OpenMP pragmas (in C/C++, or directives in Fortran), you can generate an executable that determines at run time the appropriate number of threads to create and then distribute a workload over these threads dynamically. OpenMP's other advantages, such as portability across a wide set of platforms, are detailed in a series of articles on this Web site. These articles also explain how to get started with OpenMP. For additional information, go to the OpenMP home page at www.openmp.org.
To read more, click link below.
The URL coursework.stanford.edu had humble enough beginnings in the late 1990s.
"It started as a research project and I was the only developer working on it," said Scott Stocker, a former Master's student who today is director of Web communications at Stanford.
The online course management tool is used by around 600 professors each quarter to post assignments, foster online discussion and administer quizzes. Stocker, who has long since moved on and up the Stanford IT hierarchy, left behind a full-time staff of four to manage the application he built from scratch.
Scaling, whether on a single university server or a massively distributed e-commerce application, is a challenge that just about every coder will encounter at some point in a career. And mobility only compounds the scaling issue, as new phone and PDA-powered users begin banging on Web applications designed for desktop and laptop browsers.
From academia to industry, hands-on programmers are using a handful of best practices to address the explosion of scaling issues. Many are still employing an eat-your-vegetables kind of coding common sense. But a rising tide of tools, applications, and documentation may soon make it easier to mobilize Web applications for new and different kinds of users.
Coding and mobile usersThe approach, as is fairly common in academia, was to get the ball rolling with open standards and open source.
The application's lower level guts were all open source, as Stocker built on top of the Linux operating system and mySQL database. Though it was a pre-J2EE world, Stocker still choose Java, and relied heavily on servlets and JSPs.
Unlike Common Gateway Interface (CGI) programs, Java servlets are persistent, standing by in memory to fulfill multiple requests once they're started. Beyond the benefits of separating a Web page's logic from its static elements, JSPs aren't restricted to any specific platform or server.
As coursework.stanford.edu moved from this-might-actually-work to mission critical, Stanford's main IT shop eventually stepped in to support Stocker's creation. Stanford IT is a Sun/Solaris/Oracle database environment, but the open source Java APIs plugged in easily enough to this backend.
"It's just the nature of Java Web applications that make them easy to scale," said Stocker. "The [Java] platform is TCP/IP based. It doesn't matter if the database is on a separate computer; the JDBC protocol allows for easy communication with the database over TCP/IP."
Reduce time-to-market, optimize your code for Intel® architecture and leverage existing investments with the latest Intel Fortran Compiler 8.1 for Linux updates:
Introduction
New strategies are needed to maintain historic rates of performance and price/performance improvement. We take a closer look at the Intel® Itanium® 2 processor.
By Robert Shiveley
"In 1978, a commercial flight between New York and Paris cost around $900 and took seven hours. If the principles of Moore’s Law had been applied to the airline industry the way they have to the semiconductor industry since 1978, that flight would now cost about a penny and take less than one second." (Source: Intel PDF 863KB)
In a 1965 paper, Gordon Moore predicted that the number of transistors that could be integrated into a single silicon chip would approximately double every 18 to 24 months. That prediction became widely known as Moore’s Law, and engineers at Intel have been transforming that law into reality for more than 40 years (Figure 1). During that time, increases in transistor density have driven roughly proportional increases in processor performance and price/performance. Those gains have powered the growth of today’s trillion-dollar electronics industry, put personal computers into businesses and homes throughout the world, and given rise to computing as a fundamental business enabler.
Introduction
Porting code from IA-32 architecture to EM64T to take advantage of 64-bit involves tradeoffs in performance considerations.
By Robert Y. Geva, Principal Engineer, Intel Software and Solutions Group
Intel® Extended Memory 64 Technology (Intel® EM64T) is a 64-bit extension to Intel's IA-32 architecture. Data can be accessed in 64-bit chunks, and large memory is addressable without special OS calls. This white paper introduces the architecture extensions and discusses performance tradeoffs when porting software from 32-bit to 64-bit. While being able to perform operations on 64-bit instead of 32-bit is an advantage for software that requires them, not all software can, in practice, take advantage of the additional computation bandwidth. Conversely, all data access addresses becoming 64-bits leads to increased pressure on HW resources, for example, the data cache. When porting SW from 32-bit in Intel IA-32 architecture to Intel EM64T architecture, there are performance implications resulting from differences in the architecture, implications of the microarchitecture and differences in software conventions. This white paper does not attempt to provide a characterization of applications that can benefit from porting to 64-bit—it merely discusses the tradeoffs.
We also note that several compilers are available that generate native code for EM64T: the Intel® Compiler and the Microsoft Visual Studio* 2005. Make strong efforts to optimize code for performance on Intel EM64T-based platforms.
Intel® EM64T Architecture
Intel® Extended Memory 64 Technology extends Intel IA-32 from a 32-bit architecture to a 64-bit architecture. EM64T introduces a new mode (referred to as "long mode") which supports running 32-bit or 64-bit applications. For the purposes of this paper, we will concentrate on the three modes in which most software will run:
by Kiefer Kuah
Dual-core and Quad-core processors are fast becoming the staple in desktop and mobile computing. In this article, performance data comparing single-threaded and multi-threaded matrix-vector multiplication are presented. In addition to multi-threading the routine, it was also optimized using Single Instruction Multiple Data (SIMD) instructions. The different implementations were tested on an Intel® Core™ 2 Extreme quad-core processor, QX6700. Measurable speedups were observed; the highest speedup was 20.8x. Next, the impact of increasing the data set to sizes beyond the last level cache was also characterized.
Introduction
The multiplication of a matrix and a vector is a common operation in applications such as in the skinning and physics code of 3D graphics games. We investigated a few ways to write the code for this operation and assess the performance of each version on a 2.66GHz Intel® Core™ 2 Extreme quad-core processors.
Six different versions of the code were written. The first version was written using C++ code. It involved two nested loops, iterating through each element of the data sets. This version would be used as the reference by which the performance of other versions would be measured. This version was then multithreaded using Windows* threading functions.
The SIMD versions were written in assembly and they operated on 4 floating point data in each loop. One version assumed that the data was in the array of structure (AOS) format while the other assumed the data was in the structure of array (SOA) format. Figure 2 shows an example of the structure of array construct. Two other versions were subsequently derived from these SIMD versions by converting them to multi-threaded code.
Deliver outstanding performance on single and multiprocessor computers with advanced optimization techniques to keep your legacy code in shape, including support for multi-core processors, OpenMP support and auto-parallelization.
The Intel® Fortran Compiler for Linux* delivers rapid development and winning performance for the full range of Intel® processor-based platforms.
This compiler product automatically optimizes and parallelizes software to take best advantage of multi-core Intel processors. This compiler is also available as a separate product that incorporates Cluster OpenMP*. The Intel Fortran Compiler for Linux with Cluster OpenMP provides all the functionality of the Intel Fortran Compiler for Linux, plus a simple means of extending OpenMP parallelism to 64-bit Intel® architecture-based clusters.
To sign up for a free 30-day evaluation license, click link below
Introduction
The demand for increased performance does not diminish, so more efficient ways to deliver that performance must be found.
By Shu-ling Garver and Bob Crepps, Intel Corp.
Microprocessor performance has scaled over the last three decades from devices that could perform tens of thousands of instructions per second to tens of billions of instructions per second in today’s products. Our processors have evolved from super-scalar architecture to instruction-level parallelism, where each evolution makes more efficient use of fast single instruction pipeline. Our goal is to continue that scaling, to reach a capability of 10 tera-instructions per second by the year 2015. The obvious question is: How do we get there?
The answer to that lies in Moore's Law. In parallel with our architecture scaling, our process technology has advanced or scaled at a rate predicted by Moore's Law. If we look ahead to the next decade, we will have the ability to integrate tens of billions of transistors on a single die. The dual-core Intel® Itanium® processor, code-named "Montecito," already uses 1.7 billion transistors.
As mentioned, our architecture has evolved to get the maximum performance from a single pipeline. However, we can make better use of the increasing number of transistors by moving to architectures that use multiple pipelines, or threads, or cores. We call this shift to multiple threads and cores the Era of Tera-scale Computing.
Introduction
Find where parallelism can be implemented effectively within a serial application.
By Clay P. Breshears, Intel Corp.
Explicit threading methods, such as Windows* threads or POSIX* threads, use library calls to create, manage, and synchronize threads. Use of explicit threads requires an almost complete restructuring of affected code. On the other hand, OpenMP* is a set of pragmas, API functions, and environment variables that enable you to incorporate threads into your applications at a relatively high level. The OpenMP pragmas are used to denote regions in the code that can be run concurrently. An OpenMP-compliant compiler transforms the code and inserts the proper function calls to execute these regions in parallel. In most cases, the serial logic of the original code can be preserved and is easily recovered by ignoring the OpenMP pragmas at compilation time.
OpenMP programs are threaded programs and can suffer from the same errors and performance problems as explicitly threaded applications. We assume you are familiar with OpenMP since this article examines the use of the Intel® Threading Tools, Intel® Thread Checker and Intel® Thread Profiler to analyze OpenMP programs. For Intel Thread Checker, we eschew the standard use of identifying storage conflicts in threaded code; rather, we use the diagnostic output to identify and categorize the scope of variables within parallel regions. After that, two of the more common performance problems encountered in OpenMP codes are discussed. We illustrate how to use Thread Profiler to identify these problems and give some possible solutions. For more details and information on using the Intel Threading Tools, see "Getting Started with the Intel® Thread Checker" and "Getting Started with the Intel® Thread Profiler" included in the threading tools documentation.
Introduction
New strategies are needed to maintain historic rates of performance and price/performance improvement. We take a closer look at the Intel® Itanium® 2 processor.
By Robert Shiveley, Intel Corp.
"In 1978, a commercial flight between New York and Paris cost around $900 and took seven hours. If the principles of Moore's Law had been applied to the airline industry the way they have to the semiconductor industry since 1978, that flight would now cost about a penny and take less than one second." (Source: Intel PDF 863KB)
In a 1965 paper, Gordon Moore predicted that the number of transistors that could be integrated into a single silicon chip would approximately double every 18 to 24 months. That prediction became widely known as Moore’s Law, and engineers at Intel have been transforming that law into reality for more than 40 years (Figure 1). During that time, increases in transistor density have driven roughly proportional increases in processor performance and price/performance. Those gains have powered the growth of today's trillion-dollar electronics industry, put personal computers into businesses and homes throughout the world, and given rise to computing as a fundamental business enabler.
Threading Building Blocks (TBB) is an award-winning C++ runtime library that abstracts the low-level threading details necessary for optimal multi-core performance. It uses common C++ templates and coding style to eliminate tedious threading implementation work.
TBB requires fewer lines of code to achieve parallelism than other threading models. The applications you write are portable across platforms. Since the library is also inherently scalable, no code maintenance is required as more processor cores become available.
FeaturesIntroduction
Intel ® Threading Tools help Autodesk optimize its Maya* digital software. Find out more in this case study.
by Geoff Koch, Intel Corp.
Times are good for Toronto-based Autodesk. Maya* software, the company’s flagship product, dominates the digital content creation (DCC) market for 3D modeling, animation, effects and rendering. Maya-wielding artists create stunning images across industries, from digital publishing and design visualization to broadcasting and game development.
And don't forget feature films. Despite its understated Canadian roots, Autodesk tools have helped build visual effects in some of the most ostentatious Hollywood blockbusters in recent memory, including the "Lord of the Rings" trilogy and the "Star Wars*" prequels.
But for Autodesk and other DCC companies, the digital media bar only gets higher. Photorealistic images and the suspension of disbelief are becoming hard and fast expectations for filmgoers and gamers. Building and rendering these ever more detailed images remains one of the ultimate cycle-suckers in all of computing.
" Leading studios rely on Maya software to deliver state-of-the-art results every day, and productivity is a huge factor for them," said Autodesk engineer, Martin Watt. "Whether it's something that improves the interactive drawing rate or something that reduces the time taken to render thousands of frames, anything we can possibly provide is key."
What's a Mashup?
An example is a web site that displays a list of restaurants in a given city and displays a map that highlights the location of the restaurants. The two types of information often come from different sites. This integration of services and content from multiple web sites is called a mashup.
Most sites add value beyond a simple integration of services and content. They benefit users in a manner that is different and better than the individual services. For example, Delexa.org brings together data from the social bookmarking site del.icio.us and the web site traffic tracker Alexa. Delexa.org uses the topic tags it gets from del.icio.us to allow users to search for top traffic sites by topic. A user can view the most frequently visited gardening or karate sites, for example.
Continue reading Mashup Styles, Part 1: Server-Side Mashups here.Matthew Ricks, a Sun veteran of 19 years, discusses outsourcing at Sun. As senior director of Sun vendor management, he is responsible for Sun's four largest outsourcing contracts. These include datacenter support, network management, internal helpdesk, and application development and maintenance.
Find out if Sun is seeing tangible savings and productivity gains from it's outsourcing efforts.
Increase server utilization, efficiency, and ROI while reducing server footprint. For free! Logical Domains (LDoms) is the most open virtualization technology available, and it is free. LDoms can provide big savings over proprietary virtualization technologies.
Key applications include:
Sun CEO Jonathan Schwartz discusses the $1 billion acquisition of MySQL. He covers how it will affect Sun, MySQL, and the database industry as a whole. Find out what happens to PostgreSQL and Oracle. See how the acquisition compares to the acquisition of StorageTek.
How is open source changing the industry in the most important way since the 1980s? Sun Executive VP of Global Sales and Services Don Grantham explains. Learn about the business value of open source. Find out what the three major advantages of open source are and how they can affect your business.
OpenSolaris and Open Source
Learn about OpenSolaris and open source. The future of software is in participation and community. Listen to this Sun Net Talk on Demand to hear Sun experts review the open source world.
To view the Sun Net Talk video: Open Community, Click Here.
As Chief Technology Evangelist at Sun Microsystems, Simon Phipps is charged with explaining the big picture of connected computing solutions. Today, the biggest picture in his gallery is the OpenSolaris project. He is bringing his 20-plus years of industry experience to the efforts of open source communities worldwide.
Phipps recently sat down with Inner Circle to discuss Sun's open source strategy, how it affects the way Sun does business, and why OpenSolaris benefits Sun, Sun's partners, developers, and customers.
Inner Circle (IC): What is the difference between Solaris and OpenSolaris?
Continue reading Open Up OpenSolaris here.Cut datacenter costs and increase flexibility with Sun Blade 6000 server modules
Sun has released the Sun Blade 6000 family, a new generation of blade servers with rackmount computing capabilities. The line includes three server modules running SPARC, AMD Opteron, and Intel Xeon processors.
Ali Alasti, vice president of engineering of the Sun Systems Group discusses how this new hardware offering provides new levels of computing firepower while lowering datacenter costs.
INNER CIRCLE (IC): Why should an enterprise consider Sun Blade 6000 systems over rackmounted servers?
Simulate your datacenter to see how Sun's new CoolThreads and x64 servers can save you power, cooling, and space. Inspired by the "The Sims" games, this interactive tool will challenge you to build a high-performing datacenter.
Continue reading Sun Sim Datacenter here.Download the next generation of Rational Rose: A free trial version of IBM Rational Systems Developer. This is a advanced modeling tool for developing and designing, empowering software architects and developers to create optimally-architected CORBA, C/C++, and Java/J2SE model-driven applications that fully leverage the Unified Modeling Language (UML 2).
WebSphere Application Server Community Edition V2.0 (WAS CE 2.0) is based on the Java EE 5.0 Apache Geronimo 2.0-MT-rc1. This powerful and free open source application server includes enhanced web service and simplified component and persistence models.
Register for your free copy of WAS CE 2.0 hereEclipse and Design Patterns
Learn how to install the PatternBox design pattern plugin for Eclipse. Then see how to create a Facade pattern with the new PatternBox plugin.
Aperi Storage Management Project introduction, Part 1
Learn about the Aperi’s user interface and some of the primary features of the topology viewer. See how you can explore the storage environment with the topology viewer. You can monitor the health of the elements in your storage environment. Zoom in and out of one of the storage fabrics to see the status of switches, ports, and attached elements.
Learn to use SOA entry points to develop an SOA lifecycle that encourages innovation. Practical examples with product feature demonstrations teach you SOA concepts and help jumpstart your projects. Register for this event at a location near you.
Scalable and secure connectivity within your business and beyond.
Get a practical and technical overview of SOA reuse and connectivity offerings, including the advantages of an ESB in building a flexible IT infrastructure. Register today for this technical briefing.
What Are Logical Domains?
Sun Microsystems’ Logical Domains, or LDoms, technology is part of a suite of methodologies for consolidation and resource management that includes Sun Fire Dynamic System Domains and Solaris OS Containers, of which resource control and operating system virtualization are a subset. This technology allows you, the user, to allocate a system’s various resources, such as memory, CPUs, and devices, into logical groupings and create multiple, discrete systems, each with their own operating system, resources, and identity within a single computer system. By careful architecture, a logical domains environment can help you achieve greater resource usage, better scaling, and increased security and isolation.
Continue reading Beginners Guide to LDooms: Understanding and Deploying Logical Domains here.
You can now evaluate Rational ClearCase V7.0 without installing or configuring it on your own system! Rational ClearCase is a comprehensive solution that provides integration with design, development, build, test, and deployment tools for controlled access to software assets across the full lifecycle. Rational ClearCase is seamlessly integrated with IBM Rational ClearQuest for a complete change and configuration management solution. Visit developerWorks to learn more about this product and register to explore its capabilities online.
You can now evaluate Rational ClearQuest V7.0 as a trial download or online without installing on your own system. Rational ClearQuest automates and enforces development processes for better insight, predictability, and control of the software lifecycle. ClearQuest integrates with design, development, build, test and deployment tools and facilitates communication across the organization. Visit developerWorks to learn more and get valuable technical resources to help you manage the software lifecycle more effectively.
Now you can try out Rational Performance Tester online without having to install it in your system or configure it. Rational Performance Tester helps teams create test, generate load and collect data simply. The end result, your team can be more confident in the ability of your application to accommodate user loads.
Try Rational Performance Tester Now
Innovation. Collaboration. Sharing. It All Happens Here.
In 2005 45% of new SAS business on UNIX was done on SUN Solaris servers. Sun offers a great platform for SAS deployments:
To further its investment with SAS, Sun has recently announced the opening of The Sun Solution Center for SAS Competency in its Menlo Park Campus. This is a collaborative effort between Sun and SAS Institute on delivering technology. It brings "high-value" ISV consulting expertise for our customers and partners by delivering proven Performance & Sizing characterization and Architecture & Design of the total customer landscape. "To address the significant market growth of Business Intelligence and Data Warehousing technologies, the Sun Solution Center is making joint investments with SAS Institute on delivering high-value ISV consulting expertise for our customers and partners." Graham Steven, Sr. Director Sun Solution Center
Available only to Executive Members of Sun's Partner Advantage Program, the Sun Solution Center offers many benefits to its preeminent Partners like SAS. The Sun Solution Center for SAS Competency offers dedicated, high level, strategic account planning; pre-sales services; and solution development expertise designed to mitigate not only SAS's risk, but also their customer's risk and time-frames associated with implementing a new solution.Software products that provide a high availability of resources are becoming commonplace in today's computing environments. As the complexity of managing logical disks and their data increases in cluster environments, understanding and deploying an effective backup strategy for complete data protection is a top priority.
Project Zero provides an environment for the rapid development of interactive Web applications based on popular Web technologies such as PHP. This tutorial demonstrates how easy it is to get started with Project Zero, from installing the development tools to constructing an Ajax Web 2.0 sample using PHP as the back-end scripting language. Exporting an application is covered on the way, together with examples of debugging and extending a Web 2.0 application.
The free-of-charge IBM DB2 Migration Toolkit can simplify and improve your migration to DB2 for Linux, UNIX, and Windows. This tutorial demonstrates the use of the toolkit to convert a database model from a Microsoft SQL Server DDL script to a DB2 database. The converted objects will include a stored procedure.
Part 4 of this six-part series shows you how to deploy a Java(TM) business application and database as a Java Web service running on a pSeries(R) system with the IBM AIX(R) 5.3 operating system.
Enterprise Generation Language (EGL) and Rational Business Developer Extension can be used to build dynamic Java web sites. This tutorial will step you through a simple Hello World Java application where you will create two web pages. One page will show database records, and the other page will facilitate the update of database fields. You do not need any previous knowledge of Java programming or J2EE (Java 2 Enterprise Edition). Rational Business Developer Extension provides the framework and GUI tools you need to create Java web applications and other complex business applications easily. Try the tutorial now to see just how simple it is.
Download a free trial version of IBM TXSeries for Multiplatforms, a distributed transaction processing monitor for CICS applications written in COBOL, C, C++ and PL/I. As a distributed transaction processing server, as well as a rapid deployment transactional integration platform, TXSeries for Multiplatforms delivers robust and extensible services in a modern, reusable, critical application environment.
Succeeding with Agility at Scale. Agile Development is one of the hottest trends in software development, promising improved team efficiency, shorter development cycles, better quality and software that is ultimately better suited to the customer's needs. IBM Rational provides technology, best practices, and industry expertise to help companies succeed in an Agile environment - regardless of their size and complexities.
Learn how IBM Lotus Component Designer and IBM WebSphere Portal are the ideal tools for creating and delivering composite applications. Follow along with a real-life scenario in which you download a sample component created with Lotus Component Designer, deploy it to WebSphere Portal, and turn it into a fully working composite application.
Eclipse and UML
This demo guides you through installation of Omondo's free UML plugin for Eclipse. You will also learn how to create a simple UML class diagram using the new plugin.
High-performance computing (HPC) has become easier, and two reasons are the adoption of open source software concepts and the introduction and refinement of clustering technology. This second of two articles discusses parallel programming using MPI and gives an overview of cluster management and benchmarking. It also shows you how to set up a Linux cluster using Oscar, an open source project for setting up robust clusters.
Part 1 of this series, Clustering fundamentals, discusses the types of clusters, uses of clusters, HPC fundamentals, and reasons for the growth of clustering technology in high-performance computing.
This article covers parallel algorithms, and shows you how to write parallel programs, set up clusters, and benchmark clusters. We look at parallel programming using MPI and the basics of setting up a Linux cluster. In this article, meet Oscar, an open source project that helps you set up robust clusters. Also, get an overview of cluster management and benchmarking concepts, complete with detailed steps to run the standard LINPACK tests on a cluster.
If you have installed Linux, you will be able to install and troubleshoot a Linux cluster after you read this article. And the helpful links in Resources below will help you get learn more about clustering.
Clusters and parallel programming platforms
As you saw in Part 1, HPC is mostly about parallel programming. Parallel programming is a fairly well-established field, and several programming platforms and standards have evolved around it over the past two decades.
The two common hardware platforms used in HPC are shared memory systems and distributed memory systems. For details, refer to Part 1.
On shared memory systems, High Performance Fortran is a language suited for parallel programming. It makes effective use of data parallelism and can act on entire arrays at once by executing instructions on different indexes of an array in different processors. Consequently this provides automatic parallelization with minimal effort on your part. (The Jamaica project is an example where a standard Java program is re-factored using a special compiler to generate multithreaded code. The resulting code then automatically takes advantage of SMP architecture and executes in parallel.)
On distributed memory systems, the situation is radically different because the memory is distributed; you must write code that is aware of the underlying distributed nature of the hardware and use explicit message passing to exchange messages between different nodes. Parallel Virtual Machines (PVM) were once a popular parallel programming platform for this, but lately MPI has become the de facto standard for writing parallel programs for clusters.
High-quality implementations for MPI are freely available for Fortran, C, and C++ for Linux. Two popular MPI implementations are
Creating a simple Linux cluster
One of the most interesting things about clustering is that you can build Linux-based clusters with minimal effort if you have basic Linux installation and troubleshooting skills. Let's see how this is done.
For our cluster we'll use MPICH and a set of regular Linux workstations. For simplicity, and to emphasize fundamentals, we'll build just the bare minimum system that you can use to run a parallel program in a clustered environment.
The seven steps in this section show how to build our bare-bones system. Building robust clusters and managing them involve more effort and will be covered later in this article.
Step 1:
You need at least two Linux machines if you want a real cluster. Two VMware images will also do just fine. (With VMware, obviously you do not expect any performance benefits. In fact, there will definitely be a performance hit because the CPU will be shared.) Make sure these machines can ping each other by name. If not, add appropriate entries in /etc/hosts.
Step 2:
Install the GNU C compiler and GNU FORTRAN compiler.
Step 3a:
Configure SSH for all your nodes to allow it to execute commands without being asked for a password. The aim is to get something like ssh -n host whoami to work without being asked for a password. SSH will be used as the way to communicate between different machines. (You can use rsh also for this purpose.)
This article, the first in a two-part report, reviews common issues of wireless security, and shows how to use open source software to suss out wireless networks, get information about them, and start recognizing common security problems.
One of the best ways to make sure information is kept secure is to broadcast it using a published standard, and to try to make sure the signal goes as far as possible. Right? Well, maybe that isn't the best strategy after all. Unfortunately for us, the convenience of wireless access to a network means that a lot of people use a wireless network, and that means that a lot of data is being broadcast in the clear.
In this article, I'll build a lightweight wireless sniffer that runs on open source software. You'll see how simple it is to interact with wireless networks. The information the sniffer collects offers some insights on key wireless security issues.
It's easy to underestimate the availability of wireless networks. During testing for this article, I had a recurring problem: my equipment kept accidentally picking up networks other than the ones I wanted to test. In fact, my laptop has found wireless networks to associate with while I'm traveling on the freeway! So, one obvious thing for a wireless network scanner to do is to identify the names and signal strengths of local wireless networks.
Rough consensus and running code
The code used for this article is not particularly elegant. The focus is on building a simple front end to the standard utilities, producing data that is accessible as plain text for use from a serial console or remote login.
The target platform for the sample code is NetBSD running on a fairly small box, using a standard wireless card. The primary test platforms were a laptop using an Intersil Prism chipset, and a Soekris Systems Net4801 using an Atheros chipset. The bulk of the actual code is written in Perl, using the Curses module from CPAN to make a friendly interface.
If you plan to build a more serious or fully featured program, you would probably be better off using this code as a prototype rather than actually using any of the code directly. However, it does show how some of these tools go together. My use of threading was an experiment, and I leave it up to you to decide whether that experiment was a success.
This series describes the development of the sniffer from a fairly simple (and yet buggy) program into a more complete program with fewer bugs; the last version of the program is available for download from Resources, on the last page.
Setting up the system
Flash prices continue to drop, and the test system was set up by installing NetBSD on a compact flash card. The only package installed from pkgsrc is perl58, and the only module added to it is the Curses module from CPAN. Because the application uses threading, Perl was built with the variable PERL5_USE_THREADS=yes set in /etc/mk.conf.
The goal of this application is to allow a user to connect, either over a serial console or over the network, to the system running the wireless code, and get updates on the current network status. Curses is a good way to get some of the flashiness of a graphical application without the overhead of using the X Window System or a Web server.
The program I'll develop in this article is a small Perl script that uses system commands as a back end to access the wireless network. This program will run from the command line, and will read its configuration from a file. For now, the configuration file is just read from the current directory when the program starts. (Looking ahead, this might be useful on a machine with multiple network interfaces, with each interface watching a different wireless network.)
Scanning for networks
On the first pass, I'll simply build a program that scans for and lists wireless networks. This only shows networks that are broadcasting their identity to the world. The command for this, in NetBSD, is wiconfig interface -D. Because the interface might change from system to system, the application reads that information from a configuration file. The user is presented with a list of the names of found wireless networks, and selects one from the list; then the details of that network are displayed.
To do this, the program runs wiconfig, using the -D option, and parses the output. The results are stored in an array of references to hashes. Each member of the array holds the scan results for a single access point; each hash contains a list of name/value pairs, where the name is the heading. The output from wiconfig looks like Listing 1:
Listing 1. Network scan results
The code to parse this is fairly simple. Listing 2 illustrates the main components of the function; there's a little setup work beforehand, but this is the interesting part.
Listing 2. Parsing network scan results
In the resulting hash, the name netname (SSID) is associated with the value testnet. The long names are difficult to work with, but renaming them would just add another layer of confusion. (It would be worth doing, perhaps, given that the value named [dbm] makes no sense if you don't recognize it as a subheading of Quality/Signal/Noise.)
Scans take a while, and monopolize the network interface, so it's not reasonable to run them constantly. One solution to this problem is to run a network scan only when trying to pick a network, then look at the statistics for that individual network.
Eclipse and C/C++
See how to install a C/C++ compiler (MinGW), and configure the Eclipse Developer Environment to use the C/C++ Developer Toolkit (CDT). This demo assumes you are working with Eclipse 3.0.
Driving Datacenter Optimization through Virtualization
IT organizations constantly seek technology that can lower the cost and complexity of managing ever-expanding compute environments. Toward this end, enterprises need strategies and tools that help maximize the use of every compute asset and improve operational flexibility.
Datacenter Server Proliferation
In order to remain competitive, organizations continually adjust existing business plans and work to create new income opportunities. Technology often holds the key to revenue improvement, creating requirements for IT organizations to deploy increasing numbers of compute services. With enterprise success at stake, many organizations avoid possible system security, availability, and performance conflicts by deploying only one application per server. Corresponding servers are then installed to support development, test, and disaster recovery requirements.
These common datacenter management practices soon create a sprawling compute infrastructure that is difficult to manage and leaves systems largely under utilized. In addition, IT managers are startled to find datacenters quickly reach physical and budgetary constraints in the areas of power, cooling, and real estate. The resulting inefficient IT infrastructure carries cost burdens that can actually limit business growth, leading organizations to seek more effective hosting strategies.
Continue reading Enable a Flexible, Efficient IT Infrastructure Virtualization with Logical Domains and Sun Coolthreads Servers here.How To Move a Solaris Container
This How To Guide instructs users, system administrators, and developers who have experience with Solaris 10 on proper use of new features which allow a Solaris 10 Container to be moved from one computer to another. The guide starts with a brief discussion of the need for such functionality and follows with three examples of the use of this functionality.
Note: Technology described in this guide is currently available in Solaris Express, and will be available soon in a Solaris 10 update.
Users are guided step-by-step through the process of moving a Container, with code examples and illustrations. After using this guide, a user should be able to move a Solaris Container by:
download | 748.5 KBDeutsche Apotheker und Ärztebank, better known as apoBank, is Germany’s largest cooperative bank with more than 300,000 customers, 50 branch offices and assets of 31 billion EUR (41 billion USD). apoBank provides comprehensive business management and financial services to individuals and organizations involved in social welfare occupations, including pharmacists, physicians, dentists and veterinary surgeons.
Business IssuesSun's new Network.com delivers on-demand apps for HPC
On March 13, Sun announced Network.com and the Network.com Application Catalog. Sun Inner Circle asked Kris Thorleifsson, Sun's group marketing manager for Network.com, to explain the new services and what they mean for users, ISVs, and developers.
Inner Circle (IC): What is Network.com?
Thorleifsson: Network.com enables communities of scientists and academics in life sciences, education, manufacturing, and other fields to easily accelerate innovation, and get research done faster and cheaper. It's an HPC supercomputing resource that delivers immediate online access to popular ISV and open source applications used by researchers in their daily work and provides access to a powerful compute grid. The portal gives users everything they need to conduct complex computational tasks and analysis to help speed scientific discovery. Just select the application, bring your data, and get results fast!
IC: Can you give us a few examples of some applications that are available in the catalog today?
Thorleifsson: The Network.com Application Catalog is loaded with more than 20 HPC applications for life sciences, academic, and manufacturing users to try at minimal cost, such as SimBioSys' eHiTS, Mathspec's Rational Numbers, BLAST, FASTA, Glimmer, T-Coffee, GROMACS, fastDNAml, ElmerSolver, Impact, OFELI, Blender, CalculiX, to name a few. Sun is working with its ISV partners and has engaged with numerous open source communities to grow the list of available applications.
Organizations are turning to new ways to improve datacenter performance while lowering power consumption, space, and cost
Business as usual has taken an unusual turn. As customer demand for faster, better, and cheaper computing grows, so too does the need for energy to fuel this growth. And the numbers are alarming. According to a recent industry survey1, datacenter power requirements are increasing an average of 8 percent per year — and power requirements of the top 10 percent of datacenters are growing at an even greater pace at more than 20 percent.
A recent poll conducted by Harris Interactive found that IT executives are increasingly aware of the rising energy costs associated with powering their datacenters, with three quarters of the nearly 200 executives queried saying energy efficiency has become a buying priority.
Two years ago, a Gartner poll revealed that more than 69 percent of datacenters are power-, cooling-, and space-constrained. Since then, servers have only continued to consume more power and generate more heat, and energy prices have soared (by Sun's estimation at 30 percent per year), making this an ideal time to develop a high-performing, energy-efficient datacenter.
The Energy Information Administration2 acknowledges that the most rapid increase in demand is going to come from IT equipment. In short, the cost of powering IT infrastructure comes right off the bottom line, which is why IT professionals are now being asked to find more efficient ways to increase computing capacity.
Reducing expenses by turning down the heat and cultivating green datacenters
Hello Sun Inner Circle readers. It’s Bob Worrall back with another installment in a series of letters that I publish in this venue to share my insights into the IT industry and latest developments here at Sun. Last month, I shared some of the larger lessons I learned during my first 100 days on the job as Sun CIO. This month, I’m going to discuss an issue that’s increasingly a hot topic (literally!) in today’s datacenters — energy efficiency and eco-responsibility.
If my readers will forgive me, more often than not, CIOs don’t have a clue about datacenter energy expenses. Typically, power bills are sent directly to the real estate team or the CFO. However, with the rising costs of energy worldwide, many CEOs are beginning to hold the CIO responsible for datacenter energy costs. That simple accounting change represents a monumental shift within today’s organizations — and one that I increasingly get questioned about by executives curious how Sun is managing higher energy costs.
To answer some of the queries, I invited Mark Monroe to join me for a Q&A. Mark has been at Sun for more than 13 years, during which time he has spent some time running Sun datacenters. Most recently, Mark went to work for Dave Douglas, Sun vice president of Eco-Responsibility, and now, as director of Sustainable Computing, Mark spends his time encouraging datacenter energy efficiency and determining what portion of Sun’s energy portfolio comes from green power. He understands how Sun is turning down the heat in its datacenters in reduce energy expenses and encourage eco-responsibility.
Worrall: Mark, you’ve been part of the eco-responsibility movement for a while. Why has the issue become such a hot topic for datacenter operators?
Monroe: It boils down to simple economics. Researchers at Lawrence Berkeley Labs have done extensive studies on datacenter efficiency and energy consumption. LBL estimated that 3 percent of the entire energy consumption of the United States — including automobiles, buildings, houses, and everything else that consumes power — derives from datacenters. Furthermore, power consumption rates are following Moore’s Law: As processors become more powerful, energy consumption grows at the same rate as processing power increases. Based on that, LBL concluded that the power consumption rates double every two to four years. Plus, the study that cited the 3 percent figure was done in 2004, and today in 2007, it’s conceivable that datacenters are guzzling upwards of 5 percent to 6 percent of energy in the U.S.
When "good enough" is no longer good enough
Like many IT veterans, Sun Executive Vice President for Software Rich Green witnessed numerous enterprises adopting Linux in the 1990s to meet the demanding requirements of Web applications and services. Now Green is witnessing a new trend: Issues surrounding the long-term benefits and cost-effectiveness of Linux are causing IT managers to reassess the places where the operating system makes sense.
In this issue of Sun Inner Circle, Green explains why many enterprises today are opting to upgrade from Linux to the Solaris OS and how that's helping enterprises scale IT infrastructures to meet pressing business challenges.
Green is responsible for defining the vision and roadmap for Sun’s software strategy, including the Solaris OS, Java Enterprise System suites, N1 management software, and Sun Studio and Java Studio developer tools. Green’s perspective is based on more than 20 years of industry experience, 16 of which have been spent at Sun, and close involvement with industry-standards efforts and open source communities have contributed to his insights into the evolution of developer platforms and enterprise software.
INNER CIRCLE (IC): Let’s start out by asking a basic question: What was behind the initial appeal of Linux to support the Web tier of applications and services?
GREEN: People picked Linux in the past for a number of very good reasons. First, starting in the mid-'90s, the adoption of Linux was largely fueled by fast processors. Intel, for example, was producing processors for the desktop at a price-performance level so attractive that it made a lot of sense to start using commodity-based or volume-based application infrastructures. With the rapid growth of the Web tier, a free UNIX-like operating system coupled with inexpensive servers proved pretty attractive.
Second, the same period witnessed the increasing popularity of the open source development model.
Optimizing for Lower Cost and Higher Performance through Balanced XIP
1.0 Introduction
Embedded system1 designers have a variety of code execution methods to choose from: eXecute-In-Place2 (XIP), Fully Shadowed3 and Demand Paging4. Using the best method is the key for a cost-effective solution. Each method has different implications in terms of RAM and Flash usage which directly affect the cost of the system. By choosing the best solution, the designer can realize optimal speed and chip size while reducing the Bill of Materials (BOM). This paper will explore a new type of code execution called Balanced XIP. Balanced XIP combines XIP and Demand Paging to achieve a flexible solution that can be optimized for the greatest overall performance and Flash/RAM usage to accommodate continuously changing requirements.
2.0 Techniques and Approaches
Many factors are involved with determining the code execution method for a system; BOM cost, processor features, OS capability, etc. A system may not support paging if the processor lacks a Memory Management Unit5. Most RTOS6 do not have the dynamic memory management system needed for Demand Paging. Therefore many RTOS designs are limited to either Fully Shadowed or Execute-In-Place. If the hardware supports it, a full-featured operating system may be used to allow for a Demand Paging or a Balanced XIP approach.
download | 144.03 KBBanking On Intel and SUSE Linux* Operating System (OS)
Bank of Communications (BOCOM) powers up transactional processing on Intel® Platforms running SUSE Linux* OS
Technology is vital in the daily business operations of any modern bank, and like many banks in China, the Bank of Communications (BOCOM) relies on front-end servers to manage numerous terminals in its branches. BOCOM wanted to take advantage of new information systems available on the market because its mounting volume of business transactions was making it increasingly difficult for the bank's current computer systems to maintain its stability. In 2006, BOCOM revamped the information systems at its branches, upgrading to Intel® processors running the SUSE Linux* operating system.
Challenge
Solutions
download | 257.6 KBProduct Description
PC users are running multiple, intense software applications simultaneously, increasing demand on hardware resources. In the office, PC usage has changed from data entry and word processing to e-Commerce, online collaboration and an ever-increasing need for continual security and virus protection. In the home, interests have shifted from low-bandwidth photos and Internet surfing to downloading and viewing high definition videos, as well as advanced photo and video editing. The Intel® Core™2 Duo processor was developed to meet all these demands.
Built on the innovative Intel® Core™ microarchitecture, the Intel Core 2 Duo desktop processor delivers revolutionary dual-core performance and breakthrough processor energy efficiency. With Intel® Wide Dynamic Execution, Intel® Smart Memory Access, Intel® Advanced Smart Cache and Intel® Digital Media Boost, this new processor is designed to do more in less time. Additional features to support enhanced security, virtualization and 64-bit computing makes the Intel Core 2 Duo the most impressive new processor developed for an increasingly multimedia-centered, high-definition world.
Energy Efficiency
Design changes in the Intel Core 2 Duo processors that improve performance also increase processor energy efficiency by operating at lower frequencies that require less power to run. A new feature, Intel® Intelligent Power Capability, optimizes energy usage of the processor cores by turning on computing functions only when needed. These more energy-efficient processors support smaller, more capable, and quieter desktop PCs to conserve critical power resources.
download | 185.1 KBIntroduction
This paper describes the compatibility between Intel® Compilers for Linux* and GNU compilers in terms of source, binary, and command-line compatibility. The Intel® C++ and Fortran Compilers help make your software run at top speeds on Intel platforms, including IA-32, processors with Intel® EM64T, and Intel® Itanium® processor-based systems. The compilers also provide compatibility with commonly-used Linux softwaredevelopment tools.
Overview
Intel C++ Compiler 9.0 for Linux provides excellent source and binary compatibility with the GNU GCC compiler. Compared to previous versions, Intel C++ Compiler 9.0 has improved compiler-option compatibility with GCC and general improvements related to the GCC build environment.
The motivation for improved compatibility comes from customer requests in several areas:
download | 297.91 KBWhy Linux Is Good for ISVs
Sponsored by: Red Hat and Intel
IDC OPI NION
In IDC’s opinion, Red Hat and Intel perform well across the three major factors that can influence an independent software vendor’s (ISV) decision to partner with a software vendor:
IN THIS WHITE PAPER
This IDC White Paper examines the market opportunity for enterprise Linux products and services and the position of Red Hat and Intel’s collaborative solution set in that market. It discusses the key resources Red Hat provides to ISVs to help them port and build applications to run on Red Hat Enterprise Linux and presents IDC’s opinion on Red Hat and Intel’s value proposition for ISV partners.
THE LINUX OPPORTUNITY
The growth of Linux operating environments and products is continuing along the path from upstart invention to enterprise competitor. IDC forecasts the market for application and infrastructure software on Linux to grow to $14.2 billion by 2008, representing a compound annual growth rate (CAGR) of 44.3%
from 2003 (see Table 1). Factors that make enterprise-oriented Linux products attractive to customers consist of longer and more predictable support life cycles, including security patch life cycles, combined with extensive certifications on industry-standard hardware platforms, such as Intel® EM64T,
Intel® Xeon., and Intel® Itanium® 2 processor.based servers.
To read more, click link below to subscribe to Intel® Software Dispatch and begin receiving Intel® Software Insight, a quarterly e-zine focused on the topics software-industry leaders care about. Once you fill out the brief subscription form, you will be able to download the pdf and continue
reading IDC Analysis of ISVs, Intel,and Linux.
To read complete article, click download below.
download | 124.91 KBBusinessObjects XI delivers extreme insight through specialized end-user tools on a single, trusted business intelligence platform. BusinessObjects XI includes the industry’s best performance management, reporting, and query and analysis products. These integrated end-user interfaces are supported by the most reliable, scalable, flexible, and manageable BI platform, and complemented by unified data integration.
End users have better business visibility with BusinessObjects XI. They can feel confident that they are achieving their goals on time, and they can easily align individual and group actions and decisions to the broader organizational strategy. Thanks to a unified view of enterprise performance, end users can measure what matters most and monitor individual and operational goals and metrics through intuitive, interactive, and visual displays of information.
BusinessObjects XI allows the IT department to integrate BI into any infrastructure and embed secure components into virtually any application. With its adaptive, services-oriented architecture, broad data access, end-to-end metadata, and centralized, web-based administration—BusinessObjects XI is the best platform to standardize on for all your BI needs and to embed into your existing applications.
Introduction
by John Sharp, Content Master Ltd
Clusters offer a scalable means of linking computers together to provide an expansive environment for hosting enterprise applications. The Intel® Xeon® processor and Itanium® processor are cost-effective platforms that are well-suited to implementing clusters, providing advanced features such as parallel architecture, large addressable memory spaces, and three-level cache for fast access to critical data.
OSCAR* (Open Source Cluster Application Resources), is an open-source project comprising software for building high-performance clusters. Currently, OSCAR is available for Linux*. OSCAR is managed by the Open Cluster Group, an informal group of professionals from a variety of establishments and organizations. The goal behind the OSCAR project is to make clustering a freely available and easily configurable option for systems based on Linux, helping to bring Linux into the mainstream of enterprise computing.
OSCAR contains a number of facilities, including cluster-management tools, a message passing interface based on the MPI standard, a job queuing system, and a batch scheduler. System images can be built on an OSCAR server and downloaded to OSCAR clients for execution using the OSCAR Installation Wizard. The environment is straightforward to install and configure, providing good scalability at minimal cost.
This paper provides an overview of OSCAR, describing how to use it to deploy an application cluster that can be used as a platform for high-performance computing.
By Meghan Desai, Rotation Engineer
Intel® Software Group
This year's Consumer Electronics Show showcased a dizzying array of consumer electronics devices with exhibits distributed across the Las Vegas Convention Center, the Las Vegas Hilton Convention Center, and the Sands Convention Center. With 2,700 booths spanning nearly 2 million square feet, the experience of walking through this maze and attempting to capture it all can be summed up by only one word: overwhelming. Many top industry players showed up-Intel, Microsoft, Hewlett-Packard, Panasonic, and others-as well as many smaller companies.
Amidst the chaos, one trend was striking: the convergence of functions in compact electronic devices. For example, the new Nokia n93i* combines cell-phone functionality with an MP3 player and a 3.2-megapixel camera. It can also convert to a camcorder or wireless mini laptop. Meanwhile, this trend of convergence was also evident from the other side, that is, computers packing their functionality in smaller and smaller form factors and incorporating other features. Samsung showcased its Ultra Mobile PC (UMPC) as the world's first, running Microsoft Windows Vista* on an Intel® Celeron® M processor.
Of course, Intel's booth also had an array of UMPCs and Ultra Mobile Devices (UMDs). Incorporating 3G, Wi-Fi*, and built-in webcams, UMDs are where cell phones meet the PC. At the east end of the booth, seated in real Formula 1* race cars, drivers tested their skills playing RFactor* on Intel® Core™2 Extreme processorbased systems. Experienced with car-racing games, your humble author can attest to the unbelievable realism.
download | 2.15 MBTo keep pace with the industry-wide shift toward multi-core processing, technology companies are reshaping their product roadmaps to capitalize on the rich opportunities and educating their development staff on the benefits of parallelism. The development community is getting more active as well, recognizing the possibilities offered by multi-threaded applications and seeking to learn the techniques that will influence their careers in the future.
To help unlock the unrealized potential of multi-core processing, Intel is actively involved on several fronts. Using a variety of communication techniques and producing resources to equip the software community with multi-threading expertise, Intel is expanding their outreach into new areas to reach a new generation of software professionals.
Intel’s innovative outreach is advancing in these areas:
download | 2.15 MBGamers are constantly looking for the next hot playing experience. Game developers feed this hunger by perfecting game realism, animation, and interactivity. This frequently includes optimizing their newest games for the latest game-playing platforms. To keep raising the bar, many top game developers and publishers use products from Havok, one of the gaming industry's leading independent providers of physics and character animation middleware. Its leading physics engine is one of the most widely used technologies for developing state-of-the-art games such as F.E.A.R*, Half Life 2*, Age of Empires III*, Company of Heroes*, Max Payne 2*, Destroy All Humans 2*, Over the Hedge*, Auto Assault*, and Oblivion*. Havok’s dedication to continuously innovating, enhancing, and optimizing its technology for new platforms has made it a first-choice for renowned publishers like Sony, Microsoft, EA, Ubisoft, and Activision.
BREAKING DOWN THE BARRIERS TO IMMERSIVE GAMEPLAY
To be competitive, today’s game worlds require realistic animations, authentic behaviors, and highly believable characters. Accomplishing such realism requires superior gameplay physics simulations. Gameplay physics affects how a game is played from moment-to-moment, and is generally computed on a computer’s processor. Physical changes that you cause in the game or that happen to you or around you—like knocking over a box, and then climbing up on it—change what you may want to do in each instant of gameplay. To maintain the realism, all these changes have to occur smoothly with no detectible latency. For this to happen, the close proximity between physics, game logic, and memory generally demands that these systems execute together on a computer’s processor.
A limiting factor in the past was hardware power. This is rapidly changing with the advent of multi-core processors. Combined with graphics processing unit (GPU) graphics, multi-core processor architectures have the potential to enable fully simulated game characters and their moment-to-moment actions in completely interactive and destructible 3-D worlds. Havok has introduced HydraCore* technology in its physics system and other products to take advantage of these architectures now and in the future.
download | 2.15 MBContinuing where we left off in Part 1, we can now discuss some of the fields. Particularly, field one and fields three and four are the most exciting.
File permissions and ownership
Linux separates access control on files and directories according to three characteristics: owner, group, and other. There is always exactly one owner, any number of members of the group, and everyone else.
The files within each of these categories have specific permissions with which they are accessed. File permissions, including regular files, special files (such as FIFOs, sockets, etc), or symbolic links (which dereference the permissions to the file they point to) can have any one, or any, of the following:
Symbol | Permission | |
r | Read | Can be opened to read the contents |
w | Write | Can be modified, including appending and deleting |
x | Execute | Can execute the file if it is a program or shell script |
s | Special Perm | setuid or setgid permission |
- | Access Denied | Cannot be read, written, or executed, depending on the position of the `-' |
The read, write, and execute permissions should be pretty clear as to their meaning. However, the "s" symbol may need to explanation. The next two sections address this symbol.
Set user-identification attribute
When the set user ID access mode is set in the owner permissions, and the file is executable, processes which run it are granted access to system resources based on the owner of the file.
Be extremely careful when setting these permissions. Any user who runs that file assumes the permissions of the owner of the executable file, instead of the user who created the process. This is the cause of many "buffer overflow" exploits, typically resulting in superuser privileges.
The setuid permission is shown as an s in the file permissions. For example, the setuid permission on the /usr/bin/passwd command enables normal users to read and write an otherwise inaccessible /etc/passwd file:
user@myhost | $ ls -l | /etc/shadow | /etc/passwd /usr/bin/passwd |
-r-------- | 1 root | root | 659 Jul 25 19:40 /etc/shadow |
-rw-r--r-- | 1 root | root | 711 Jul 25 19:40 /etc/passwd |
-r-sr-xr-x | 1 root | bin | 15613 Apr 27 12:29 /usr/bin/passwd |
You will notice that the s takes the place of the execute bit in the example above. This special permission mode really has no meaning unless the file also has execute permission as well.
In the example we see the /etc/shadow file is only readable by root, yet the /usr/bin/passwd file enables us to write our password changes there. When either a normal user, a member of the bin group, or even anyone else executes /usr/bin/passwd, it is really run as root, due to the "s" bit set in the owner's permissions field.
Keep in mind that setuid has a different meaning when applied to directories. See the explanation for directories that follows.
If the lack of integration and support has been holding up Linux deployments in the data center, IBM's Integrated Platform announcement is likely to kick-start the market.
By any standards, IBM's progress in driving Linux up into the data-center environment has been impressive. Although the open-source operating system has been struggling to gain credibility as a base for real business-critical applications, a steady stream of enterprise-class customers has been implementing new systems under Linux, moving the focus away from simple Web server and file/print server deployment and toward core business systems.
Download this whitepaper and find out more.
© 2003 Arcati Ltd.
A three-step technology convergence is unfolding that will better align business and IT, making enterprises more agile, operationally efficient, and able to deliver new and better value to end customers. This convergence will also better position IT as a strategic element in the global business value equation.
The convergence of technologies such as virtualization, Grid, and serviceoriented architecture (SOA) is creating a critical inflection point for the enterprise IT architecture. The resulting converged state of these technologies holds the promise of addressing some of the most significant problems facing enterprises today.
Forces creating an opportunity for IT innovation
Four forces are driving enterprises to move toward standards-based solutions built using virtualization, Grid, and SOA technologies. That move is creating an opportunity for IT organizations to better serve the business and ultimately the customers of the business.
The evolution of business processes
Most enterprises have learned from the past couple of decades that new technologies can be critical for transforming a business to better serve customers since this transformation often requires automating processes and changing the fundamental way a business runs and operates. For example, build-to-order PC vendors have transformed how companies deliver customized products to individual customers, creating competitive advantages. Pharmaceutical companies are applying a similar model to their business as they work to deliver personalized medications to meet individual needs.
To read more, click link below to subscribe to Intel® Software Dispatch and begin receiving Intel® Software Insight, a quarterly e-zine focused on the topics software-industry leaders care about. Once you fill out the brief subscription form, you will be able to download the pdf and continue reading
The Convergence of Virtualization, Grid, and SOA.
To read complete article, click download below.
download | 1.11 MBFREE Trade Magazine Subscriptions & Technical Document Downloads.
Browse through our extensive list of trade publications and technical documents by industry and geographic eligibility to find the titles that best match your skills and interests. Simply complete the application form and submit it. Publications are absolutely free to professionals who qualify.
Publications include:
By Jonathan Schwartz
One of the most interesting trends to watch in 2007 is the continued democratizing power of the Web. You can see it everywhere. One of America's finest institutions of learning, Yale University, is posting its curriculum online for anyone to freely access. Education, broadly distributed, for free. It's great for our collective global intelligence.
And Yale is not the only one - Stanford University, the University of California, the University of Wisconsin, and others are participating in the Google Library Project to provide the entirety of their library's contents to everyone, everywhere via the Web.
Whether or not you are interested in online education, what's really happening here is that these universities are reaching new "audiences" - students and academics in this case. Who's going to take these courses? Those who couldn't afford to attend, or are located in far regions of the globe, or maybe just didn't have the grades. Either way, what's important is that the universities aren't cannibalizing their existing student population, but expanding it (and their reputations) - to billions of people through the Internet.
In order to fuel innovation and get products to market faster, you need to be the most efficient. With regards to a manufacturer’s infrastructure, that means reducing operational costs and automating management—even at remote sites—while increasing security and not compromising on agility. You need to make smart choices in base infrastructure technology.
SUSE® Linux Enterprise Server from Novell® enables you to deliver mission-critical IT services—with enhanced security and reduced costs—while improving reliability and performance.
Now is the Time for Linux in Manufacturing
SUSE Linux Enterprise 10 is the platform for the open enterprise. Through the most rigorous software building and testing best practices in the industry, Novell designs SUSE Linux Enterprise to be the best engineered, lowest cost and most inter-operable platform for enterprise computing. The SUSE Linux Enterprise 10 platform offers several solutions for the manufacturing industry, including SUSE Linux Enterprise Server and SUSE Linux Enterprise Real Time. Numerous manufacturers are using SUSE Linux Enterprise Server in their corporate and technical data centers, trusting Novell excellence in serving global enterprises to satisfy the specialized needs of business and engineering—significantly reducing costs while improving system performance.
SUSE Linux Enterprise Server 10 allows you reap substantial performance and cost benefits in the following areas:
By including technologies like the XEN hypervisor* for virtualization, Oracle Cluster File System 2*, Heartbeat* 2.0.3 and Multipath* I/O for storage, high availability and failover, SUSE Linux Enterprise Server allows you to reach new levels of server consolidation and utilization, storage management, automation and savings in the data centers you have deployed across the globe.
Resource utilization. Efficiency. Scalability. Availability. Manageability. Security. These are the issues that keep data center managers awake late into the night. Virtualization technologies can address these concerns and benefit the entire enterprise, but they haven’t been widely adopted—that is, until recently.
What’s changed? Well, for starters, the data center. The number of physical servers has grown to unmanageable proportions. Enterprises need virtualization technologies to compensate for the inefficiencies of increasing server sprawl. Linux* has taken a more prominent role in enterprises1—handling everything from edge services (Web, firewall, DNS and DHCP) to middle-tier application and middleware; from backend database, e-mail and file serving to commercial high-performance cluster computing and enterprise grid deployments. More and more enterprises are also turning to Linux to help address their multi-tier server consolidation issues. In addition, Intel and AMD have designed virtualization functionality into the latest x86 and x86-64 processors—adding hardware support for server consolidation by enabling strict fault and performance isolation. They’ve also added functionality that enables unmodified operating systems to run concurrently on the same physical machine.
In this rapidly changing landscape, Linux vendors such as Novell have recognized the possibilities for data center transformation. These organizations are now releasing a new generation of products designed to integrate virtual machines—increasing efficiency and managing resources in ways that were unforeseen just a few years ago.
Novell is committed to the propagation of Xen* virtualization technologies. These technologies are included in the release of SUSE® Linux Enterprise Server 10, the latest open source server operating system from Novell®. This unique opportunity for Novell to take a leading role in the shift to virtualization-based IT is due to the convergence of commodity hardware and open source software—that is, Linux running on x86 and x86-64 computers. It’s a combination that is transforming racks of compute and storage servers into the preeminent enterprise IT platform. Virtualization is also differentiating applications as they evolve into self-contained modular services. Xen virtual machines take that evolution one giant step further.
OVERVIEW
COCC is a mutually owned service bureau proving information technology services to community banks and credit unions in the Northeastern U.S. The company has more than 130 customers and nearly 300 employees.
CHALLENGE
Technology requirements often exceed the capabilities of many community banks and credit unions. COCC provides the technology expertise to help these organizations run their businesses and compete with national banks. The company services 7,000 workstations, 500 ATMs and processes more than 7 million check images each month. COCC needs to support a broad variety of platforms and applications, as well as have the flexibility to create custom applications to meet specific needs of its customers.
Security is also a critical requirement for operating in a tightly regulated industry. COCC had been using a proprietary UNIX* system, but wanted to move its business to an open platform to improve its development opportunities and reduce costs. The company also hoped to improve performance and security.
SOLUTION
For a company focused on customer service, COCC was determined to find a software vendor that shared a similar commitment to support. The company evaluated Linux* solutions, including Red Hat*, but found a more comprehensive and secure solution in SUSE LINUX Enterprise Server. COCC was able to install SUSE LINUX Enterprise Server in about an hour and quickly began performing application migrations from UNIX or Microsoft Windows.
WALTHAM, Mass. - March 30, 2005 - Deutsche Bahn, Germany's national railway company, has selected Linux* as its strategic server platform. Currently DB Systems, the IT service provider of Deutsche Bahn, is running more than 300 Intel-based servers with critical business applications on Novell's SUSE® LINUX Enterprise Server. Applications like Lotus Notes* have now been migrated to the IBM* mainframe platform also using SUSE Linux Enterprise Server. DB Systems expects significant cost savings, more vendor independence and integration advantages throughout the roll-out period and beyond.
"We had to choose a system that would offer us the flexibility, security and reliability required to maintain a high level of services to our customers. We are confident that a Linux based system can offer us this more cost effectively than any proprietary solutions," said Detlef Exner, director of IT Production for DB Systems.
Following that strategy, DB Systems evaluated several options and selected SUSE Linux Enterprise Server due to its scalable, high-performance foundation for secure enterprise computing. Exner adds, "Novell's ability to offer extensive support for SUSE Linux and its co-operation with many hardware and software vendors has given us additional confidence to use this also for our mission-critical tasks."
download | 748.5 KBOVERVIEW
Established 175 years ago, GLOBUS is a leading retailer in Germany with more than 20,000 employees and nearly 90 locations, including 10 in the Czech Republic. GLOBUS competes in a more than 35 markets, including food, electronics and home improvement, selling more than 100,000 products in each of its stores.
CHALLENGEGLOBUS had been using a proprietary UNIX* system to run its custom-developed ERP applications. Each store location had an expensive server to run its ERP applications, as well as file and print services. With slim profit margins in the food market, the company needed to significantly reduce its IT expenditures, without sacrificing performance or reliability. By moving from a proprietary system to Linux*, GLOBUS sought to reduce both its software and hardware costs.
SOLUTIONGLOBUS evaluated several Linux solutions before selecting SUSE LINUX Enterprise Server. The company needed a comprehensive solution that was also modular and flexible.
GLOBUS began implementing SUSE LINUX Enterprise Server in 20 of its smaller locations and in a short time saw good results. The company is now rolling out SUSE LINUX individually to all its 35 locations. An IT team of two can install, transfer data and test SUSE LINUX Enterprise Server for a store location in less than a week.
SUSE Linux Enterprise 10 is an open, flexible and secure platform that is ready to host the applications and databases critical to your business—from the desktop to the data center, across a wide variety of workloads. The SUSE Linux Enterprise platform is tightly integrated with Novell solutions for systems management, identity management and workgroup services, and it also utilizes open standards, which simplifies integration with your existing IT environment.
With SUSE Linux Enterprise, your organization can better address the challenges of increasing competition, spiraling costs, growing security threats and demanding customers. When performance, reliability and world-class support really matter, organizations choose SUSE Linux Enterprise from Novell®.
SUSE Linux Enterprise 10 includes the following components:
Novell ZENworks® Linux Management is not part of the platform but is frequently discussed as a significant value-added patch-and-update tool that integrates into Novell Customer Center.
In the future, Novell will release additional products built on top of the SUSE Linux Enterprise 10 platform, including SUSE Linux Point of Service 10 and Novell Open Enterprise Server 2.
SUSE LINUX ENTERPRISE SERVER 10
With more than 1500 enhancements, new features and updates, SUSE Linux Enterprise Server 10 is the latest version of the world’s best-engineered Linux* server.
SUSE Linux Enterprise Server is an enterprise-quality server designed to handle mission-critical workloads in the data center. Developed and backed by Novell, only SUSE Linux Enterprise Server offers an open, scalable, high-performance data center solution that comes with application security, virtualization and integrated systems management across a full range of hardware architectures. SUSE Linux Enterprise Server is deployable as a general-purpose server or can be tailored to run a variety of specialized workloads, and it offers seamless interoperability with your existing data center infrastructure.
Supported and certified by the world's leading hardware and software vendors, SUSE Linux Enterprise Server is backed by award-winning Novell technical support and a global ecosystem of partners and services. With SUSE Linux Enterprise Server, businesses can dramatically reduce costs while deploying the most secure and reliable data center server on the market.
Sun's Whitfield Diffie on ECC and Solaris 10 OS security
In a groundbreaking 1976 paper on public-key cryptography, Whitfield Diffie famously illustrated how people with no prior knowledge of each other could use a shared public key and private secret key to enable a secure communications. Now as chief security officer at Sun Microsystems, Diffie is responsible for ensuring that Sun remains on the forefront of security innovation. Sun Inner Circle recently caught up with Diffie to discuss how Sun sees the future of information security and encryption.
Inner Circle (IC): It's been nearly 30 years since the 1976 Diffie-Hellman paper ushered in the age of public-key cryptography. What's the impact of the paper today?
DIFFIE: It's like having 15 minutes of fame: I did one good hour of work in 1976 and I've been making a living off of it ever since. The impact of the paper has been very gratifying. With SSL in every browser, public-key encryption is the most widely deployed cryptographic technology of all time.
It's also gratifying to have achieved some goals that are broader than the technology. I was one of the founders of the Association for Cryptologic Research, which now has more than 1,000 members and plays a role in putting on more than a dozen conferences a year. I just came back from Crypto 2006 in Santa Barbara, which had 500 attendees. The first Crypto conference was in the same location in 1981. It was the first public research conference on cryptography that I can recall and it had about 50 attendees.
One of my goals was unification of the techniques used to protect government information with those used to protect commercial information. It always seemed silly to think that a secret document required more protection than a billion dollar funds transfer. Well, it's finally begun to happen. Last year, the National Security Agency announced a new suite of cryptographic algorithms authorized to protect all levels of classified information. All of them are public and most of them are public standards. They call it Suite B. (Suite A is a collection of secret algorithms with colorful names like "Juniper" and "Mayfly.")
The centerpiece of Suite B is the Advanced Encryption Standard, a cryptographic algorithm designed in Belgium and selected by the U.S., in an international contest, to be its national standard. The key management part of Suite B is second-generation public-key cryptography. It's called elliptic curve cryptography, or ECC
Continue reading Talking Security with Mr. Cryptography here.
Opening Up with Simon Phipps, Sun's Chief Open Source Officer.
With 20 years of experience in software development, Simon Phipps has helped guide Sun's open source strategy, including the OpenSolaris project. Now, as chief open source officer at Sun, Phipps has been given the weighty task of deciding how to open source all of Sun's software.
Inner Circle recently sat down with Phipps to discuss open source licenses, working with communities of developers, and how governance of open source projects is critical to success.
Inner Circle: You've now been in the chief open source officer position for almost a year. Tell us about your role and its responsibilities.
PHIPPS: It's an exciting role, and one that leverages what I've done as chief technology evangelist at Sun in the past. In this role, my responsibilities have expanded as a result of the formation of the Open Source Group at Sun. This particular group has quite a broad and diverse set of responsibilities — as might be expected from an organization that exists to create a consistent approach across all of Sun's open source projects.
» What are some of the challenges that the Open Source Group must confront?
PHIPPS: Licensing policy is obviously a very important matter for us, but the Open Source Group at Sun has other equally important tasks. It also seeks to determine how Sun is going to identify its open source projects, as well as what approaches should be taken with regards to the governance of open source projects. Within the team there are people with a technical interest in the open sourcing of Java, Solaris, and Sun development tools. Plus, the group also helps the customer-facing staff understand and communicate Sun's open source commitment.
» Can you tell us which open source business model Sun supports?
PHIPPS: I think it's funny that people still talk about an open source business model. As far as I can tell, there is no single business model for open source projects. The term "open source" really describes what happens when a community of developers gathers around a shared body of source code, and uses that knowledge to create software products or programs that meet specific needs. But, those needs are not always the same thing. Some developers are working on open source projects to make money, others for social ends, and some are in it for the fun of it.
So, just as there are many different motivations for involvement, there are many different business models that can be used by an open source community. At Sun, our current thinking tends to promote a model that makes the software available completely without charge. Then we provide services that are useful in putting that open source-based software into production.
» Broadening the discussion a bit, what are the biggest challenges that open source communities, in general, face today?
Continue reading The Challenge of Open Source Software here.
I'm Larry Singer, Sun senior VP and strategic insight officer. I can hear you now... you’re either intrigued or amused by my title, and wondering what a strategic insight officer does for a living.
My job at Sun is to help a company that was built by engineers for engineers do a better job of "intercepting" customer demands and responding with our powerful R&D resources to engineer industry-leading technology that meets real-world needs.
Becoming the sponsor of Sun Inner Circle gives me a unique opportunity to do that, and I look forward to exchanging with you thoughts, ideas, and insights on the IT opportunities that are always before us. I would like to thank Bill Vass for his sponsorship of Sun Inner Circle and wish him continued success in his new role as COO of Sun Federal.
One opportunity that's before us is Web 2.0. In case you missed it, the World Wide Web commemorated its 15th anniversary last month, on August 6. On that date in 1991, Tim Berners-Lee, a researcher at the CERN nuclear physics laboratory in Switzerland, posted the world's first public Web page, and helped to trigger the technological juggernaut that would change the world.
Now it's all about Web 2.0, and a second generation of rich, dynamic Web services built on secure open standards that enable sharing, participation, and collaboration while delivering the extreme performance and massive throughput demanded by global proliferation of the Internet.
Continue reading 7 Practical Ways to Web 2.0 here.
Unix, whatever the flavor, has long since given up its role as the savior of IT. And, in fact, while Unix is widely embedded at many organizations, there are those who see its days as numbered, primarily because alternatives like Linux can get the job done less expensively—thanks to an open-systems approach that gets rid of proprietary software and proprietary hardware. And, best of all, migration from Unix to Linux is largely pain-free.
The keys to ensuring migration success, so you can leverage the advantages of Linux, are having partners and a plan. Intel and Novell®, offering the combination of Intel server technology and SUSE® Linux Enterprise Server, are able partners, ready to help you develop an action plan. And with a plan, you can begin to transition from Unix to Linux, yielding:
Here’s how!
Linux – Open For Business
For starters, it is important to understand that Linux, which began as the inspiration of just one man, Linus Torvalds, has become the joint endeavor of a well-governed, cooperative, business-oriented global movement. Linux is no longer bleeding-edge or experimental. It’s the smart open choice for business today, offering a strong ROI opportunity. That opportunity is based on its open architecture and low cost as well as the ability Linux provides to simplify and consolidate your infrastructure around fewer servers and away from proprietary products. Moreover, a migration often translates into an overall savings in terms of software, hardware, personnel, and support and maintenance costs.
SUSE® Linux Enterprise 10 helps you fuel innovation by delivering UNIX*-like performance and reliability on both commodity and high-end hardware.
With scalability to 1,024 CPUs, more than 10 TB of physical memory on the server, accelerated graphics and interoperability on the desktop, an automated installation system, remote administration and world-class, enterprise-level support, SUSE Linux Enterprise 10 is the platform of choice for server and desktop computing in Electronic Design Automation (EDA).
Today’s consumer electronics demand increasingly complex designs. As a manufacturer of semiconductors or electronics, you are facing challenging decisions:
Novell® understands the challenges of the electronics industries and offers many unique features that impact EDA with SUSE Linux Enterprise 10 such as:
Inside Xen 3.0: A XenSource White Paper
Virtualization has become a key requirement for the enterprise. This results from an urgent need to focus on reduced total cost of ownership (TCO) for enterprise computing infrastructure. In spite of – or indeed because of – the widespread adoption of relatively cheap, industry standard x86-based servers, enterprises have seen costs and complexity escalate rapidly. In addition to the capital expenditures to purchase them, each server in the data center costs an enterprise about an additional $10,000 per year to run, with costs including provisioning, maintenance, administration, power, real-estate, and hardware and software licenses.
At the same time, most servers today run at less than 15% utilization, meaning that most server capacity is wasted. Operating system (OS) virtualization, a concept pioneered by IBM in 1972 on the System 360, has become a key requirement to alleviate this problem because it enables increased utilization, allowing multiple operating system and application images to share each server, cutting both per-server capital cost and the overall lifetime operational costs. If every physical server can host multiple virtual servers, the overall required number of servers is reduced, and with that reduction come increased utilization, reduced complexity, and lower total cost of ownership.
Virtualization also offers many additional benefits – including development, staging and testing, dynamic provisioning, reduced patching, no-downtime maintenance, high availability and load balancing. Further, virtualization opens the door for enterprises to realize the promise of utility computing. But today’s virtualization offerings are crippled by poor performance, lack of security and scalability, and an inability to offer the fine-grained resource guarantees that are required to provide true application level SLAs and support high availability. To get high performance virtualization on today’s modern hardware takes a new kind of software: a low level, minimal, secure and high performance virtualization software layer called a hypervisor. The Xen open source hypervisor, created by the XenSource founders and now developed collaboratively by over 20 major enterprises working in the Xen project, is leading the industry in high performance enterprise virtualization. Moreover Xen is the industry’s first virtualization software to fully support Intel’s VT-x hardware virtualization support.
Virtualization: The New Data Center Paradigm, Again
Virtualization is almost as old as enterprise computing itself. First introduced in the 1960s to allow partitioning of mainframe hardware, it has been a mainstay of high-end proprietary server environments ever since. Today, virtualization is once again a hot topic of conversation in the data center because emerging technologies have the potential to remedy issues relating to resource utilization, efficiency, scalability and manageability. Armed with virtual machines on commodity hardware, data center administrators hope to create new levels of flexibility and agility in their environments at a lower total cost of ownership.
Virtualization can drive up resource utilization on individual servers, thus increasing the total return on those investments. Moreover, it can integrate distributed systems, transforming disparate racks of compute and storage servers into a bona fide enterprise IT platform.
Two new major developments will have a dramatic effect on virtualization technology adoption. On the hardware side, x86 architecture-based microprocessor manufacturers have released a new generation of chips that support virtualization natively. On the software side, the emergence of the open-source Xen* hypervisor virtual machine technology has eliminated much of the performance impact associated with the mediation layer that accompanies full virtualization and software emulation. The introduction of Xen also drives down the overall cost of virtualization.
These developments could completely decouple software from the underlying physical implementation. The result would be impressive new levels of resource utilization and improvements in availability, manageability, scalability, performance, application security and much more.
But virtualization is not a panacea. Without the right infrastructure and management tools, virtualization may do very little to stem the tide of complexity and inefficiency that has overwhelmed even administrators’ best plans. Thus, when selecting a vendor to help you virtualize your data center, you should choose one with the management tools and experience to help make your implementation a successful one.
Novell® sees virtualization as a tremendous opportunity for its data center customers. Novell envisions virtualization-enabled data centers in which there is highly sophisticated integration of components that are largely isolated today. It’s an environment in which Novell expertise and technologies will play prominent roles. SUSE® Linux Enterprise 10, the flagship Linux* platform from Novell, continues to lead the way in data center virtualization, with support for both x86based processors and mainframes.
How to Achieve Sustainable, Cost-Effective Growth for Your IT Infrastructure—and Your Business
Opportunity and Risk in a Time of Change
The ability to understand and manage change has long been a core competence of successful companies. In today’s global and technology-dependent business world, it is more important than ever. Technology is opening markets, enabling global outsourcing, and helping companies cope with complex regulatory requirements across multiple jurisdictions. Technology is also moving us toward a real-time business environment in which transactions are instantaneous, processes are transparent, and the ability to turn oceans of data into actionable information is a critical competitive advantage.
A convergence of technologies fuels these changes. A short list would include Web services, radio frequency identification (RFID) tags, mobile clients and wireless networks, Voice over IP, and improved tools for business intelligence and process analysis. It is critical that companies work to understand and integrate these emerging capabilities. As they do so, they also must pay close attention to the basic health, scalability, manageability, and agility of their IT infrastructure, because fundamental server technologies are also advancing rapidly. Companies that manage these transitions effectively will be better positioned to successfully extend their technology-based business solutions. Those that don’t may be left behind in a rapidly changing competitive environment.
Today’s Critical Server Hardware Transitions
Three transitions stand out as particularly fundamental for addressing next-generation performance, capacity, and TCO challenges: multi-core processors, virtualization, and 64-bit computing (Figure 1).
download | 748.5 KB download | 748.5 KB
In the
The second installment of this series illustrates a hands-on approach to get your Bluetooth system up and running in linux and then moves on to learn some basic Bluetooth communications from the shell .
Setting up Bluetooth on Linux
Compiling a kernel with Bluetooth support
The first thing you have to do is enable Bluetooth support in your kernel. If you don’t have Bluetooth support in your kernel you may get a precompiled on that has Bluetooth on it, or compile it yourself from the sources (recommended). You may also want to build only required modules for your running kernel, but this howto doesn’t explain that.
I have set up my bluettoth on kernel 2.6.15. It has the bluez kernel installed. If you are using the 2.6 series, the next thing you need to do is install the bluez utils package and the bluez library packages. For earlier kernel versions (2.4 series) you will also need to install the bulez kernel before installing the other packages.
All of the above bluez packages are available
Starting Bluetooth
Your Bluetooth system is almost ready. Now you have to start the Bluetooth service. Use :
[root@haxbox kdebluetooth]# service Bluetooth start
If everything goes well you should see:
Starting Bluetooth subsystem: hcid sdpd hidd hid2hci rfcomm.
Bluetooth service has been started. Next you need to plug in your Bluetooth dongle (I used an ISBT Bluetooth USB dongle). Then load the necessary module by doing a modprobe.
[root@haxbox kdebluetooth]modprobe hci_usb
To read more, click link below.
To achieve the objectives of their Integration Strategies, IT infrastructure groups have been moving towards implementations based on "Open Standards". This article is focused on envisioning a traditional Middleware "component" from a Service Oriented Architecture point of view.
A Middleware component, such as a database adapter is re-architected to comply with the Open Standards. The Adapter’s large grained logic is decomposed into smaller "Services", each performing a simple task. A current physical adapter in this case is considered a "Virtual Adapter", because it is logically comprised of distributed, independent, interoperable, but loosely coupled "Service" objects.
Each "Service" is started as a WebService. A "Service" is interoperable with other services via its exposed Web Services Description Language (WSDL). The services "find" each other by performing a "lookup/discovery" process in a Universal Description, Discovery and Integration (UDDI) implementation. A "Coordinator" service, known as Resource Manager Service (RMS) receives a Single Object Access Protocol (SOAP) request message from a Middleware routing service, usually a business message broker. Depending on the request message details, the RMS identifies and initiates the service resources, which are "needed" to collaborate in order to process this request. After this process is completed, the RMS sends back a SOAP reply message to the Middleware message broker.
What are the Issues?
Traditional IT integration strategies are based on coarse-grained, point-to-point and often proprietary components. The core functionality of such proprietary components constitutes a small portion of the overall functionality of the business; the rest of these components provide functionality that is mostly shared with other components. In addition to the component’s core functionality, the JVM in which the component functions includes common modules such as a Configuration Manager, a Logging Manager, a Transport Management, Monitoring and Routing managers, to name a few.
In a Middleware system where several of such components get deployed on the same server, performance, maintenance, error detection and fault tolerance are important issues to consider in the overall system’s behavior. When it comes to reusability, Middleware systems architected based on such large grained components are bound to the redundant deployments of jar files pertaining to these common modules. The front-end users of such "closed" middle tiers are often blind to what the current operational state of these components is. This affects the clients who could make better logistics decisions if they had a priori knowledge about the state of the middle tier. Middleware systems with such characteristics are closed to their clients, unable to adapt to changes derived by new business requirements and ultimately, they are unable to keep up with the evolving technology standards. Throughout their deployment phase, they cause redundant efforts which in most cases are simply considered obsolete.
What is a Virtual Component?
Proprietary components implementing an organization’s business functions make up the core details of that organization’s IT infrastructure. They have functionalities that we cannot live without, but they must not become overheads.
To avoid the issues that were mentioned above, a coarse-grained component is decomposed into several fine-grained, independent collaborating services with open interfaces. Each component is now comprised of a number of Reusable Services plus one service that implements the targeted business function. The collaborating services responsible for maintaining a component’s overall functionality are loosely coupled and are interoperable through Open Standards recommended guidelines. Therefore, a physical large grained component’s functionality is "virtually available" at runtime as a result of the distribution of its function amongst a group of reusable services. The "collaboration pattern" of these services is business requirements driven. It evolves polymorphically and performs "on demand". The on demand integration of such collaborating services with open interfaces results in a middle tier "Virtual Component".
Benefits
Virtual Components: A Database Adapter Example
A Middleware database adapter’s functionality is logically distributed over a network of independent fine-grained Web Service objects. The resulting collaboration of these interoperable services constitutes a "Virtual" coarse grain database adapter component. Any service may be the runtime client of one or more peer services. A service’s details are exposed to its clients via one single WSDL document. A service looks up the service(s) it needs to leverage by obtaining its reference(s) from an implementation of an Open Standards UDDI. A service publishes its own reference to the UDDI implementation once it gets started either by an administrator or by an orchestrating service. When a service obtains a reference to another service, it uses it to send a SOAP message to that service via a transport mechanism whose details are out of the scope of this article. Such transport must be supported by the ESB on top of which the Virtual Component is deployed. A "Coordinator" service, known as Resource Manager Service, starts to handle a specific category of business services. RMS manages the synergy amongst the collaborating services implementing the target component. It receives a SOAP message per each request from the Middleware’s service router, i.e. a message broker. Upon completion of a request process, the RMS sends a reply message back to the Middleware’s message broker. Consequently, the client will receive the reply message.
While a service’s function is encapsulated, it adapts to its new requirements changes by mutating its member objects, locally and independently. The vehicle for maintaining such adaptability, interoperability and integration capabilities is the Open Standards. A middle tier adapter which is implemented as a result of the runtime integration of such WebService objects is Service Oriented and, hence a "Virtual Adapter".
A Service Oriented Adapter Model
Implemented based on Open Standards Web Service, a service is the paradigm for establishing a concrete integration strategy of a Virtual Adapter.
As mentioned before, the RMS receives a SOAP request message from the middleware’s message broker. To initiate the participant services, the RMS uses the service initiation information residing in the WS-Addressing header blocks of the SOAP message.
A minimal set of participant services integrated at runtime to function as a Virtual Database Adapter is described below.
The middleware’s routing mechanism sends a SOAP message to a particular RMS (as described below). In this case, the broker’s message flow receives a SOAP message from a client, performs necessary transformations and passes it on to a corresponding RMS. Depending on the request’s details in the SOAP message, the message flow selects the RMS it should send the request to. To reach the provider’s endpoint, the flow uses a URL from the RMSs WSDL and sets its "WebService URL" property to it dynamically. When the broker receives the reply back from that RMS, it sends it back to the calling client using the endpoint information it retrieves from the client’s WSDL.
RMS is implemented as the "Coordinator" pattern service to manage the collaboration of the participant services.
An instance of RMS, listening to receive HTTP/SOAP requests from the middleware’s service broker is started for a category of business services. For instance, an RMS instance is started to listen for requests, which are database bound. Upon startup, the RMS looks up the UDDI implementation and obtains references of a set of minimal participant services such as a Configuration Manager Service, a Logging Manager Service, a DataSource Manager Service and a Business Function Service. These WebServices expose their references and public methods invocation details via a WSDL document. The collaborating WebServices access each other at runtime. Once the request processing is completed, the RMS merges the results into a reply message and sends it back to the middleware’s message broker. .
This is a WebService, which maintains and manages all configurations related entities for a virtual component. Basically, the RMS passes a fully qualified configuration path to the CMS only once at the RMS’s start-up time. The CMS registers the new RMS’s reference as its client and then caches all the configuration parameters available in the files on the configuration path and stores them in a serializable Collection object. A copy of the configuration key/values is submitted to the RMS.
Throughout a virtual component’s life cycle, if there are any changes in configuration files, the CMS detects this change automatically and updates its own cache. It then notifies the corresponding RMS by passing a refreshed copy of the configuration values to it.
All the loggings pertaining to a particular RMS service and its participant services are delegated to a particular instance of LMS. Once the RMS is provided with all the configuration data by CMS, it passes the required logging information to the LMS. The LMS registers the RMS’s reference as its client and uses this reference to notify the RMS of any file system related errors. The LMS’s reference is passed by the RMS to all participant services for on demand loging.
This is a WebService, which makes all the database calls on behalf of any collaborative service requiring database access. In particular, a Business Function Service (as described below) delegates its database invocations requirements to this service. This service leverages the Open Standards infrastructure to obtain connections, perform query executions and manages any transactional operation against the backend database system.
This is the WebService, which has the adapter’s business logic at its core. It receives the input request message from the RMS, identifies the required database related fields, creates SQL statements and delegates the database calls to the DMS. In addition, the BFS uses LMS for logging and CMS (when necessary) throughout processing of the request message. It produces a reply message using the results it obtains from the database and sends it to the calling RMS.
Conclusion
The evolution of the Open Standards provides an opportunity to further decompose large applications into a runtime integrated set of collaborating smaller, efficiently managed objects known as "services". Service Oriented Architecture based infrastructure technologies such as Enterprise Service Bus (ESB) simplifies this logical decomposition process by providing an environment where these services can be well defined by open interfaces. Interoperability becomes a "given" when these services are implemented as WebServices. A WebService is a reusable object, which can participate in satisfying multiple business functions. As a result, a particular combination of available smaller reusable WebServices create an equivalent larger business function. This article perceives such an integration phenomenon a Virtual Component. The Virtual Component is a polymorphic runtime entity versus the traditional middle tier physical components packaged offline. A Virtual Component is adaptable to business requirements changes easily because its core business functions are implemented in one isolated service, hence a BFS. The Virtual Component is reusable because the participating services such as CMS and/or LMS can provide facilities to multiple Virtual Components simultaneously with little to no coupling. An "Open Middleware" is, therefore is comprised of a set of middle tier Virtual Components leveraging Open Standards guidlines.
Compiling the Linux Kernel
One of Linux’s greatest strengths is that its source code is available to anyone who wants it. The GNU GPL (General Public License) under which Linux is distributed even allows you to tinker with the source code and distribute your changes! Real changes to the source code (at least, those to be taken seriously) go through the process of joining the official kernel tree. This requires extensive testing and proof that the changes will benefit Linux as a whole. At the very end of the approval process, the code gets a final yes or no from a core group of the Linux project’s original developers. It is this extensive review process that keeps the quality of Linux's code so noteworthy.
For system administrators who have used other proprietary operating systems, this approach to code control is a significant departure from the philosophy of waiting for the company to release a patch, a service pack, or some sort of "hot fix." Instead of having to wade through public relations, sales engineers, and other front-end units, you have the option of contacting the author of the subsystem directly and explaining your problem. A patch can be created and sent to you before the next official release of the kernel, and get you up and running.
Of course, the flip side of this working arrangement is that you need to be able to compile a kernel yourself rather than rely on someone else to supply precompiled code. And, of course, you won’t have to do this often, because production environments, once stable, rarely need a kernel compile. But if need be, you should know what to do. Luckily, it’s not difficult.
In this chapter, we’ll walk through the process of acquiring a kernel source tree, configuring it, compiling it, and finally, installing the end result.
CAUTION: The kernel is the first thing that loads when a Linux system is booted (after the boot loader of course!). If the kernel doesn’t work right, it’s unlikely that the rest of the system will boot. Be sure to have an emergency or rescue boot medium handy in case you need to revert to an old configuration. (See the section on GRUB in Chapter 6).
What exactly is a kernal?
Before we jump into the process of compiling, let’s back up a step and make sure you’re clear on the concept of what a kernel is and the role it plays in the system. Most often, when people say “Linux? they are usually referring to a “Linux distribution.? As discussed in Chapter 1, a distribution comprises everything necessary to get Linux to exist as a functional operating system. (For example, SuSE Linux is a type of Linux distribution.)
Distributions make use of code from various open source projects that are independent of Linux; in fact, many of the software packages maintained by these projects are used extensively on other UNIX-like platforms as well. The GNU C Compiler, for example, which comes with most Linux distributions, also exists on many other operating systems (probably more systems than most people realize exist).
So, then, what does make up the pure definition of Linux? The kernel. The kernel of any operating system is the core of all the system’s software. The only thing more fundamental than the kernel is the hardware itself.
The kernel has many jobs. The essence of its work is to abstract the underlying hardware from the software and provide a running environment for application software, through system calls. Specifically, the environment must handle issues such as networking, disk access, virtual memory, and multitasking—a complete list of these tasks would take up an entire chapter in itself! Today’s Linux kernel (version 2.6.*) contains almost six million lines of code (including device drivers). By comparison, the sixth edition of UNIX from Bell Labs in 1976 had roughly 9000 lines. Figure 9-1 illustrates the kernel’s position in a complete system.
Although the kernel is a small part of a complete Linux system, it is by far the most critical element. If the kernel fails or crashes, the rest of the system goes with it. Happily, Linux can boast its kernel stability. Uptimes (the length of time in between reboots) for Linux systems are often expressed in years. Indeed, UNIX systems in general regularly claim significantly long uptimes.
Get a pdf version of Chapter 9 from Linux Administration: A Beginner's Guide: click download, below.
© 2006 McGraw-Hill
The Rich Client Platform (RCP) is an exciting new way to build Java applications that can compete with native applications on any platform. This tutorial is designed to get you started building RCP applications quickly. It has been updated for Eclipse 3.1.
Introduction
Try this experiment: Show Eclipse to some friends or co-workers who haven't seen it before and ask them to guess what language it is written in. Chances are, they'll guess VB, C++, or C#, because those languages are used most often for high quality client side applications. Then watch the look on their faces when you tell them it was created in Java, especially if they are Java programmers.
Because of its unique open source license, you can use the technologies that went into Eclipse to create your own commercial quality programs. Before version 3.0, this was possible but difficult, especially when you wanted to heavily customize the menus, layouts, and other user interface elements. That was because the "IDE-ness" of Eclipse was hard-wired into it. Version 3.0 introduced the Rich Client Platform (RCP), which is basically a refactoring of the fundamental parts of Eclipse's UI, allowing it to be used for non-IDE applications. Version 3.1 updated RCP with new capabilities, and, most important, new tooling support to make it easier to create than before.
If you want to cut to the chase and look at the code for this part you can find it in the accompanying zip file. Otherwise, let's take a look at how to construct an RCP application.
Getting started
RCP applications are based on the familiar Eclipse plug-in architecture, (if it's not familiar to you, see the references section). Therefore, you'll need to create a plug-in to be your main program. Eclipse's Plug-in Development Environment (PDE) provides a number of wizards and editors that take some of the drudgery out of the process. Select File > New > Project > Plug-in Development > Plug-in Project to bring up the Plug-in Project wizard. On the subsequent pages, enter a Project name such as org.eclipse.ui.tutorials.rcp.part1, indicate you want a Java project, select the version of Eclipse you're targetting, and enable the option to Create an OSGi bundle manifest. Then click Next.
Beginning in Eclipse 3.1 you will get best results by using the OSGi bundle manifest. In contrast to previous versions, this is now the default.
In the next page of the Wizard you can change the Plug-in ID and other parameters. Of particular importance is the question, "Would you like to create a rich client application?". Select Yes. The generated plug-in class is optional but for this example just leave all the other options at their default values. Click Next to continue.
Starting with Eclipse 3.1, several templates have been provided to make creating an RCP application a breeze. We'll use the simplest one available and build up from there. Make sure the option to Create a plug-in using one of the templates is enabled, then select the Hello RCP template. This is RCP's equivalent of "Hello, world". Click Finish to accept all the defaults and generate the project. Eclipse will open the Plug-in Manifest Editor. The Plug-in Manifest editor puts a friendly face on the various configuration files that control your RCP application.
If you get a dialog asking if Eclipse can switch to the Plug-in Development Perspective click Remember my decision and select Yes (this is optional).
Taking it for a spin
Trying out RCP applications used to be somewhat tedious. You had to create a custom launch configuration, enter the right application name, and tweak the plug-ins that were included. Thankfully the PDE keeps track of all this now. All you have to do is click on the Launch an Eclipse Application button in the Plug-in Manifest editor's Overview page. You should see a bare-bones Workbench start up (see Figure 1).
Figure 1. World's simplest RCP application.
Apache Protect is a GUI utility for configuring and setting up the built-in basic authentication and access control capabilites of your local Apache Web server, pre-installed with Mac OS X.
Manually setting up user and group files, protect directories with a username, and password and set access control requires adjustments in the terminal and use of Unix commands. With this tool and its Aqua interface, the whole process is a lot easier.
Download Apache Protect (316 K) for Apple Macintosh OS 10.3 and later.
Developers.net provides links to these applications as a courtesy, and makes no representations regarding the applications or any information related thereto. Any questions, complaints or claims regarding the applications must be directed to the appropriate software vendor.
Create and modify your Python application's GUI using the easy design tool Glade; then, automate the process of setting up event handlers.
Writing GUI programs involves two basic steps. First, you need to write the code to create the interface, with elements, such as menus, and widgets, such as buttons, labels and entry fields. You then need to write the code that executes when events occur, such as when a button is pressed or a menu item is selected. When the program runs, it enters an event loop that repeatedly waits for an event and then calls the event handler, also known as a callback function, that was defined for that event. For example, you write a function to be called when a button is pressed. Writing code to display the widgets, defining the functions to be called when events occur and connecting each event to the specific function is a tedious process to do by hand.
For many widget sets, programs exist to lay out the GUI visually. Damon Chaplin wrote the Glade program to allow users to create an interface visually using the GTK/GNOME widgets and also to specify which functions to call when events occur. Glade stores the layout of the widgets and the callbacks as an XML file. Glade also generates a C or C++ program that contains all the calls to create the widgets in the specified layout, connect the callbacks and define empty functions for each callback. However, Glade does not create Python code. The GladeGen program I wrote generates Python code based on the Glade XML file.
Read the rest of this article here.
© 2004 Linux Journal
Abstract: The Eclipse Platform is designed for building integrated development environments (IDEs) that can be used to create applications as diverse as web sites, embedded Java programs, C++ programs, and Enterprise JavaBeans. This paper is a general technical introduction to the Eclipse Platform. Part I presents a technical overview of its architecture. Part II is a case study of how the Eclipse Platform was used to build a full-featured Java development environment.
Introduction
The Eclipse Platform is an IDE for anything, and for nothing in particular.
Although the Eclipse Platform has a lot of built-in functionality, most of that functionality is very generic. It takes additional tools to extend the Platform to work with new content types, to do new things with existing content types, and to focus the generic functionality on something specific.
The Eclipse Platform is built on a mechanism for discovering, integrating, and running modules called plug-ins. A tool provider writes a tool as a separate plug-in that operates on files in the workspace and surfaces its tool-specific UI in the workbench. When the Platform is launched, the user is presented with an integrated development environment (IDE) composed of the set of available plug-ins.
The quality of the user experience depends significantly on how well the tools integrate with the Platform and how well the various tools work with each other.
Part I:
The Eclipse Platform (or simply "the Platform" when there is no risk of confusion) is designed and built to meet the following requirements:
| If you build it, they will come. —W.P. Kinsella, Field of Dreams (1989) |
Platform runtime and plug-in architecture
A plug-in is the smallest unit of Eclipse Platform function that can be developed and delivered separately. Usually a small tool is written as a single plug-in, whereas a complex tool has its functionality split across several plug-ins. Except for a small kernel known as the Platform Runtime, all of the Eclipse Platform's functionality is located in plug-ins.
Plug-ins are coded in Java. A typical plug-in consists of Java code in a JAR library, some read-only files, and other resources such as images, web templates, message catalogs, native code libraries, etc. Some plug-ins do not contain code at all. One such example is a plug-in that contributes online help in the form of HTML pages. A single plug-in's code libraries and read-only content are located together in a directory in the file system, or at a base URL on a server. There is also a mechanism that permits a plug-in to be synthesized from several separate fragments, each in their own directory or URL. This is the mechanism used to deliver separate language packs for an internationalized plug-in.
Each plug-in has a manifest file declaring its interconnections to other plug-ins. The interconnection model is simple: a plug-in declares any number of named extension points, and any number of extensions to one or more extension points in other plug-ins.
A plug-in's extension points can be extended by other plug-ins. For example, the workbench plug-in declares an extension point for user preferences. Any plug-in can contribute its own user preferences by defining extensions to this extension point.
An extension point may have a corresponding API interface. Other plug-ins contribute implementations of this interface via extensions to this extension point. Any plug-in is free to define new extension points and to provide new API for other plug-ins to use.
On start-up, the Platform Runtime discovers the set of available plug-ins, reads their manifest files, and builds an in-memory plug-in registry. The Platform matches extension declarations by name with their corresponding extension point declarations. Any problems, such as extensions to missing extension points, are detected and logged. The resulting plug-in registry is available via the Platform API. Plug-ins cannot be added after start-up.
Plug-in manifest files contain XML. An extension point may declare additional specialized XML element types for use in the extensions. This allows the plug-in supplying the extension to communicate arbitrary information to the plug-in declaring the corresponding extension point. Moreover, manifest information is available from the plug-in registry without activating the contributing plug-in or loading of any of its code. This property is key to supporting a large base of installed plug-ins only some of which are needed in any given user session. Until a plug-in's code is loaded, it has a negligible memory footprint and impact on start-up time. Using an XML-based plug-in manifest also makes it easier to write tools that support plug-in creation. The Plug-In Development Environment (PDE), which is included in the Eclipse SDK, is such a tool.
A plug-in is activated when its code actually needs to be run. Once activated, a plug-in uses the plug-in registry to discover and access the extensions contributed to its extension points. For example, the plug-in declaring the user preference extension point can discover all contributed user preferences and access their display names to construct a preference dialog. This can be done using only the information from the registry, without having to activate any of the contributing plug-ins.
Read the rest of this whitepaper: click download, below.
© 2003 Object Technology International Inc.
Alias FBX is a free platform-independent 3D authoring and interchange format that provides access to 3D content from most 3D vendors and platforms. The FBX file format supports all major 3D data elements, as well as 2D, audio, and video media elements.
The FBX SDK allows software and hardware vendors to easily add support for the FBX format. The SDK is an easy-to-use C++ software development toolkit that provides conversion utilities allowing application and content vendors to transfer their existing commercial and demonstration content into the FBX format with a minimum of effort.
Download Alias FBX SDK for Macintosh, Windows 2000/XP, Iris, or Linux.
Developers.net provides links to these applications as a courtesy, and makes no representations regarding the applications or any information related thereto. Any questions, complaints or claims regarding the applications must be directed to the appropriate software vendor.
The new edition of this reference covers all aspects of the Red Hat Fedora and Enterprise Linux distribution. Full details on everything from installation and configuration to system administration and server management of Enterprise Linux—with specifics on the Linux Kernel 2.6—are included. The new IPv6 Protocol, including the network security features of IPSEC and Virtual Private Networks, are also covered. The DVD contains the entire Red Hat Fedora Core distribution—usually available on multiple CD-ROMs.
|
Red Hat Enterprise Linux and Fedora Core 4: The Complete Reference provides a comprehensive examination of all aspects of Fedora Core 4 Linux, including recent critical changes in administration such as device management, kernel configuration, and IPv6 support. In terms of coverage, The Complete Reference is currently the only true Fedora Core 4 book, providing coverage of key Fedora Core 4 and even Fedora Core 3 developments.
Other books in this class either take a different more introductory approach, or simply fail to cover key Fedora Core 4 developments. Only in this book will you find in depth discussion of key administration changes such as automatic device generation with udev, the Hardware Abstraction Layer (HAL), and kernel header management. It still remains the only text in its class that covers IPv6 topics ranging from network address auto-configuration to DNS records. In addition, there is special focus on security tools, providing dedicated chapters on SELinux, IPsec, and GPG encryption. The book remains the only text in its class to discuss Kerberos, as well as provide detailed examination of RAID and LVM file systems.
The Complete Reference also covers the latest inclusions like the Global File System, detailing the various packages you need to implement the system, as well as upcoming solutions like using the latest securitylevel development version to enable Windows share browsing on Gnome. Though comprehensive in its handling of administration topics, The Complete Reference deals just as thoroughly with user topics, with beginning chapters providing introductory material, along with in depth chapters on Gnome, KDE, and shell usage and configuration. Office, Database, Multimedia, and Internet applications like Firefox, including Windows access and video support, are also covered. Dedicated chapters examine Internet services like Web servers, proxies, DNS, and FTP.
Chapter 13, "Mail and News Clients," reviews management of mail and news clients installed with Red Hat Enterprise Linux and Fedora Core.
Get a pdf version of Chapter 13, "Mail and News Clients," from Red Hat Enterprise Linux & Fedora Core 4: The Complete Reference: click download, below.
© 2005 McGraw-Hill/Osborne Books
The word Darwin is often used to refer to the underpinnings of Mac OS X. In fact, in some circles Mac OS X itself is rarely mentioned at all. It is important to understand the distinction between the two—how they are related and how they differ.
Darwin is the core of the Mac OS X operating system. Although Darwin can stand alone as an independent operating system, it includes only a subset of the features available in Mac OS X. Figure 1-1 shows how Darwin is related to Mac OS X as a whole.
Figure 1-1 Darwin’s relation to Mac OS X
Darwin is an open source project. With it, you as a developer gain access to the foundation of Mac OS X. Its openness also allows you to submit changes that you think should be reflected in Mac OS X as a whole. Darwin has been released as a separate project that runs on PowerPC-based Macintosh computers as well as x86-compatible computers. Although it could be considered a standalone operating system in its own right, many of the fundamental design decisions of Darwin are governed by its being embedded within Mac OS X. In bringing your applications to the platform, you should target Mac OS X version 10.1.4 (Darwin 5.4) or later.
Mac OS X itself is not an Open Source project. As you can see from Figure 1-1, there are many parts of Mac OS X that are not included in the Open Source Darwin components. Part of your job while porting is deciding where your application will fit in Mac OS X.
If you are a developer whose tool is a command-line tool (or has a useful subset that is a command-line tool), you can, of course, simply port your application as a command-line tool or service, which is usually not that complicated. By doing this you gain a small benefit, in that it is now available to Mac OS X users who are familiar with the UNIX command-line environment. You will not be able to market it to Mac OS X users as a whole though, since many users do not even know how to access the command line on their computers.
Read the rest of this tutorial here.
© 2005 Apple Computer Inc.
Altova XMLSpy 2005 Home Edition is a free entry level XML development tool for designing and editing applications involving XML technologies (XML, DTD, XML Schema, XSLT 1.0/2.0, XPath 1.0/2.0, WSDL, SOAP, XQuery, and others). XMLSpy automatically generates runtime code in multiple programming languages for creating advanced XML applications, using the views and options that best suit user requirements and preferences.
XMLSpy Home Edition is suited for hobbyists, entry level developers, and students. It also supports seamless integration with Eclipse, allowing you to access the rich XML editing capabilities of XMLSpy 2005 directly within the Eclipse development environment.
Download a free copy of XMLSpy Home Edition 2005.
Deskzilla 1.0 is an alternative, desktop client application for the Bugzilla bug-tracking system, created by an independent software vendor. It is free for open-source projects.
Though Deskzilla has several new features and helps to do routine bug tracking, it isn't a full replacement for the vast Bugzilla web interface. The goal of the Deskzilla project is to explore possibilities for unique bug-tracking features that are open for a desktop application.
Deskzilla downloads bug information from Bugzilla, stores it in a local database, allows you to view and edit bugs, and uploads changes to Bugzilla.
Data exchange with Bugzilla is carried out via standard HTTP/HTML/XML interfaces. In other words, Deskzilla does the same things you do when you use web browser to work with Bugzilla, only faster.
Read more about how Deskzilla works here.
Download a copy of Deskzilla 1.0 Beta 2 here.
© 2005 The Mozilla Organization
This document is a general overview of security issues that face the administrator of Linux systems. It covers general security philosophy and a number of specific examples of how to better secure your Linux system from intruders. Also included are pointers to security-related materials and programs.
This document covers the major security issues that affect Linux security. General philosophy and net-born resources are also discussed.
A number of other HOWTO documents overlap with security issues, and those have been pointed to wherever appropriate.
This document is not meant to be an up-to-date exploits document. Large numbers of new exploits happen all the time. This document will point you where to look for such up to date information, and some general methods to prevent such exploits from taking place.
Additionally, while there are several resources available in various places on the Internet regarding general security, we are trying to consolidate much of this general information, and provide information a general system administrator can use as a practical guide. This should in no means substitute for reading books on the appropriate subject, and practical experience which works for you.
The U.S. Government has several organizations devoted to computer security, and generally the information they have online is quite extensive and very useful. A general introduction to computer security is available at csrc.ncsl.nist.gov/nistpubs/800-12/, which will be very useful.
See the References section for pointers to security references. It is also a tremendous advantage if you understand how TCP/IP works, and some of the common system administration functions. You might find this guide helpful in a beginner introduction www.sunworld.com/sunworldonline/swol-11-1995/swol-11 sysadmin.html. Though it is Solaris-centric, you'll find much of this information general enough to still be applicable.
You may also find this link helpful: www.cis.ohio state.edu/~dolske/gradwork/cis694q/ for another introduction to TCP, including how sequence numbers work, which is the foundation of man-in-the-middle attacks, a description of the SYN/ACK handshake used to initiate a TCP connection, a description of a few of the problems in TCP/IP, a few other types of attacks, and how they work, as well as some solutions to these problems.
Overview
This document will discuss procedures and commonly used software to increase the trust level of your system. It is important to discuss the basic concepts first, and create a security foundation before we get started.
Organization of this document
This document has been divided into a number of sections. They cover several broad kinds of security issues. So far these sections include:
/var/log/messages and keep an eye on your system.
Host security
Perhaps the area of most concentration on security is done with host-based security. This typically involves making sure your own system is secure, and hoping everyone else on your network does the same.
Choosing good passwords, securing your services your hosts offer, keeping good accounting records, and upgrading programs that have known security exploits are among the things the local security administrator is responsible for doing.
Although this is absolutely necessary, it can become a daunting task once your network of machines becomes larger. It can be said that host-based security does not scale. A host-based security exploit must be repaired on each machine on your network, which requires accessing each machine individually and applying the fix.
Windows and controls are two of the primary means by which users interact with Macintosh computers. Most of the information that the user sees is presented in a window, and the controls within a window let the user interact with the application.
The Window Manager and the Control Manager are the primary programming interfaces for creating and manipulating windows and controls in your application. This document describes the basic types of windows and controls, their suggested usage, and how they interact with the Carbon event model. This document also contains programming examples for creating windows and controls using Interface Builder (or by calling specific functions), sample implementations of controls, and information about how to create your own custom windows or controls.
The concepts and examples in this document assume you are building applications for Mac OS X. However, because the Window Manager and Control Manager are Carbon-compliant, many of the functions described also work with Mac OS 9. This document calls out instances where functionality is available only in Mac OS X.
'Basic Control Manipulation' describes various control manipulation functions that you may want to use in your application.
© 2005 Apple Computer Inc.
We always knew that networking would become an integral part of our future products. Not just an add-on component, but also a highly optimized addition to the core, Nucleus PLUS, itself. So, we started early in our history (when starting anything hurt!) developing what we think now, is one of the world’s best TCP/IP stacks. This white paper will walk you through the history of Nucleus NET and why, in particular, it is so much a part of our future. We will also detail some of the features that we believe make Nucleus NET a formidable challenge to other embedded TCP/IP stacks.
Introduction
In early 1992, we realized the impact that networking was beginning to have on the embedded market. Companies like Wind River Systems and Integrated Systems were making great strides in providing embedded software primarily due to their integration with Internet protocols. We examined the offerings from these two companies and found that they were in general too cumbersome for the embedded market.
This is due to the fact that they are re-worked versions of BSD (a free version of the TCP/IP networking stack developed by the University of California at Berkeley). We then launched a search into possible foundational technology that we could modify to meet the needs of a growing market that simply needed to be connected to a capable network. We chose NCSA telnet for our foundational technology.
The NCSA code worked and was fairly simple to understand; unfortunately, it was originally developed as a single tasking, non-real-time environment. We then began replacing much of the internal structure of the stack to tightly integrate it with our real-time kernel. The purpose of this integration was twofold. First, we wanted it to be efficient. Secondly, we wanted its priority to be easily manipulated so that it would fit into the real-time scheme of an embedded system. To date, the greatest advantage of Nucleus NET over all other networking packages is its unique fit into the Nucleus PLUS real-time environment. Networking functionality in embedded systems that employ Nucleus PLUS and Nucleus NET can be relegated to whatever priority makes sense for your application.
How Nucleus NET works
In the process of developing Nucleus NET, we paid very close attention to well-structured code that is easy to read and understand. Nucleus NET's basic TCP, UDP, IP, ICMP, etc. is a highly versatile protocol stack that is small in size and quick in execution. It behaves seamlessly within a multi-tasking environment and takes advantage of some of Nucleus PLUS's unique features (like suspending on a queue for a timeout) to enhance the timing characteristics of the stack. This further enhances the real-time environment supported by Nucleus NET. Extreme caution has been taken to avoid excessive operating system overhead. Tasks, therefore, spend very little time in the stack itself. It is efficient in handling time consuming processes such as check summing and data copies. This is especially necessary when slower processors are expected to maintain extremely high data rates.
Read the rest of this whitepaper here (pdf).
© 2004 Mentor Graphics Inc.
These -m options are defined for the IBM RS/6000 and PowerPC:
|
GCC supports two related instruction set architectures for the RS/6000 and PowerPC. The POWER instruction set are those instructions supported by the rios chip set used in the original RS/6000 systems and the PowerPC instruction set is the architecture of the Motorola MPC5xx, MPC6xx, MPC8xx microprocessors, and the IBM 4xx microprocessors.
Neither architecture is a subset of the other. However there is a large common subset of instructions supported by both. An MQ register is included in processors supporting the POWER architecture.
You use these options to specify which instructions are available on the processor you are using. The default value of these options is determined when configuring GCC. Specifying the -mcpu=cpu_type overrides the specification of these options. We recommend you use the -mcpu=cpu_type option rather than the options listed above.
The -mpower option allows GCC to generate instructions that are found only in the POWER architecture and to use the MQ register. Specifying -mpower2 implies -power and also allows GCC to generate instructions that are present in the POWER2 architecture but not the original POWER architecture.
The -mpowerpc option allows GCC to generate instructions that are found only in the 32-bit subset of the PowerPC architecture. Specifying -mpowerpc-gpopt implies -mpowerpc and also allows GCC to use the optional PowerPC architecture instructions in the General Purpose group, including floating-point square root. Specifying -mpowerpc-gfxopt implies -mpowerpc and also allows GCC to use the optional PowerPC architecture instructions in the Graphics group, including floating-point select.
The -mpowerpc64 option allows GCC to generate the additional 64-bit instructions that are found in the full PowerPC64 architecture and to treat GPRs as 64-bit, doubleword quantities. GCC defaults to -mno-powerpc64.
If you specify both -mno-power and -mno-powerpc, GCC will use only the instructions in the common subset of both architectures plus some special AIX common-mode calls, and will not use the MQ register. Specifying both -mpower and -mpowerpc permits GCC to use any instruction from either architecture and to allow use of the MQ register; specify this for the Motorola MPC601.
Read the rest of this chapter (pdf).
© 2005 Apple Computer Inc.
To the outside world, a "supercomputer" appears to be a single system. In fact, it's a cluster of computers that share a local area network and have the ability to work together on a single problem as a team. Many businesses used to consider supercomputing beyond the reach of their budgets, but new Linux applications have made high-performance clusters more affordable than ever. These days, the promise of low-cost supercomputing is one of the main reasons many businesses choose Linux over other operating systems.
This new guide covers everything a newcomer to clustering will need to plan, build, and deploy a high-performance Linux cluster. The book focuses on clustering for high-performance computation, although much of its information also applies to clustering for high-availability (failover and disaster recovery). The book discusses the key tools you'll need to get started, including good practices to use while exploring the tools and growing a system. You'll learn about planning, hardware choices, bulk installation of Linux on multiple systems, and other basic considerations. Then, you'll learn about software options that can save you hours—or even weeks—of deployment time.
Since a wide variety of options exist in each area of clustering software, the author discusses the pros and cons of the major free software projects and chooses those that are most likely to be helpful to new cluster administrators and programmers. A few of the projects introduced in the book include:
Download Chapter 10, Management Software, from High Performance Linux Clusters with OSCAR, Rocks, OpenMosix, and MPI: click download, below.
© 2005 O'Reilly Media, Inc.
Many developers are justifiably cautious about programming in the kernel. A decision to program in the kernel is not to be taken lightly. Kernel programmers have a responsibility to users that greatly surpasses that of programmers who write user programs.
You should avoid programming in the kernel
Kernel code must be nearly perfect. A bug in the kernel could cause random crashes, data corruption, or even render the operating system inoperable. It is even possible for certain errant operations to cause permanent and irreparable damage to hardware—for example, by disabling the cooling fan and running the CPU full tilt.
Kernel programming is a black art that should be avoided if at all possible. Fortunately, it usually is unnecessary. You can write most software entirely in user space. Even most device drivers (FireWire and USB, for example) can be written as applications, rather than as kernel code. A few low-level drivers must be resident in the kernel's address space, however, and this document might be marginally useful if you are writing drivers that fall into this category.
Though parts of this document are useful in driver writing, this is not a document about writing drivers. In Mac OS X, you write device drivers using the I/O Kit. Though this document covers the I/O Kit at a conceptual level, the details of I/O Kit programming are beyond the scope of this document. Driver writers are encouraged to read Inside Mac OS X: I/O Kit Fundamentals for detailed information about the I/O Kit.
This document covers most aspects of kernel programming with the exception of device drivers. Covered topics include scheduling, virtual memory pagers and policies, Mach IPC, file systems, networking protocol stacks, process and thread management, kernel security, synchronization, and a number of more esoteric topics.
© 2004 Apple Inc.
Eclipse was originally designed for building integrated development environments that were versatile enough to create applications for a range of programming languages. The intention was to provide tools makers with an IDE that would include mechanisms and rules that would consistently result in seamless tools integration. Since then, Eclipse has evolved to include an IDE that provides benefits for a wide range of development projects.
Because it is Java-based, Eclipse includes the Java Development Kit; and yet its architecture supports all major programming languages from C/C++ to Cobol.
Eclipse is a free download, and is available on a number of platforms. Since IBM launched Eclipse in November 2001, more than 18 million download requests have been logged from over 125 countries.
A growing consortium of high-profile companies and organizations are actively supporting and extending Eclipse's ongoing development and giving the platform momentum. These organizations contribute support and technology, and they determine the direction and scope of Eclipse's growth.
Highly extensible
Because it is a highly extensible, open framework, Eclipse allows you to use—and create your own—plug-in tools to extend the basic Eclipse IDE for developing your applications.
This means that if you are developing an application using Eclipse for Mac OS X, and you need a special tool to facilitate development on your project, you can choose from literally hundreds of available plug-in tools that work seamlessly with Eclipse and with any of the plug-in tools you are using.
These plug-ins, which have been developed by a wide variety of companies and individuals, run the gamut from traditional coding tools such as source code analyzers, graphical layout tools, and compilers to productivity enhancers like bug trackers, source code managers, and even games. When you download and unzip the plug-in tools, they are automatically integrated into the Eclipse framework enabling you to create high-quality applications in less time.
Eclipse's architecture has fostered a worldwide community of plug-in developers. As more plug-ins are created that address the entire development cycle, Eclipse becomes increasingly useful, and popular.
The range of plug-ins is amazing. One biotech consultant uses the Jmechanic plug-in, saying, "our clients could quickly identify many performance problems, and could then decide whether it was something they wanted to fix, outsource, or live with." Using the Eclipse plug-in saved licensing costs, and gave each developer on their team the freedom to run a time profile before checking in their code.
Another developer uses Eclipse as his primary IDE, and says, "the Sysdeo Tomcat launcher plug-in is essential for my daily work, because it allows me to do runtime debugging of my web application from within Eclipse."
Figure 1 shows the Eclipse user interface on Mac OS X, with an open example of a sample plug-in project.
Figure 1: Eclipse User Interface on Mac OS X
Speeds developmentEclipse's features are well implemented and very effective, and are designed to increase the speed of the development cycle by automating tedious tasks that distract you from coding.
Other strengths include built-in CVS integration that makes it convenient to synchronize code with the CVS server. One Eclipse user says, "the Synchronize view makes it easy to merge changes and view changes before I decide to update. The Annotation view allows me to determine when each line of a file was added and who added it. This feature is great for tracking down bugs."
In Part One I introduced Eiffel and talked about is basic language constructs. In Part Two we explored some more advanced language features. It's now time for the big bucks: Design by Contract (DbC).
Intended audience. In order to make the most of these tutorials, you should not only know how to code in some Object Oriented programming language (like C#), but also understand the basic theory of OO design (inheritance, polymorphism, and so on). Make sure you brush up on that before you begin. Reading the tutorials in order also helps :)
In this tutorial I will talk about software correctness and how it can be more easily achieved in Eiffel using assertions and contracts.
References. Like the other times, I've used the documentation in Eiffel ENViSioN! to get examples and ideas. There's more detail there if you wish to continue you Eiffel development days.
Software Correctness
Ok, so no one likes bugs. The problem with writing correct software is that a piece of software is correct if, and only if, it does exactly what it is supposed to. The problem is one of details. If you are 100 percent exact, you almost end up writing the software, and if you handwave, you'll miss important cases. How then to make correctness feasible?
Many formal ways of specifying correctness (or, equivalently, functionality) have been devised, but the problem is that once you write your code, they are in their nice binder and if you didn't respect them no one may notice any soon. Pre- and post- conditions inserted in comments cannot be enforced, so if you want to make sure they hold you have to check them at BOTH and the client and the supplier. This makes your code inefficient and prone to even more errors.
The solution is adding these details in the code itself, so the compiler will enforce them for you. And not as normal code, but recognized as such, which also makes them easy to disable once you trust that your software works. You want to do this module-by-module because you want each module to be correct within itself (respect its postcondition) AND being able to trust its clients (because they are respecting their pre-conditions). For more details on the motivation and theory behind this, as well as for becoming an expert in everything object-oriented, I highly recommend Bertrand Meyer's classic booksr Object-Oriented Software Construction.
So DbC is this: a formal way to tell the Eiffel compiler what are your expectations and guarantees regarding a module (always a class in Eiffel), and having the compiler enforce them. The model is still based around preconditions and postconditions, but now you have a way to express these in mathematical (so also logical) notation.
In case you're rusty about this, a precondition is a statement (about something like a parameter) that has to be true when a routine is entered (like that x is positive before calling sqrt(x)). The postcondition is a statement about what the return value (or side-effect, but that's hard to pin down) should be (like sqrt(x)*sqrt(x) = x). Also of notice, the class invariant is a statement always true about the class (doesn't apply to routines, you need data for it to make sense); this is of course the "stable state" of the class, so it must be true at the end of your methods (or when your class is available to be used) not while you're playing around within them (for example if you have an array with an iterator, the iterator position is always >0). If you studied Abstract Data Structures, you may know that specifying these properties is enough to define the behavior of a class, for example you can write, say, a stack in Prolog just by coding these logic rules. So Eiffel turns out as a great language for BOTH designing and programming.
Let's see how to do this in practice.
Assertions
Each routine in Eiffel can contain an assertion for a precondition and one for a postcondition. Assertions are Boolean statements (i.e. they are either true or false), and are composed by Boolean clauses that are ANDed togheter (in logic jargon, they are in conjunctive normal form, or CNF).
Assertions give you the power of both a if-then statement (which you would need to verify them) and a try-catch block (which you will need to handle errors). We saw last time how the "rescue" keyword can be used to recover from a false assertion.
In Eiffel preconditions are introduced by the require keyword, and postcondition by the ensure keyword. As most the keywords in Eiffel, these do a lot to improve readability. Each line after the keyword is a clause, and each clause has two parts separated by a colon: an identifier with a name for the clause (again at least for readability, but also to reference to it), and the Boolean expression iself. For example:
ensure
item_count_increased: item_count = old item_count + 1
» next
In Part One I introduced Eiffel and talked about is basic language constructs. As promised, I'm back for more.
Intended audience. In order to make the most of these tutorials, you should not only know how to code in some Object Oriented programming language (like C#), but also understand the basic theory of OO design (inheritance, polymorphism, and so on). Make sure you brush up on that before you begin. Reading the tutorials in order also helps :)
In this tutorial I will explain how inheritance in Eiffel works and you'll see how it's a very robust implementation (more so than C++ or Java/C#). I'll also talk a about genericity and exception handling in Eiffel.
Note: In the first tutorial I said I would cover Design by Contract here, but as I was working on this, I noticed the tutorial is already very long without it, so I couldn't cover it very well. Since Design by Contract is the strongest feature of Eiffel, I decided to add some more language functionalities to this part and talk about Design by Contract in its fully glory and complexity in the whole Part Three. I'm not trying to post more tutorials; as you can see this tutorial is still very long and rich.
References. Like last time, I've used the documentation in Eiffel ENViSioN! to get examples and ideas. There's more detail there if you wish to continue you Eiffel development days.
Inheritance
Inheritance and client/supplier (also called composition) are the two relationships that can exist between classes. We saw composition at work last time, when we could define class attributes. I'll assume you know what inheritance is all about (as I mentioned in the "Intended audience" note), and let's see how it works in Eiffel.
First things first: Eiffel supports multiple implementation inheritance, so it has no need for Interfaces as special cases. Most people don't seem to like multiple inheritance, but you'll see that Eiffel implements in a very amicable manner, and it will be your friend.
As I mentioned last time, in Eiffel abstract (i.e., non-instantiable) classes are called deferred. Interfaces are classes in which every feature is deferred (or pure abstract in C++ terminology). So if you have a deferred class called Comparable, you can inherit from it like you would implement an interface, and just implement the features. Type conformance tells us that this is identical to using interfaces.
But since we can, Comparable does not have to be completely deferred. Look at this example ("Current" is like "this" in C++):
|
|
Java 2 Platform, Standard Editions 1.4.1 for Mac OS X represents the evolution of many years of work by Apple to integrate Java with the OS X operating system. Java 1.4.1 for Mac OS X addresses both integration with J2SE and integration into the native operating system—and is much more integrated into the operating system than any previous release of Java.
J2SE is a platform in and of itself. Many design decisions made there do not fit completely with the design decisions in Mac OS X. The result is that there are some differences between Java in Mac OS X and Java on other platforms. This document attempts to highlight those differences, so you can spend your time writing applications, not trying to figure out why something doesn't work the way you think it should.
Want to know more? Click download, below.
© 2003 Apple Computer Inc.
This O'Reilly book is an introduction to the wireless technologies supported by Linux and how to install and configure them for different scenarios. You'll also learn how to get Wi-Fi running on a laptop, how to use Linux to create your own access point, and how to deal with cellular networks, Bluetooth, and Infrared, and more. Read Chapter 3 here.
Click on download, below.
This document discusses anti-spam philosophies from a variety of perspectives and provides information about available options for dealing with spam if you're sick of spam and want it to go away now.
Who should be reading this document
This document could be useful for:
For a more thorough explanation of the issues here, I recommend reading the IETF Anti Spam Recommendations. David E. Sorkin has produced an excellent document called Technical and Legal Approaches to Unsolicited Electronic Mail.
Specific issues of policy
Anyone dealing with spam prevention will have to make definite and impacting decisions about the following issues:
by Ben Laurie, Apache core team and board member and OpenSSL core team member. OpenSSL.
Apache-SSL is a secure Web server, based on Apache and SSLeay OpenSSL. It is licensed under a BSD-style license, which means, in short, that you are free to use it for commercial or noncommercial purposes, so long as you retain the copyright notices. This is the same license as used by Apache from version 0.8.15.
Main features
Apache-SSL source patches can be found on the following UK master distribution sites:
and additional FTP mirrors at:
The patches must be applied to the Apache source, and the result compiled and linked with SSLeay or OpenSSL. The modified source will still compile a standard Apache as well as Apache-SSL.
Keeping up to date
The best way to become aware of upgrades is to join the announce Mailing List, where new versions are announced.
The Open Scripting Architecture is an API that provides a standard mechanism for creating scriptable applications and for writing scripting components to implement scripting languages.
This guide helps developers bring applications written for UNIX-based operating systems to Mac OS X. It discusses some of the design decisions as well as some of the concerns. It also points out some of the advanced features of Mac OS X not available in traditional UNIX applications that you can add to your ported apps.
| « March 2010 | ||||||
| Su | Mo | Tu | We | Th | Fr | Sa |
1 |
2 |
3 |
4 |
5 |
6 |
|
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
18 |
19 |
20 |
21 |
22 |
23 |
24 |
25 |
26 |
27 |
28 |
29 |
30 |
31 |
|||
 SOFTWARE DEVELOPMENT HOME TECH JOBS ARTICLES DOWNLOADS SOLUTIONS TUTORIALS WHITEPAPERS NEWS MY PROFILE SEARCH TOP SEARCHES HOT JOBS ALLIANCES FEEDBACK SUBMIT CONTENT Sitemaps: Main Sitemap Content Sitemap Jobs Sitemap Searches Sitemap Thawteshowcase Sitemap Ibmshowcase Sitemap Appdevshowcase Sitemap Tippitshowcase Sitemap Oracleshowcase Sitemap Ciscoshowcase Sitemap Skillsoftshowcase Sitemap Enterprisedbshowcase Sitemap Intelisdshowcase Sitemap Compuwareshowcase Sitemap Quinstreetshowcase Sitemap Sunicshowcase Sitemap Sunebshowcase Sitemap Numarashowcase Sitemap Novellshowcase Sitemap Intelisnshowcase Sitemap Businessobjectsshowcase Sitemap Quintumshowcase Sitemap Intelmcshowcase Sitemap Tradepubshowcase Sitemap Motorolashowcase Sitemap Businessobjectsitshowcase Sitemap Mumshowcase Sitemap Sunkoreanshowcase Sitemap Cardiffshowcase Sitemap Businessobjectsedushowcase Sitemap Partner Sites: | DEMOCRASAY | TAPESTRY INTELLIGENCE |
|
| « March 2010 | ||||||
| Su | Mo | Tu | We | Th | Fr | Sa |
1 |
2 |
3 |
4 |
5 |
6 |
|
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
18 |
19 |
20 |
21 |
22 |
23 |
24 |
25 |
26 |
27 |
28 |
29 |
30 |
31 |
|||
|
SOFTWARE DEVELOPMENT HOME TECH JOBS ARTICLES DOWNLOADS SOLUTIONS TUTORIALS WHITEPAPERS NEWS MY PROFILE SEARCH TOP SEARCHES HOT JOBS ALLIANCES FEEDBACK SUBMIT CONTENT Sitemaps: Main Sitemap Content Sitemap Jobs Sitemap Searches Sitemap Thawteshowcase Sitemap Ibmshowcase Sitemap Appdevshowcase Sitemap Tippitshowcase Sitemap Oracleshowcase Sitemap Ciscoshowcase Sitemap Skillsoftshowcase Sitemap Enterprisedbshowcase Sitemap Intelisdshowcase Sitemap Compuwareshowcase Sitemap Quinstreetshowcase Sitemap Sunicshowcase Sitemap Sunebshowcase Sitemap Numarashowcase Sitemap Novellshowcase Sitemap Intelisnshowcase Sitemap Businessobjectsshowcase Sitemap Quintumshowcase Sitemap Intelmcshowcase Sitemap Tradepubshowcase Sitemap Motorolashowcase Sitemap Businessobjectsitshowcase Sitemap Mumshowcase Sitemap Sunkoreanshowcase Sitemap Cardiffshowcase Sitemap Businessobjectsedushowcase Sitemap Partner Sites: | DEMOCRASAY | TAPESTRY INTELLIGENCE | |