Filter by products, topics, and types of content

(0 Products)

(121 Topics)

(4 Industries)

(6 Types)

1 - 19 of 19 results
Show Summaries | Hide Summaries
View Results
Title none Type none Date none
Evolutionary architecture and emergent design: Investigating architecture and design
Software architecture and design generate a lot of conversational heat but not much light. To start a new conversation about alternative ways to think about them, this article launches the Evolutionary architecture and emergent design series. Evolutionary architecture and emergent design are agile techniques for deferring important decisions until the last responsible moment. In this introductory installment, series author Neal Ford defines architecture and design and then identifies overarching concerns that will arise throughout the series.
Also available in: Chinese   Russian   Vietnamese   Spanish  
Articles 24 Feb 2009
Evolutionary architecture and emergent design: Emergent design in the wild
How can you tell when emergent design is suitable? This final installment of Evolutionary architecture and emergent design discusses the suitability of emergent design for various types of projects and how to tell when to make decisions. It concludes by recapping some of the series' key points.
Also available in: Chinese  
Articles 18 Jan 2011
Evolutionary architecture and emergent design: Environmental considerations for design, Part 2
Enterprise software projects don't exist in a vacuum. Environmental considerations have an impact even on decisions that seem purely technical. This Evolutionary architecture and emergent design installment continues to investigate some of those environmental concerns, in particular refactoring and the intersection between architecture and design.
Also available in: Chinese  
Articles 30 Nov 2010
Evolutionary architecture and emergent design: Environmental considerations for design, Part 1
As much as we'd like it to, software design doesn't exist in a vacuum. This installment of Evolutionary architecture and emergent design discusses how two environmental factors -- estimation and technical debt -- can affect design decisions, and how your emergent designs can survive the rough political waters in which they may find themselves.
Also available in: Chinese   Portuguese  
Articles 26 Oct 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  
Articles 28 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  
Articles 17 Aug 2010
Evolutionary architecture and emergent design: Fluent interfaces
This installment of Evolutionary architecture and emergent design continues the discussion of harvesting techniques for idiomatic patterns in emergent design. When you identify a reusable pattern, you should capture it in a way to sets it apart from the rest of your code. Domain-specific languages (DSLs) offer many techniques for concisely capturing data and functionality. This month, Neal Ford shows you three ways to build internal DSLs that capture idiomatic domain patterns.
Also available in: English   Chinese   Japanese   Portuguese  
Articles 13 Jul 2010
Evolutionary architecture and emergent design: Using DSLs
Until now, Evolutionary architecture and emergent design has primarily focused on emergent design for technical patterns. This installment covers capturing domain idiomatic patterns using domain-specific language (DSL) techniques. Series author Neal Ford illustrates the approach with an example and shows the benefits of this abstraction style for harvesting idiomatic patterns.
Also available in: Chinese   Japanese  
Articles 08 Jun 2010
Evolutionary architecture and emergent design: Leveraging reusable code, Part 2
Once you use the techniques described in previous Evolutionary architecture and emergent design installments to discover emergent design in code, you need a way to harvest and leverage those design elements. This article covers two techniques for harvesting idiomatic patterns: capturing patterns as APIs and using metaprogramming techniques.
Also available in: Chinese  
Articles 11 May 2010
Evolutionary architecture and emergent design: Leveraging reusable code, Part 1
Once you identify idiomatic patterns in code, the next step is to harvest and use them. Understanding the relationship between design and code can facilitate the discovery of reusable code. This Evolutionary architecture and emergent design installment explores the code/design relationship, the importance using an expressive language, and the potential value of rethinking abstraction styles.
Also available in: Chinese   Portuguese  
Articles 30 Mar 2010
Evolutionary architecture and emergent design: Evolutionary architecture
This installment of Evolutionary architecture and emergent design tackles a variety of topics related to evolutionary architecture, including the important distinction between design and architecture (and how to tell them apart), some issues that come up when you create enterprise-level architecture, and the difference between static and dynamic typing in service-oriented architectures.
Also available in: Chinese   Russian   Portuguese   Spanish  
Articles 19 Jan 2010
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  
Articles 08 Dec 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   Vietnamese  
Articles 01 Sep 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   Vietnamese  
Articles 28 Jul 2009
Evolutionary architecture and emergent design: Emergent design through metrics
Software metrics can help you find hidden design elements in your code, enabling them to emerge as idiomatic patterns. This installment of Evolutionary architecture and emergent design shows how intelligent use of metrics and visualizations lets you discover important code elements that are obscured by accidental complexity.
Also available in: Chinese   Japanese   Vietnamese  
Articles 04 Mar 2010
Evolutionary architecture and emergent design: Refactoring toward design
Earlier installments in this series discuss how unit testing leads you to a better design. But if you already have lots of code, how do you discover design elements lurking within it? The preceding installment talked about building structural targets for your code. In this article, series author Neal Ford expands on those ideas and covers techniques that use refactoring to allow emergent design.
Also available in: Chinese   Japanese   Vietnamese  
Articles 26 May 2009
Evolutionary architecture and emergent design: Composed method and SLAP
How do you find hidden design in aging code bases? This article discusses two important patterns for code structure: composed method and single level of abstraction. Applying these principles to your code allows you to find reusable assets that remained hidden before, with the further benefit of letting you abstract existing code into harvested frameworks.
Also available in: Chinese   Russian   Japanese   Spanish  
Articles 21 Apr 2009
Evolutionary architecture and emergent design: Test-driven design, Part 2
Testing is only a side effect of test-driven development (TDD); when done right, TDD improves the overall design of your code. This Evolutionary architecture and emergent design installment completes a walk-through of an extended example showing how design can emerge from the concerns that float up from testing.
Also available in: Chinese   Russian   Vietnamese  
Articles 07 Apr 2009
Evolutionary architecture and emergent design: Test-driven design, Part 1
Most developers think that the most beneficial part of using test-driven development (TDD) are the tests. But, when done right, TDD improves the overall design of your code. This installment in the Evolutionary architecture and emergent design series walks through an extended example showing how design can emerge from the concerns that float up from testing. Testing is only a side effect of TDD; the important part is how it changes your code for the better.
Also available in: Chinese   Russian   Vietnamese  
Articles 24 Feb 2009
1 - 19 of 19 results
Show Summaries | Hide Summaries