Add to Favorites    Make Home Page 11204 Online  
 Language Categories  
 Our Services  
 Home  


Development
Java » Tips and Tutorials » Development

A D V E R T I S E M E N T

Search Projects & Source Codes:


  • Data Management in J2EE Apps - Free
    This article examines two data management strategies available on the Java platform: Java object serialization and Java Database Connectivity (JDBC). While neither data management strategy is inherently superior or inferior to the other, when it comes to managing enterprise information systems, JDBC wins hands down.
  • 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.
  • Annotations in Tiger (J2SE 5.0)
    Annotations, a new feature in J2SE 5.0 (Tiger), brings a much-needed metadata facility to the core Java language. In this first of a two-part series, author Brett McLaughlin explains why metadata is so useful, introduces you to annotations in the Java language, and delves into Tiger's built-in annotations. Part 2 covers custom annotations.
  • Unclogging Server Bottlenecks w/ Active Containers - Free
    In server-side control architectures a majority of the control events must be handled on the server side to update the state of the control. For every user event, the entire page data is sent back to the server as part of the form submission, even data that has not changed or is not affected by the user event. This article shows you how to use containers to overcome data-processing redundancy, which can otherwise drain the life out of your handheld or Web server.
  • Java Performance Tuning w/ Fat Clients
    Tuning isn't always about speed, sometimes other aspects of the application need fixing. When your application needs tuning, your first course of action is normally to monitor the application with a profiler. But profiling is not always practical -- sometimes for ironic reasons. In this installment of Eye on performance, Jack Shirazi and Kirk Pepperdine, Director and CTO of Java Performance Tuning relate their recent experiences with profiling a fat client -- so fat, in fact, that it left no room for a profiler.
  • Tracing in a Multithreaded, Multiplatform Environment - Free
    Most Java programmers use some kind of tracing system to keep track of potential errors and problems in code under development. However, multithreaded and multiplatform systems can generate a large and baffling amount of tracing data. This article offers tips that will help you make sense of trace data from complex applications.
  • Using Aspect-Oriented Programming to Maintain Legacy Java Apps - Free
    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.
  • 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.
  • 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.
  • 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.
  • Implementing lazy load design pattern using dynamic proxy
    In P of EAA, Martin Fowler explains the Lazy Load pattern. In essence, this is the design pattern where you do not load all the data from the database initially, but fetch the data on demand, lazily. The advantage of this way of implementing this is that you do not fetch unnecessary data, but only fetch data as the demand arises. Martin Fowler explains various ways to implement this lazy load functionality. One of the approaches he mentions is using the Virtual Proxy pattern. Java has a very powerful implementation of the Virtual Proxy pattern from the 1.3 specification called the Dynamic Proxy. This document explains how to leverage on the Dynamic Proxy classes to implement a generic LazyLoader that can be used across multiple types of objects.
  • 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.
  • 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.
  • 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.
  • 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.
  • 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.
  • 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.
  • 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 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
    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.

  • Page 1   Page 2  

    A D V E R T I S E M E N T




    Google Groups Subscribe to SourceCodesWorld - Techies Talk
    Email:

    Free eBook - Interview Questions: Get over 1,000 Interview Questions in an eBook for free when you join JobsAssist. Just click on the button below to join JobsAssist and you will immediately receive the Free eBook with thousands of Interview Questions in an ebook when you join.

     Advertisements  

    Google Search

    Google

    Source Codes World.com is a part of Vyom Network.

    Vyom Network : Web Hosting | Dedicated Server | Free SMS, GRE, GMAT, MBA | Online Exams | Freshers Jobs | Software Downloads | Interview Questions | Jobs, Discussions | Placement Papers | Free eBooks | Free eBooks | Free Business Info | Interview Questions | Free Tutorials | Arabic, French, German | IAS Preparation | Jokes, Songs, Fun | Free Classifieds | Free Recipes | Free Downloads | Bangalore Info | Tech Solutions | Project Outsourcing, Web Hosting | GATE Preparation | MBA Preparation | SAP Info | Software Testing | Google Logo Maker | Freshers Jobs

    Sitemap | Privacy Policy | Terms and Conditions
    Copyright ©2003-2019 SourceCodesWorld.com, All Rights Reserved.
    Page URL: http://www.sourcecodesworld.com/scripts/Development-414/Default.asp


    Download Yahoo Messenger | Placement Papers | Free SMS | C Interview Questions | C++ Interview Questions | Quick2Host Review