Advertisements
 
 Advertisements
financeappsios puzzlegamesios musicappsios

Development

Introducing Scripting Variables in JSP Tags.  Introducing Scripting Variables in JSP Tags.

 This is a tutorial about JSP tags that explains the scripting variables and its uses. As described by this article, the scripting variables are page level variables, which are declared by JSP tags. This article includes an online demo and detailed description about Java class (which implements Tag interface), Java class (which extends TagExtraInfo class), Tag Library Descriptor, JSP page (which calls the Tag) and the Summary....

How to use Java 5's built-in annotations  How to use Java 5's built-in annotations

 This is an useful tutorial for the programmers to learn about java classes and the terminologies involved in generating them with annotations. The author has given a brief explanation on the definition of metadata, code analysis, compiler checking etc., and gives an introduction for annotations of java. Besides these you will also come to know how to create java class and to define it as a annotation type, the method of using metadata in documenting, code checking, compiling etc.,...
Tags: create, java, code, using, learn, class, tutorial, compiler, checking, metadata, author, for, useful, method,

Unclogging Server Bottlenecks with Active Containers  Unclogging Server Bottlenecks with Active Containers

 Developers who develops the server side component are unaware of the environment in which their component is going to be utilized. While each and every page has a number of other components, the composite control component will be the main cause for data redundancy which increases the burden of the web servers. This tutorial can be used by the programmers to avoid the problem of repettition of data processing....

Lazy load using dynamic proxy  Lazy load using dynamic proxy

 Lazy load is a design pattern in which the data items are retrieved from the database only on demand. In this tutorial, the author describes the use of Java's powerful dynamic proxy pattern to design this lazy load mechanism. The author explains about dynamic proxy, and provides example codes for implementing dynamic proxy class and for specifying the interfaces that represent the persisting data....

Introducing the Reflexive User Interface Builder  Introducing the Reflexive User Interface Builder

 The IBM Reflexive User Interface Builder (RIB), a new technology available from alphaWorks, is an application and toolkit for building and rendering Java AWT/Swing and Eclipse SWT GUIs. RIB specifies a flexible and easy-to-use XML markup language for describing Java GUIs and provides an engine for creating them. You can use RIB to test and evaluate basic GUI layout and functionality, or to create and render GUIs for an application....
Tags:

Working with preferences: the Preferences API Specification  Working with preferences: the Preferences API Specification

 The addition of the java.util.prefs package to Java 1.4 (through JSR 10) lets you manipulate user preference data and configuration data by providing you with access to an implementation-specific registry (for example, the Windows Registry on Windows platforms). This article introduces you to the Preferences class and walks you through its use. It puts it all together with a sample program....

Improve the performance of your Java code  Improve the performance of your Java code

 Many algorithms are expressed most concisely as tail-recursive methods. Compilers can automatically transform such methods into loops and thereby improve program performance, but this transformation is not required by the Java language specification, so not all JVMs will perform it. This means that tail-recursive methods in the Java language can result in unexpectedly large memory usage. This article demonstrates that dynamic compilation maintains the language`s semantics while static compilation often doesn`t. Learn why this matters and get a bit of code to help you determine whether your just-in-time (JIT) compiler can transform tail recursion on code while preserving semantics....

