Filter by products, topics, and types of content

(0 Products)

(119 Topics)

(3 Industries)

(6 Types)

1 - 70 of 70 results
Show Summaries | Hide Summaries
View Results
Title none Date down
Java.next: Choosing your next JVM language
Any of the Java.next languages is a suitable candidate for your next language, so how do you choose? Investigate the factors that contribute to this important decision.
Also available in: Chinese   Russian   Japanese  
13 May 2014
Java.next: Functional coding styles
All of the Java.next languages include functional programming constructs, which enable you to think at a higher level of abstraction. However, differences in terminology among the languages can make it difficult to see similar constructs. This installment shows how common functional programming constructs manifest in the Java.next languages, pointing out some subtle differences in the implementation details of those features.
Also available in: Chinese   Russian   Japanese   Portuguese  
24 Dec 2013
Java.next: Currying and partial application
All of the Java.next languages include currying and partial application but implement them in different ways. This installment explains both techniques, distinguishes between them, and shows implementation details -- and practical uses -- in Scala, Groovy, and Clojure.
Also available in: Chinese   Russian   Japanese  
26 Nov 2013
Java.next: Mixins and traits
The Java language's primary paradigm, object orientation with single inheritance, effectively models most but not all programming problems. The Java.next languages extend this paradigm in various ways, including mixins and traits. This Java.next installment defines the mechanisms that mixins and traits share, and it delves into the subtle differences between mixins in Groovy and traits in Scala.
Also available in: Chinese   Russian   Japanese  
19 Sep 2013
Java.next: Extension without inheritance, Part 1
Groovy, Scala, and Clojure offer many extension mechanisms, whereas inheritance is virtually the Java language's only option. This installment looks at category classes, the ExpandoMetaClass, implicit casts, and protocols as ways to extend Java classes with the Java.next languages.
Also available in: Chinese   Russian   Japanese  
12 Jun 2013
Java.next: Common ground in Groovy, Scala, and Clojure, Part 1
The Java.next languages (Groovy, Scala, and Clojure) have more commonalities than differences, converging toward common ground in many of their features and conveniences. This installment explores how they each address a longstanding deficiency in the Java language -- the inability to overload operators. It also discusses the related concepts of associativity and precedence.
Also available in: Chinese   Russian   Japanese  
14 May 2013
Java.next: The Java.next languages
This article launches a new developerWorks series by Neal Ford that performs a deep comparison of three next-generation JVM languages: Groovy, Scala, and Clojure. In this initial installment, find out what you'll gain from understanding their similarities and differences -- whether or not you choose to keep using Java as your main programming language for now.
Also available in: Chinese   Russian   Japanese  
14 May 2013
Functional thinking: Why functional programming is on the rise
Java developers should learn functional paradigms now, even if they have no immediate plans to move to a functional language such as Scala or Clojure. Over time, all mainstream languages will become more functional; Neal Ford explores the reasons why in this installment.
Also available in: Chinese   Russian   Japanese  
29 Jan 2013
Functional thinking: Laziness, Part 2
Implementing lazy evaluation is easy in a language that supports closures. This Functional thinking installment shows how to derive a lazy list using Groovy's closures as building blocks. Then it explores some of the performance and conceptual benefits of lazy evaluation, including the ability to initialize fields lazily in some languages.
Also available in: Chinese   Russian   Japanese  
19 Dec 2012
Functional thinking: Laziness, Part 1
A common feature of many functional programming languages is lazy evaluation, whereby expressions are evaluated only when necessary rather than upon declaration. Java doesn't support this style of laziness, but several frameworks and related languages do. This article shows how to build laziness into your Java applications, using pure Java and functional frameworks.
Also available in: Chinese   Russian   Japanese  
20 Nov 2012
Functional thinking: Transformations and optimizations
Various functional languages and frameworks feature many of the same abstractions and behaviors but name them differently. In this Functional thinking article, series author Neal Ford optimizes the solution from the preceding installment by improving the algorithm and adding caching, illustrating how each language or framework accommodates the required changes.
Also available in: Chinese   Russian   Japanese  
16 Oct 2012
Functional thinking: Tons of transformations
Functional programming constructs are appearing in all major languages now, but they can be hard to spot because they're identified by a wide variety of common names. This installment of Functional thinking shows the same example written using seven different functional frameworks and languages, investigating similarities and differences.
Also available in: Chinese   Russian   Japanese   Portuguese  
25 Sep 2012
Functional thinking: Rethinking dispatch
Next-generation languages for the Java platform have more-flexible method-dispatch mechanisms than the Java language. In this Functional thinking installment, Neal Ford explores dispatch mechanisms in functional languages like Scala and Clojure, showing new ways to think about executing code.
Also available in: Chinese   Russian   Japanese   Portuguese  
21 Aug 2012
Functional thinking: Functional design patterns, Part 3
The Gang of Four's Interpreter design pattern encourages extending a language by building a new language from it. Most functional languages let you extend the language in a variety of ways, such as operator overloading and pattern matching. Although Java doesn't permit any of these techniques, next-generation JVM languages do, with varying implementation details. In this article, Neal Ford investigates how Groovy, Scala, and Clojure realize the intent of the Interpreter design pattern by allowing functional extensions in ways that Java does not.
Also available in: Chinese   Russian   Japanese  
15 May 2012
Functional thinking: Functional design patterns, Part 2
Design patterns represent just one way to solve problems, but if you primarily use object-oriented languages, you may come to think in design patterns. In this installment of Functional thinking, Neal Ford illustrates solutions to a common problem -- incompatible interfaces -- using traditional design patterns, metaprogramming, and functional composition. Each approach has pros and cons, but thinking about the design of the solutions helps you see problems in new ways.
Also available in: Chinese   Russian   Japanese  
03 Apr 2012
Functional thinking: Functional features in Groovy, Part 3
Modern dynamic languages have incorporated many functional features to take mundane tasks off developers' hands. This article explores the benefits of caching at the function level with Groovy, contrasting it with an imperative approach. It illustrates two types of caching -- intramethod and external -- and discusses the advantages and disadvantages of the imperative and functional versions.
Also available in: Chinese   Russian   Japanese  
31 Jan 2012
Functional thinking: Functional features in Groovy, Part 2
With Groovy, metaprogramming and functional programming form a potent combination. See how metaprogramming enables you to add methods to the Integer data type that take advantage of Groovy's built-in functional capabilities. And learn how to use metaprogramming to incorporate the Functional Java framework's rich set of functional features seamlessly into Groovy.
Also available in: Chinese   Russian   Japanese  
20 Dec 2011
Functional thinking: Functional features in Groovy, Part 1
Over time, languages and runtimes have handled more and more mundane details for us. Functional languages exemplify this trend, but modern dynamic languages have also incorporated many functional features to make developers' lives easier. This installment investigates some of the functional features already lurking in Groovy, showing how recursion hides state and how to build lazy lists.
Also available in: Chinese   Russian   Japanese   Spanish  
22 Nov 2011
Java development 2.0: Ultra-lightweight Java web services with Gretty
Gretty is one of a new school of ultra-lightweight frameworks made for building web services. Built on top of the blazingly fast Java NIO APIs, Gretty leverages Groovy as a domain-specific language for web endpoints and Grape's Maven-style dependency management. In this article, get started with using Gretty to build and deploy Java web service applications.
Also available in: Chinese   Russian   Japanese   Portuguese  
16 Aug 2011
Functional thinking: Immutability
Immutability is one of the building blocks of functional programming. This Functional thinking installment discusses the many aspects of immutability in the Java language and shows how to create immutable Java classes in both traditional and newer styles. It also shows two ways to create immutable classes in Groovy, removing much of the pain of the Java implementation. Finally, you'll learn when this abstraction is appropriate.
Also available in: Chinese   Russian   Japanese  
26 Jul 2011
Functional thinking: Thinking functionally, Part 2
Functional languages and frameworks let the runtime control mundane coding details such as iteration, concurrency, and state. But that doesn't mean you can't take back control when you need to. One important aspect of thinking functionally is knowing how much control you want to give up, and when.
Also available in: Chinese   Russian   Japanese   Spanish  
31 May 2011
Functional thinking: Thinking functionally, Part 1
Functional programming has generated a recent surge of interest with claims of fewer bugs and greater productivity. But many developers have tried and failed to understand what makes functional languages compelling for some types of jobs. Learning the syntax of a new language is easy, but learning to think in a different way is hard. In the first installment of his Functional thinking column series, Neal Ford introduces some functional programming concepts and discusses how to use them in both Java and Groovy.
Also available in: Chinese   Russian   Japanese   Portuguese   Spanish  
03 May 2011
Java development 2.0: MongoDB: A NoSQL datastore with (all the right) RDBMS moves
If you're exploring the world of NoSQL databases, then MongoDB -- sometimes billed as the NoSQL RDBMS -- deserves a place on your list. Learn all about MongoDB's custom API, interactive shell, and support for RDBMS-style dynamic queries, as well as quick and easy MapReduce calculations. Then get started creating, finding, and manipulating data using MongoDB's native Java language driver and a handy Groovy wrapper called GMongo.
Also available in: Chinese   Russian   Japanese   Portuguese  
28 Sep 2010
Evolutionary architecture and emergent design: Building DSLs in JRuby
Ruby is the current state-of-the-art language for constructing internal domain-specific languages (DSLs). One of the best Ruby implementations is the one that runs on the JVM: JRuby. In this installment of Evolutionary architecture and emergent design, you'll learn how to leverage Ruby's expressiveness yet keep the benefits of your existing (and future) Java code. You'll see how to construct internal DSLs in Ruby as a way of capturing domain idiomatic patterns.
Also available in: Chinese   Japanese  
28 Sep 2010
Resolve common concurrency problems with GPars
Alex Miller shows you how to use the Groovy-based DSLs found in GPars to solve common concurrency problems.
Also available in: Chinese   Russian   Japanese  
07 Sep 2010
Evolutionary architecture and emergent design: Building DSLs in Groovy
Internal domain-specific languages (DSLs) are possible but cumbersome in the Java language because of its restrictive syntax. Other languages on the JVM are better suited to building them. This Evolutionary architecture and emergent design installment covers some of the capabilities you can exploit and issues you'll encounter when using Groovy to build internal DSLs.
Also available in: Chinese   Japanese   Portuguese  
17 Aug 2010
Java development 2.0: Gaelyk for Google App Engine
The introduction of the Google App Engine saw a wave of frameworks emerge to facilitate developing applications targeted for it. The Gaelyk framework, one such framework written in Groovy, eases development of lightweight applications that leverage a datastore. And the scalability you can achieve is impressive.
Also available in: Chinese   Russian   Japanese   Portuguese  
15 Dec 2009
Evolutionary architecture and emergent design: Harvesting idiomatic patterns
This installment ties together emergent-design concepts from previous Evolutionary architecture and emergent design articles with a case study that shows how to discover, harvest, and leverage unexpected design elements in code. Once you understand how to identify design elements, you can use that knowledge to improve your code's design. Emergent design allows you to discover aspects of your code that you could never anticipate yet have become important parts of your code base.
Also available in: Chinese   Japanese   Portuguese  
08 Dec 2009
Java development 2.0: REST up with CouchDB and Groovy's RESTClient
A burst of innovation in the open source world over the last few years has led to an increase in Java developer productivity. Freely available tools, frameworks, and solutions address once-common time sinks. A promising new entry on the scene is Apache CouchDB, hailed by some as the database for Web 2.0. The big picture of CouchDB is easy to grasp, and using it is as simple as using a Web browser. This Java development 2.0 column introduces CouchDB and shows you how Groovy's RESTClient can help you tap into its strengths.
Also available in: Chinese   Russian   Japanese   Portuguese  
17 Nov 2009
Mastering Grails: Mock testing with Grails
In this Mastering Grails installment, Scott Davis shows you how to take advantage of the built-in mocking capabilities of the GrailsUnitTestCase and ControllerUnitTestCase classes included with Grails.
Also available in: Chinese   Japanese  
20 Oct 2009
memcached and Grails, Part 2: Integrating memcached into Grails
James Goodwill completes his two-part introduction to integrating memcached and Grails with a sample Grails application and a Java-based memcached client. Learn how to integrate Spymemcached into your Grails-built, contact-management application, then try caching individual request results with memcached. You'll also use the memcached client commands introduced in Part 1 to test the effectiveness of your new cache.
Also available in: Chinese   Japanese  
06 Oct 2009
Java development 2.0: You can borrow EC2 too
In this Java development 2.0 installment, Andrew Glover give you a hands-on introduction to developing for and deploying on the Amazon Elastic Compute Cloud (EC2). Learn how EC2 differs from Google App Engine, and leverage an Eclipse plug-in and the concise Groovy language to get a simple Web application up and running quickly on EC2.
Also available in: Chinese   Russian   Japanese   Portuguese  
29 Sep 2009
Practically Groovy: SwingBuilder and the Twitter API, Part 1
In this Practically Groovy article, Scott Davis tackles a topic that strikes fear into most server-side Java developers: Swing. As you'll learn, Groovy's SwingBuilder takes some of the sting out of this powerful yet complex GUI framework.
Also available in: Chinese   Russian   Japanese  
29 Sep 2009
Mastering Grails: Creating a custom plug-in
In this Mastering Grails installment, Scott Davis shows you how to create your own Grails plug-in. Once you see how effortless it is to create a plug-in, you'll understand why more than 250 Grails plug-ins are available now, with new ones being added all the time.
Also available in: Chinese   Russian   Japanese   Portuguese  
15 Sep 2009
Evolutionary architecture and emergent design: Language, expressiveness, and design, Part 2
The ability to see and harvest idiomatic patterns is critical for emergent design. Also vitally important to design is code's expressiveness. In Part 2 of this two-part article, Neal Ford continues discussing the intersection of expressiveness and patterns, demonstrating these concepts with both idiomatic patterns and formal design patterns. He recasts more of the classic Gang of Four patterns in dynamic languages for the JVM to show how more-expressive languages enable you to see design elements obscured by more-opaque languages.
Also available in: Chinese  
01 Sep 2009
Practically Groovy: The @Delegate annotation
Scott Davis continues the discussion about Groovy metaprogramming with an in-depth look at the @Delegate annotation, which blurs the distinctions between data type and behavior and static and dynamic typing.
Also available in: Chinese   Japanese  
25 Aug 2009
Evolutionary architecture and emergent design: Language, expressiveness, and design, Part 1
The ability to see and harvest idiomatic patterns is critical for emergent design. Also vitally important to design is code's expressiveness. In a two-part article, Neal Ford discusses the intersection of expressiveness and patterns, demonstrating these concepts with both idiomatic patterns and formal design patterns. He recasts some of the classic Gang of Four patterns in dynamic languages for the JVM to show how more expressive languages enable you to see design elements obscured by more opaque languages.
Also available in: Chinese  
28 Jul 2009
Practically Groovy: Metaprogramming with closures, ExpandoMetaClass, and categories
Enter into the world of metaprogramming, Groovy-style. The ability to add new methods to classes dynamically at run time -- even Java classes, and even final Java classes -- is incredibly powerful. Whether used for production code, unit tests, or anything in between, Groovy's metaprogramming capabilities should pique the curiosity of even the most jaded Java developer.
Also available in: Chinese   Japanese  
23 Jun 2009
Mastering Grails: File uploads and Atom syndication
In this Mastering Grails installment, Scott Davis shows you how to upload files to your Grails application and set up an Atom syndication feed. With these last pieces in place, Blogito becomes a full-fledged blog server.
Also available in: Chinese   Japanese   Portuguese  
09 Jun 2009
Practically Groovy: Building, parsing, and slurping XML
Learn how easy it is to slice and dice XML using Groovy. In this installment of Practically Groovy, author Scott Davis shows that whether you're creating XML with MarkupBuilder and StreamingMarkupBuilder, or parsing XML with XmlParser and XmlSlurper, Groovy offers a set of compelling tools for dealing with this ubiquitous data format.
Also available in: Chinese   Japanese   Portuguese  
19 May 2009
JSF 2 fu, Part 1: Streamline Web application development
With version 2.0, JavaServer Faces (JSF) makes it easy to implement robust, Ajaxified Web applications. This article launches a three-part series by JSF 2.0 Expert Group member David Geary showing you how to take advantage of the new features in JSF 2 to sharpen your skills like a kung fu master. In this installment, you'll learn how to streamline development with JSF 2 by replacing XML configuration with annotations and convention, simplifying navigation, and easily accessing resources. And you'll see how to use Groovy in your JSF applications.
Also available in: Chinese   Russian   Japanese  
12 May 2009
Mastering Grails: Authentication and authorization
Grails provides all the basic building blocks you need to put together a secure Web application, ranging from a simple login infrastructure to role-based authorization, and in this installment of Mastering Grails, Scott Davis gives you a hands-on lesson in securing your Grails application. You'll also learn about some plug-ins that can help you extend your applications' security capabilities in new directions.
Also available in: Chinese   Japanese   Portuguese  
28 Apr 2009
Practically Groovy: Reaching for each
In this Practically Groovy installment, Scott Davis provides a dizzying array of ways to iterate through ... arrays. And lists. And files. And URLs. And on and on and on. The most impressive part is that Groovy provides a consistent mechanism for walking through all of those collections and more.
Also available in: Chinese   Japanese  
14 Apr 2009
Mastering Grails: Rewiring Grails with custom URIs and codecs
In this installment of Mastering Grails, Scott Davis shows you how to customize the standard Uniform Resource Identifier (URI) that Grails generates for Web pages. Moving from primary keys to descriptive titles in URIs gives users a more memorable and more meaningful path to the resources that they seek.
Also available in: Chinese   Russian   Japanese  
10 Mar 2009
Social mashups with Groovy
Build a Groovy mashup that lets users view a map of their Twitter friends with Twitter4J, Google Maps, and a bit of Ajax.
Also available in: Chinese   Japanese  
24 Feb 2009
Scott Davis on rebooting the Practically Groovy series
Scott Davis, author, speaker, software developer, founder of ThirstyHead.com, a Groovy and Grails training company, gets excited about rebooting the "Practically Groovy" series on developerWorks. His article "Groovy: A DSL for Java Programmers" is highlighted this week.
18 Feb 2009
Practically Groovy: Groovy: A DSL for Java programmers
Groovy expert Scott Davis reboots the Practically Groovy series, dormant since 2006. This initial installment catches you up on Groovy's recent history and the current state of the Groovy union. Then you'll learn how easy it is to get started with Groovy, circa 2009.
Also available in: Chinese   Russian   Japanese  
17 Feb 2009
Groovier Spring, Part 1: Integration basics
The Spring Framework provides a solid foundation for Web and enterprise applications. Spring's support for dynamic languages like Groovy adds capabilities that can make your application architecture more flexible and dynamic. In Part 1 of this two-part series, you'll learn the basics of integrating Groovy into Spring applications.
Also available in: Chinese   Russian   Japanese  
06 Jan 2009
Groovier Spring, Part 2: Change application behavior at run time
The Spring Framework provides a solid foundation for Web and enterprise applications. Spring's support for dynamic languages like Groovy adds capabilities that can make your application architecture more flexible and dynamic. In the second and final installment of the Groovier Spring series, you'll learn how to change the behavior of Spring applications at run time using dynamically refreshable beans.
Also available in: Chinese   Russian   Japanese  
06 Jan 2009
Mastering Grails: Asynchronous Grails with JSON and Ajax
JavaScript Object Notation (JSON) and Asynchronous JavaScript + XML (Ajax) are staples of Web 2.0 development. In this installment of the Mastering Grails series, author Scott Davis demonstrates the native JSON and Ajax capabilities baked into the Web framework.
Also available in: Chinese   Russian   Japanese  
18 Nov 2008
Mastering Grails: Testing your Grails application
Grails makes it easy to ensure that your Web applications start out bug free and stay that way. As a bonus, you can leverage your test code to produce a rich set of executable documentation that is always up-to-date. This month, Grails guru Scott Davis shows you the Grails testing ropes.
Also available in: Chinese   Russian   Japanese  
14 Oct 2008
Mastering Grails: RESTful Grails
We live in the era of mashups. Creating Web pages that give users the information they want is a good start, but offering a source of raw data that other Web developers can easily mix in with their own applications is better. In this installment of Mastering Grails, Scott Davis introduces various ways to get Grails to produce XML instead of the usual HTML.
Also available in: Chinese   Russian   Japanese  
16 Sep 2008
Mastering Grails: The Grails event model
Everything in Grails, from build scripts to individual artifacts such as domain classes and controllers, throw events at key points during an application's life cycle. In this Mastering Grails installment, you'll learn how to set up listeners to catch these events and react to them with custom behavior.
Also available in: Chinese   Japanese  
12 Aug 2008
Mastering Grails: Grails and legacy databases
In this Mastering Grails installment, Scott Davis explores the various ways that Grails can use database tables that don't conform to the Grails naming standard. If you have Java classes that already map to your legacy databases, Grails allows you to use them unchanged. You'll see examples that use Hibernate HBM files and Enterprise JavaBeans 3 annotations with legacy Java classes.
Also available in: Chinese   Japanese  
15 Jul 2008
Mastering Grails: Grails services and Google Maps
Scott Davis shows you how you can add maps to a Grails application using freely available APIs and Web services in this latest installment of Mastering Grails. He uses the trip-planner sample application from previous installments and takes it to the next level with geocoding, Google Maps, and Grails services.
Also available in: Chinese   Japanese  
20 May 2008
Mastering Grails: Many-to-many relationships with a dollop of Ajax
Many-to-many (m:m) relationships can be tricky to deal with in a Web application. In this installment of Mastering Grails, Scott Davis shows you how to implement m:m relationships in Grails successfully. See how they're handled by the Grails Object Relational Mapping (GORM) API and the back-end database. Also find out how a bit of Ajax (Asynchronous JavaScript + XML) can streamline the user interface.
Also available in: Chinese   Japanese  
15 Apr 2008
Mastering Grails: Changing the view with Groovy Server Pages
Groovy Server Pages (GSP) puts the "Web" in the Grails Web framework. In the third installment of his Mastering Grails series, Scott Davis shows you the ins and outs of working with GSP. See how easy it is to use Grails TagLibs, mix together partial fragments of GSPs, and customize the default templates for the automatically generated (scaffolded) views.
Also available in: Chinese   Russian   Japanese  
11 Mar 2008
Mastering Grails: Build your first Grails application
Java programmers needn't abandon their favorite language and existing development infrastructure to adopt a modern Web development framework. In the first installment of his new monthly series Mastering Grails, Java expert Scott Davis introduces Grails and demonstrates how to build your first Grails application.
15 Jan 2008
Invoke dynamic languages dynamically, Part 2: Find, execute, and change scripts at run time
The Java scripting API added in Java SE 6 and backward compatibility with Java SE 5 allows dozens of scripting languages to be called at run time from a Java application in a simple, unified way. Part 1 of this two-part article introduces the API's basic features. Part 2 exposes more of its power, demonstrating how external scripts written in Groovy, JavaScript, and Ruby can be executed and altered at run time to change business logic without stopping and restarting the application.
Also available in: Chinese   Russian   Japanese  
11 Sep 2007
Invoke dynamic languages dynamically, Part 1: Introducing the Java scripting API
You don't need to compile dynamic languages into Java bytecode to use them with a Java application. Dozens of scripting languages can be called at run time from Java code in a simple, unified way using the scripting package added to Java Platform, Standard Edition 6 (Java SE) and backward compatible with Java SE 5. Part 1 of this two-part article introduces the Java scripting API's features. It uses a simple Hello World application to show how Java code can execute scripting code and how scripts can in turn execute Java code. Part 2 dives deeper into the power of the Java scripting API.
Also available in: Chinese   Russian   Japanese  
04 Sep 2007
Practically Groovy: Smooth operators
The Java language has banned operator overloading, but upstart Groovy says "bring it on!" Find out what you've been missing all these years, as Andrew Glover walks you through everyday uses of Groovy's three categories of overloadable operators in this final, regular installment of Practically Groovy.
Also available in: Russian   Japanese  
25 Oct 2005
Practically Groovy: Functional programming with curried closures
Spice up your standard closures with the curry method, invented by Haskell Curry and found in the Groovy language since before the JSR compliant releases.
Also available in: Russian   Japanese  
23 Aug 2005
Practically Groovy: Groovy's growth spurt
With the release (and subsequent releases) of a JSR-241 compliant parser, the changes to Groovy's syntax have been formalized -- which means if you weren't paying attention before, now's the time to start. This month, resident Groovy practitioner Andrew Glover walks through most important changes to Groovy's syntax and shows you a handy feature you won't find in classic Groovy.
Also available in: Russian  
19 Jul 2005
Practically Groovy: Stir some Groovy into your Java apps
Ever thought about embedding Groovy's simple, easy-to-write scripts in your more complex Java programs? In this installment of Practically Groovy, Andrew Glover shows you the many ways to incorporate Groovy into your Java code and explains where and when it's appropriate to do so.
Also available in: Russian   Japanese  
24 May 2005
Practically Groovy: Go server-side up, with Groovy
The Groovlet and GroovyServer Pages (GSP) frameworks are built on the shoulders of the Java Servlet API. Unlike Struts and JSF, however, Groovy's server-side implementation isn't meant for all occasions. Rather, it's a simplified alternative for developing server-side applications quickly and easily. Follow along with Groovy advocate Andrew Glover as he introduces these frameworks and demonstrates their use.
Also available in: Russian   Japanese  
15 Mar 2005
Practically Groovy: MVC programming with Groovy templates
Views are an integral part of MVC programming, which is itself a ubiquitous component of enterprise application development. In this installment of Practically Groovy, Andrew Glover shows how Groovy's template engine framework can simplify view programming and make your code more maintainable over time.
Also available in: Russian   Japanese  
15 Feb 2005
Practically Groovy: JDBC programming with Groovy
Take your practical knowledge of Groovy one step further this month, as Andrew Glover shows you how to use GroovySql to build a simple data-reporting application. GroovySql combines closures and iterators to ease Java Database Connectivity (JDBC) programming by shifting the burden of resource management from you to the Groovy framework itself.
Also available in: Russian   Japanese  
11 Jan 2005
Practically Groovy: Ant scripting with Groovy
Both Ant and Maven rule the world of build processing, but XML is occasionally a less-than-expressive configuration format. In this second installment in his new series on the practical applications of Groovy, Andrew Glover introduces Groovy's builder utility, which makes it especially easy to combine Groovy with Ant and Maven for more expressive and controllable builds.
Also available in: Russian   Japanese  
14 Dec 2004
Practically Groovy: Unit test your Java code faster with Groovy
Not long ago, developerWorks contributor Andrew Glover penned an article introducing Groovy, a new proposed standard language for the Java platform, as part of our alt.lang.jre series. Reader response was fantastic, so we've decided to launch this column to offer a practical guide to using this hot new technology. This first installment introduces a simple strategy for unit testing Java code with Groovy and JUnit.
Also available in: Russian   Japanese  
09 Nov 2004
alt.lang.jre: Feeling Groovy
Andrew Glover offers an informal introduction to Groovy, the proposed addition to the standard programming languages for the Java platform.
03 Aug 2004
1 - 70 of 70 results
Show Summaries | Hide Summaries