Introduction to Running Objects

 

In the last years, the fast and constant evolution of business requirements together with the high priority and short development schedule became the main problems for thousands of developers trying to tackle the challenge of deliver high quality applications in the shortest time possible. In the same time, we have several initiatives that try to support the development community and solve these problems.

Methodologies such as Scrum for project management with its iterative delivery; development approaches such as Domain-Driven Design that suggests to focus on the domain and its logic; patterns such as Model-View-Controller that supports the development isolating areas such as presentation and domain logic, coordinating them through a control layer and Service Oriented Architecture that aids the integration design of applications through the exposure of services are essential elements to achieve the existing software development requirements.

To fulfill these requirements and provide developers with a tool that supports the latest methodologies, patterns and architectures, enabling them to deliver the highest business value in the shortest time possible was born Running Objects.

 

Running Objects

What is Running Objects?

Running Objects is a framework that allows you to use simple OO concepts, focus on your business domain and do not waste time with areas that are not relevant to your application. You will build better software, with less time and with no pain.

It’s built on top of ASP.NET MVC using a refined mix of concepts such as Domain-Driven Design, Naked Objects, Object-Oriented UI and Design Patterns. Basically, everything that is necessary to let you aggregate the highest business value in the shortest time to your application.

 

What can it do for you?

Domain-Driven Development with Object-Oriented Modeling

Use the power of DDD and OO to develop your applications. Your OO design and model will be your application. You don't need to worry with developing Data Access Components and/or User Interface code. Keep the focus in your business requirements.

Test-Driven Development with ease

Making use of OO concepts, Running Objects let you create a clean code, ready for unit testing. You can ask "But do I need to do something else to create the unit tests”, we will answer "Yes, the unit tests”.

Automatic RESTful service generation

Expose your objects as REST services automatically. Running Objects follows the HATEOAS (Hypermedia as the Engine of Application State) REST constraint to generate the RESTful service layer of your objects.

 

Fluent Security Configuration

No more hassles configuring security of your application. Use the code based configuration to create high-coherent security settings. You will never have an out of date security configuration again!

Extensible User Interface

Running Objects provides a default set of views that automatically generates the user interface based on your objects. But if you want to customize them, feel free to take the control and create your own views, templates and mix them all!

Transparent Persistence

Using the Repository Pattern, Running Objects let you use the persistence you want! It has an Entity Framework Repository ready to use, so if you are using Entity Framework, it will be just 1 line of configuration to use it!

 

What are the next steps?

For more information about the Running Objects, please check it out the official website at http://runningobjects.com, take a look at the get started tutorial and download it! We are currently working in more blog posts, webcasts and tutorials, so stay tuned!

Published Tuesday, July 31, 2012 4:50 PM by edurdias

Comments

# re: Introduction to Running Objects

Wednesday, August 01, 2012 11:19 AM by lynn eriksen

Tried out the template.

Too much 'auto magic' going on here. I could see an empty list for my object, but not how to create one. Woudn't know where to begin how to.

What minimal documentation you have is out of date. And without documentation, you'll have little adoption. And while I applaud an attempt to create a better dynamic data for MVC, taking an 'auto magic' approach is antithethical to why people use MVC to begin with.

That said, I would love to see how you evolve the project. Please provide documentation and a way to use scaffolding or other means to get around the 'auto magic' and I'll take a much longer look.

# re: Introduction to Running Objects

Wednesday, August 01, 2012 11:41 AM by edurdias

Hi lynn eriksen,

I agree with you that we need more documentation. We are working hard this week to get some get start videos and tutorials.

We don't intend to do 'auto magic', the RO will use the OO concepts to help you build the application. For example, to create a new item, you just need to create a constructor. The constructor will be the "Create Item" screen.

I really forgot to release the new get started. I am doing it today.

Stay tuned because we will have a lot of new docs this week.

Thank you,

Eduardo

# re: Introduction to Running Objects

Wednesday, August 01, 2012 7:19 PM by lynn eriksen

Okay. Sounds good. I will keep an eye out.

Might want to link a blog to RunningObjects.com as well.

# re: Introduction to Running Objects

Thursday, August 02, 2012 3:43 AM by Richard Pawson

Hi Eduardo

I'm always seek to see more people adopting the Naked Objects pattern :-)  A couple of questions:

1)  Is Running Objects a resurrection of the DotObjects project? (The latter seems to have gone dead and I see your name against both).

2) You might like to consider making your auto-generated RESTful API conform to the Restful Objects specification (see restfulobjects.org).  This is an independent specification, not tied to any implementation, but has been adopted both by Naked Objects for .NET and by Apache Isis (which took over the Naked Objects for Java).  Apart from being a very comprehensive and well-thought-out generic spec for an API to a domain object model, it has the huge advantage that if you can implement this spec then your Running Objects server could be used with any client written to that spec.  Or, conversely, if you separated out the client and server sides of Running Objects then you could use your client against other server implementations.

See also this recent article by Dan Haywood and me:  www.infoq.com/.../Intro_Restful_Objects

# re: Introduction to Running Objects

Thursday, August 02, 2012 9:46 AM by edurdias

Hi Richard,

Thank you for your feedback. Naked Objects has been part of the subjects of our researches for the last years.

I’ve implemented DotObjects in few projects and they were still missing ‘something’. After review the architecture where it would never be possible to accomplish a server-client approach; the concepts behind where applying Naked Objects at its full level would be too much intrusive to the development and; the requirement for a business analysis process that merges with the architecture and domain modeling where the main reasons to shutdown it and start over again, new, different and them Running Objects has born few months ago.

Running Objects brings a new proposal, simple, direct and straight forward DDD for the software and business analysis, OO for modeling and Naked Objects as inspiration and reference.

Great to know that we projects working with REST services, I will take a deep look at it. Currently we use a single core mechanism for both REST/ASP.NET ends. Just the rendering and routing control differentiate them.

I'm currently researching about description languages for RESTful services, if you have any insight or idea, please contact me.

Regards,

Eduardo

Leave a Comment

(required) 
(required) 
(optional)
(required)