index.xml

<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>DDD concepts with Ruby</title>
    <link>https://ddd-ruby.github.io/index.xml</link>
    <description>Recent content on DDD concepts with Ruby</description>
    <generator>Hugo -- gohugo.io</generator>
    <language>en-us</language>
    <copyright>Released under the MIT license</copyright>
    <lastBuildDate>Fri, 06 Jan 2017 21:07:13 +0100</lastBuildDate>
    <atom:link href="https://ddd-ruby.github.io/index.xml" rel="self" type="application/rss+xml" />
    
    <item>
      <title>Quest for Quality</title>
      <link>https://ddd-ruby.github.io/quality/</link>
      <pubDate>Fri, 06 Jan 2017 21:07:13 +0100</pubDate>
      
      <guid>https://ddd-ruby.github.io/quality/</guid>
      <description>

&lt;p&gt;We continuously strive to provide best quality in our work. And we like to keep it transparent, because it helps us to stay accountable.&lt;/p&gt;

&lt;p&gt;When you find anything worth improving, please tell us and we will work through that issue together. Here is the overview of the &lt;code&gt;ddd-ruby&lt;/code&gt; organization status for different quality metrics.&lt;/p&gt;

&lt;h2 id=&#34;builds-status&#34;&gt;Builds Status&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href=&#34;https://travis-ci.org/ddd-ruby/&#34;&gt;https://travis-ci.org/ddd-ruby/&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;h2 id=&#34;code-coverage&#34;&gt;Code Coverage&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href=&#34;https://codecov.io/gh/ddd-ruby&#34;&gt;https://codecov.io/gh/ddd-ruby&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;h2 id=&#34;dependencies-overview&#34;&gt;Dependencies Overview&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href=&#34;https://gemnasium.com/ddd-ruby&#34;&gt;https://gemnasium.com/ddd-ruby&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</description>
    </item>
    
    <item>
      <title>Additional Information</title>
      <link>https://ddd-ruby.github.io/additional-information/</link>
      <pubDate>Wed, 04 Jan 2017 00:00:00 +0000</pubDate>
      
      <guid>https://ddd-ruby.github.io/additional-information/</guid>
      <description>

&lt;h2 id=&#34;videos&#34;&gt;Videos&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href=&#34;https://www.youtube.com/watch?v=CjNBnkMHjh4&#34;&gt;Domain-Driven Design for the Database Driven Mind - 2015&lt;/a&gt; + &lt;a href=&#34;https://github.com/julielerman/DomainDrivenDesignforDatabaseDrivenMind&#34;&gt;code&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&#34;https://channel9.msdn.com/Events/TechEd/Europe/2014/DEV-B411&#34;&gt;Entity Framework Model Partitioning in Domain-Driven Design Bounded Contexts - 2014&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;h2 id=&#34;podcasts&#34;&gt;Podcasts&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href=&#34;http://www.devdiscussions.com/episodes&#34;&gt;http://www.devdiscussions.com/episodes&lt;/a&gt;
Dev Discussions are recorded conversations between web-application developers as we discuss relevant topics.
With topics like DDD / Event Sourcing.&lt;/li&gt;
&lt;/ul&gt;
</description>
    </item>
    
    <item>
      <title>DDD in Ruby</title>
      <link>https://ddd-ruby.github.io/</link>
      <pubDate>Tue, 08 Mar 2016 21:07:13 +0100</pubDate>
      
      <guid>https://ddd-ruby.github.io/</guid>
      <description>

&lt;h2 id=&#34;beautiful-highly-adaptable-and-maintainable-ruby-applications-only-a-dream&#34;&gt;Beautiful, highly adaptable and maintainable Ruby applications - only a dream?&lt;/h2&gt;

&lt;p&gt;At some point of your career you have probably heard about DDD (Domain Driven Design) and dismissed it quickly as overly complex and too &lt;code&gt;enterprisy&lt;/code&gt;. After all, MVC and CRUD seem so much simpler and why would you go through the trouble of introducing new layers of complexity to your Ruby / Rails application? It just works and is really easy do maintain for many years to come, right?&lt;/p&gt;