Demystifying Extreme Programming: Just-in-time design  Demystifying Extreme Programming: Just-in-time design

 People who aren`t familiar with XP are bothered by the concept of just-in-time (JIT) design -- designing and implementing what you know you need right now and not worrying about future design issues until absolutely necessary. While this approach might seem unwise or even reckless, XP advocate Roy Miller wraps up his series by showing you how safe and easy JIT design is -- and how it just might revolutionize the way you write code....
Tags:

Mash that trash -- Incremental compaction in the IBM JDK Garbage Collector  Mash that trash -- Incremental compaction in the IBM JDK Garbage Collector

 This article discusses incremental compaction, a new feature in the memory management component of IBM JDK 1.4.0. Incremental compaction is a way of spreading compaction work across different garbage collection cycles, thereby reducing pause times. The authors discuss the need for incremental compaction, the compaction phases at a high level, and some runtime parameters. They also explain how to interpret changes in the verbosegc output....

Exploiting ThreadLocal to enhance scalability  Exploiting ThreadLocal to enhance scalability

 The ThreadLocal class appeared with little fanfare in version 1.2 of the Java platform. While support for thread-local variables has long been a part of many threading facilities, such as the Posix pthreads facility, the initial design of the Java Threads API lacked this useful feature. Further, the initial implementation was quite inefficient. For these reasons, ThreadLocal gets relatively little attention, but it can be very handy for simplifying the development of thread-safe concurrent programs. This article examines ThreadLocal and offers tips for exploiting its power....

Concurrent programming in the Java language  Concurrent programming in the Java language

 One of the most important features of the Java language is support for multithreaded (also called concurrent) programming. This tutorial introduces you to the proper use of multiple threads in a Java program, using sample programs to illustrate these concepts. Before taking this course, you should have a general knowledge of Java programming; the context and level of knowledge used in this tutorial is the equivalent of an undergraduate operating systems course....

Java programming code page considerations  Java programming code page considerations

 Every Java programmer should be aware of the problem of code pages vs. Java Unicode. This article describes some pitfalls to avoid with code page and Unicode conversions and provides example fixes for the problems. Armed with this informaion, you should be able to create applications that are more truly platform and code page independent....

Threading lightly : Reducing contention  Threading lightly : Reducing contention

 While it`s common to hear that synchronized method calls can be 50 times as expensive as unsynchronized method calls, these numbers can actually be quite misleading. With each successive JVM version, overall performance has improved, and the cost of uncontended synchronization has been reduced, making the issue of uncontended synchronization overhead less significant. Contended synchronization, however, is quite expensive. Moreover, a high degree of contention is disastrous for scalability -- an application that had a high degree of contended synchronization will exhibit markedly worse performance as the load increases. This article explores several techniques for reducing contention, and hence improving scalability, in your programs....

Diagnosing Java code: The case for static types  Diagnosing Java code: The case for static types

 Love or hate it, static type checking can make code more robust. Programming languages are moving away from static type checking, but it is too powerful a debug resource to abandon. Static type checking can be one of the key weapons in a powerful arsenal against introducing and for detecting bugs. This article explains why we should be glad that the Java language supports it, and discusses how it can be made even better....

Diagnosing Java Code : The Orphaned Thread bug pattern  Diagnosing Java Code : The Orphaned Thread bug pattern

 In multithreaded code, it is often common to use a single, master thread that drives the actions the other threads take. This master thread may send messages, often by placing them on a queue, that are then processed by the other threads. But if the master thread throws an exception, the remaining threads may continue to run, awaiting more input to the queue, causing the program to freeze. This article discusses detecting, fixing, and avoiding this bug pattern....

Diagnosing Java Code: The Impostor Type bug pattern  Diagnosing Java Code: The Impostor Type bug pattern

 When special tags in fields are used to distinguish between types of objects, errors are possible in which a tag mislabels the associated data -- a bug pattern known as the Impostor Type. This article examines the symptoms and causes of this bug, defines ways to prevent this error from occurring, and discusses a tempting hybrid implementation that does not use impostor types but, in the end, turns out to have many of the same weaknesses. Article includes code snipets....

Scaling Web services and applications with JavaGroups  Scaling Web services and applications with JavaGroups

 As the J2EE platform has matured, it has opened up the opportunity to deploy commodity servers in networked cluster configurations for scaling of Web services and Web applications at the Web tier. These commodity servers, interconnected through commodity LAN hardware, can provide cost-effective clustering solutions. The last piece of the clustering puzzle is in the software. In this seriesSing Li examines three open source software substrates that can enable high-impact Web tier clustering, beginning with JavaGroups....

How to lock down your Java code  How to lock down your Java code

 You inevitably spend some part of your week crunching code that you didn`t write, and for which you may not have the source. This beginner`s guide to opening up and locking down Java code walks you through the essentials of disassembling, decompiling, and obfuscating Java code, using examples from popular tools such as Mocha, HoseMocha, jmangle, and JODE....

Weighing in on Java native compilation  Weighing in on Java native compilation

 Learn the pros and cons of generating native code from Java source. This article includes the basics of code compilation, including a brief overview of why many developers are employing Java native compilers for their applications....

Using Aspect-Oriented Programming to Maintain Legacy Java Apps  Using Aspect-Oriented Programming to Maintain Legacy Java Apps

 In an enterprise environment, you can easily end up in a tangle of modules with a number of third-party libraries and frameworks. While a number of tools are available to aid you in comprehending complex programs, most are expensive and time-consuming to learn. Aspect-oriented programming can be applied to a wide range of programming scenarios, including the comprehension and maintenance of legacy applications....

 

 

Pages :  1 2