Skip to content.
Manageability
Search
Sections
Latest Updates
Home
Personal tools
You are not logged in
Log in
You are here:
Home
»
blog
»
stuff
»
High Time For A New Kind Of Computer Science
»
Send this page to somebody
Send this page to somebody
Fill in the email address of your friend to send an email with the address.
Address info
Send to
(Required)
The e-mail address to send this link to.
From
(Required)
Your email address.
Comment
A comment about this link.
Related
Control Flow Business Process Modeling Considered Harmful
A Pattern Language for Loose Coupling
On the Trustworthiness of SaaS Components
Is Chandler's Demise Evidence that Dynamic Languages Can't Scale?
Laws of Software Complexity
Thou Shalt Not Inherit
Reuse Via String Substitution
Rules of Acquisition Must Be Declared
The Fallacies of Inheritance
Enhanced EJB Architecture
Taxonomy Of Object Composition
JBI Deals With the Heterogenous Network
Loose Coupling and Mediation
Why Document Passing is Loosely Coupled
Dataflow and Query Processing
Components are Like Runtime Classes
Weblogic Workshop's Asynchronous Components
Fallacies of a Perfect Computing World
Text Makes a Powerful Comeback!
Loosely Coupled Java Based Languages
The Elevator Pitch for Web Based Continuations
The Secret World of Exception Handling Frameworks
Quick Take on the Pi Calculus
Encapsulation and Representation are Orthogonal
A Definition of "Services"
Anemic Domain Model and SOA
Is there a Preferred Axis for Loose Coupled-ness?
WebServices' Greatest Achilles Heel
Lazy Evaluation And Object Composition
What's This? An Embeddable REST Microkernel!
Continuing Review of a REST Based Microkernel
The Next Thing After Java Technology
XML Fallacies Revealed
Why Object Oriented Encapsulation is Obsolete
Why Class Based Domain Modeling Does Not Work
Text Files Unfairly Compared To The Internal Combustion Engine
Integration at the Glass and the 80/20 Point
5 Rules of Model View Separation
Is Over Abstraction Java's Achilles Heel?
Usable APIs: Dependency Injection, Failure Strategies, Duck Typing and REST
Loose Coupling and its connection to Robustness
Is Quick And Dirty Good Enough?
Six Operators of Modularity
Loosely Coupled Dimensions [Updated]
Prototype Based Programming Makes A Comeback!
Why Pessimistic Transactions Aren't Practical
Contracts and Interaction Operators
Transactions and SOA
Why Time Travel is a Necessity
Uniformity and Recombinant Computing
Tuple Spaces for Human Interaction
Compatibility and Evolution in an Asynchronous World
The Importance Of "Requires"
The Trouble with Evolving XML Schemas
XML Schema is a Case of Premature Optimization
How To Achieve Flexible XML Messaging
Don't Dismiss Structure Shyness
Are Abstraction Layers in Messaging Necessary?
The RESTfulness of Speech Acts
The Imminent Rise of REST and Fall of SOAP
Requirements Without Measurement Are Nothing More Than Utterances
Ten Fallacies of Software Analysis and Design
Deconstructing Dependency Injection
Groovy and Del.icio.us
High Time to Get Rid of the Stack
The Conceptual Underpinnings of JotSpot
Microsoft's Standardized Verb Set
Reverse Proxy Patterns
Do We Live in a Donut World?
On the Degrees of Reusability
The Architecture of Eclipse
The Sensible Trend of ScreenCasting
Object-Based Remodularization (a.k.a. Programming with Adapters )
Why REST is Better - Part 1 - Explained in Code
Why REST is Better - Part 2 - Contract Based Protocols
Why REST is Better - Part 3 - Think Globally, Act Locally
The Long Tail of Recombinant Components
The Ten Commandments for SOA Salvation
Why Rigorous Processes, Specifications and Estimations are a Waste of Time
How Web 2.0 supports Lean Production
Why are Standardization Train Wrecks always in Slow Motion?
SOA 2.0 : Why a Revision is Really Necessary
What did Javascript have that Java did not?
Software Development Trends for 2007
Top Five Java Technologies that Didn't Make the List and Why
Design Patterns for Almost-Infinite Scalability
Object Oriented Styled Interactions Considered Harmful
High Time to Remodel Object Modeling?
SOA Principles and Modularity
Is Fortress the Ultimate Language for DSLs?
Mega Components Reusability - Due Diligence
Why Can't Locking Be Abstracted Away?
Manageability of Dependencies
Meta Tags Revisited
Is It High Time To Get Rid Of Classes?
Refactoring to Implicit Invocations
Programming with Adaptors
Principles of Loosely Coupled API's
The Limits of Static Reasoning
The Hive Mind is Asynchronous
Do Aspects Supercede Components?
A New and More Powerful Definition of Objects
Words of Wisdom on Designing Usable APIs
Explicitness versus Loose Coupling
Dynamic Typing is Not a Panacea Either
Discordant Web Service Orchestration
Six Degrees of Iterator
Does Static Typing Break Encapsulation?
A Definition of "Component"
The Everything Loosely Coupled Architecture
Are Components Beyond Object-Oriented Programming?
Applying Economic Theory to Software
Deriving Architecture
Software Connectors a Subset of Communicative Acts
Taxonomy of Software Connectors
Software Connectors and Loose Coupling
FIPA Standard Communicative Acts
Categories of Loose Coupling
Loose Coupling: Dimensions and Categories
Why Lots of Things are Considered Harmful
Classification of Links
Adaptive Object Model Architectural Style
Soft Security and Why Not EJB
get, set Functions and if Statement Considered Evil
Post-EJB and Architectural Neutral Design
Speech Acts, REST and Method Classification
OFBiz Turning OO on its Head or Programming in the Large?
Asynchronous services [finally] preached
Principle of Duality in JSPs
Navigation
Home
blog
Software Engineering Concepts Revisited
archive
Java Open Source
stuff
visitors
reading
This site conforms to the following standards:
Section 508
WAI-AAA
Valid XHTML
Valid CSS and tableless layout