&lt;p&gt;Well&amp;hellip; If you have ever worked on a successful Rails application, you probably experienced firsthand the problems that grow, when you apply MVC / CRUD to more complex requirements. You might start to introduce some extra layers, like &lt;code&gt;services&lt;/code&gt;, &lt;code&gt;interactors&lt;/code&gt; and such. While doing this, you have to invent new patterns, that are not quite popular in the Ruby community and there is little guidence, where this path will lead you.&lt;/p&gt;

&lt;p&gt;We developers / builders / business-owners want similar things:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;maintainable applications&lt;/li&gt;
&lt;li&gt;correct software&lt;/li&gt;
&lt;li&gt;good developer experience&lt;/li&gt;
&lt;li&gt;this thing should run in production without major problems&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&amp;hellip;&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Ruby libraries supporting DDD</title>
      <link>https://ddd-ruby.github.io/libraries/</link>
      <pubDate>Tue, 08 Mar 2016 21:07:13 +0100</pubDate>
      
      <guid>https://ddd-ruby.github.io/libraries/</guid>
      <description>

&lt;h2 id=&#34;rdm-the-missing-dependencies-manager-for-ruby-apps&#34;&gt;Rdm: the missing dependencies manager for Ruby apps&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href=&#34;https://ddd-ruby.github.io/rdm/&#34; target=&#34;_blank&#34;&gt;Rdm&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;With RDM you can split up one big Ruby application into multiple lightweight packages with explicit dependencies. You can do it before going the &lt;code&gt;microservices&lt;/code&gt; road, because this would be a much smoother transition. Going from explicit dependencies graph to proper SOA / microservices is also more straightforward. In DDD it helps to define clearer &lt;a href=&#34;http://martinfowler.com/bliki/BoundedContext.html&#34;&gt;Bounded Contexts&lt;/a&gt;, where each package can only access explicit dependencies. Contrast this with a monolithic Rails application with one global Ruby memory space, and you might understand the benefit of having stricter, more explicit way of managing dependencies.&lt;/p&gt;

&lt;h2 id=&#34;smartioc-a-declarative-dependency-injection-library&#34;&gt;SmartIoC: a declarative dependency Injection library&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href=&#34;https://ddd-ruby.github.io/smart_ioc/&#34; target=&#34;_blank&#34;&gt;SmartIoC&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;SmartIoC is a smart and really simple IoC container for Ruby applications.&lt;/p&gt;

&lt;p&gt;It allows you to create your dependencies on demand, supports lazy-loading of Ruby files, also allows different contexts for each dependency, so you get test/lightweight implementations in development / tests enviroments. It works great in combination with &lt;code&gt;Rdm&lt;/code&gt;.&lt;/p&gt;

&lt;h2 id=&#34;hashcast-hash-attributes-caster-in-declarative-way&#34;&gt;HashCast - Hash attributes caster in declarative way&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href=&#34;https://ddd-ruby.github.io/hashcast/&#34; target=&#34;_blank&#34;&gt;HashCast&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;In the DDD context it helps to convert user input to a properly casted Ruby object / hash. It is a lightweight dependency-free Ruby library, with a nice DSL for for specifying the structure of expected input with Ruby types.&lt;/p&gt;

&lt;h2 id=&#34;purevalidator-ruby-domain-object-validation-library&#34;&gt;PureValidator - Ruby domain object validation library&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href=&#34;https://ddd-ruby.github.io/pure_validator/&#34; target=&#34;_blank&#34;&gt;PureValidator&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;PureValidator is a simple, mostly dependency-free (except &lt;code&gt;i18n&lt;/code&gt;) library to validate your domain Ruby objects. It is an excellent companion to &lt;a href=&#34;https://ddd-ruby.github.io/hashcast/&#34; target=&#34;_blank&#34;&gt;HashCast&lt;/a&gt; to validate your Ruby objects against specific domain rules. What makes PureValidator special is the separation of validation rules from the object to validate. After countless fights against &lt;strong&gt;one-size-fits-all&lt;/strong&gt; &lt;code&gt;ActiveModel::Validations&lt;/code&gt;-style validations that mix domain/value object with its valudations, we came to prefer this simpler and more flexible approach.&lt;/p&gt;

&lt;p&gt;This approach is more popular in functional programming and leads to maintainable, easily unit-testable code. You are free to use multiple different validators for the same object in different situations. For example your validation rules during creation of an object are different from validations when user is changing a single boolean flag on it.&lt;/p&gt;

&lt;h2 id=&#34;contracts-contracts-for-ruby&#34;&gt;Contracts - Contracts for Ruby&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href=&#34;https://ddd-ruby.github.io/contracts.ruby/&#34; target=&#34;_blank&#34;&gt;Contracts&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Contracts let you clearly – even beautifully – express how your code behaves, and free you from writing tons of boilerplate, defensive code.&lt;/p&gt;

&lt;p&gt;We have a forked version of &lt;code&gt;contracts&lt;/code&gt; with nice diff output for KeywordArgs type (Hash).&lt;/p&gt;

&lt;h2 id=&#34;active-serializer-a-simple-objects-to-hash-serializer&#34;&gt;Active Serializer - a simple objects to hash serializer.&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href=&#34;https://ddd-ruby.github.io/active_serializer/&#34; target=&#34;_blank&#34;&gt;ActiveSerializer&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;ActiveSerializer is a lightweight dependency-free objects serializer with a nice declarative DSL.&lt;/p&gt;

&lt;p&gt;In our &lt;a href=&#34;https://github.com/ddd-ruby/json_serialization_benchmark&#34; target=&#34;_blank&#34;&gt;Serializers performance benchmark&lt;/a&gt; it places on a solid middle ground right after plain Ruby presenters while sporting a declarative DSL, providing you the same convenience as &lt;code&gt;ActiveModel Serializers&lt;/code&gt; do.&lt;/p&gt;

&lt;p&gt;Compared to &lt;code&gt;ActiveModel::Serializers&lt;/code&gt;-dependencies (activemodel / actionpack), that move with the corresponding Rails version, you get non of the potential headaches of conflicting transient dependencies, that are the horror and bane of many biggish Rails applications.&lt;/p&gt;

&lt;h2 id=&#34;apiview-friggin-fast-serializer-gem&#34;&gt;ApiView - Friggin&amp;rsquo; fast Serializer gem&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href=&#34;https://ddd-ruby.github.io/api_view/&#34; target=&#34;_blank&#34;&gt;ApiView&lt;/a&gt;
Another lightweight dependency-free objects serializer. Its &lt;code&gt;DSL&lt;/code&gt; is less involved, because its main focus is performance.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;code&gt;ApiView&lt;/code&gt; is currently the fastest known Ruby-based object serializer. If you are generating huge JSON payloads in your Ruby application, it will bring you 5-10X fold performance improvements, as demonstrated in our &lt;a href=&#34;https://github.com/ddd-ruby/json_serialization_benchmark&#34; target=&#34;_blank&#34;&gt;Serializers performance benchmark&lt;/a&gt;.&lt;/p&gt;

&lt;h2 id=&#34;values-values-is-a-tiny-library-for-creating-value-objects-in-ruby&#34;&gt;Values - Values is a tiny library for creating value objects in ruby.&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href=&#34;https://github.com/tcrayford/Values&#34; target=&#34;_blank&#34;&gt;Values&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;ol&gt;
&lt;li&gt;Constructors require expected arguments&lt;/li&gt;
&lt;li&gt;Instances are immutable&lt;/li&gt;
&lt;/ol&gt;

&lt;h2 id=&#34;overview-on-travis-ci&#34;&gt;Overview on Travis.CI&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href=&#34;https://travis-ci.org/ddd-ruby&#34; target=&#34;_blank&#34;&gt;DDD-Ruby libs on Travis&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</description>
    </item>
    
    <item>
      <title>Getting started</title>
      <link>https://ddd-ruby.github.io/getting-started/</link>
      <pubDate>Sat, 29 Mar 2014 00:00:00 +0000</pubDate>
      
      <guid>https://ddd-ruby.github.io/getting-started/</guid>
      <description>&lt;p&gt;Motivate the reader to dive deeper in DDD concepts by gently introducing him to some basic material. Also explain how Ruby and DDD applied together help to maintain agile and flexible applications.&lt;/p&gt;
</description>
    </item>
    
  </channel>
</rss>