To see how Obix source code looks like, let's have a look at a very simple example. We didn't explain yet all elements used in the source code below, but the goal is to just get a first idea, without worrying about all the details.

Suppose we want to deal with products in an ERP application. Obviously, a first step is to define type product. This is how we do it:

type id : product
   // instructions to define the type
end type

	The definition of a type starts with the keyword type and ends with end type. Note Every software element is ended with the keyword end, optionally followed by it's name. So, instead of end type we can also simply write end
	Our type's identifier is product. id is a property of the type. Every property is defined by the syntax property_name : property_value. The spaces before and after the : are optional. Note Instead of writing type id : product we can also simply write type product
	To increase readability, indentation (spaces or tabs) is used in front of instructions that are contained in an element. One-line comments start with //.

By applying the simplifications explained in the above notes, we can write the code in a more concise way:

type product
   // instructions to define the type
end

The next step is to add attribute identifier that is used to uniquely identify the product:

type product
   attribute identifier type:positive32 end
end

	The definition of an attribute starts with the keyword attribute.
	The type of attribute identifier is positive32, which means that the identifier can be any positive number (greater than 0) stored in 32 bits

Let's add two more attributes:

type product
   attribute identifier type:positive32 end
   attribute name type:string end
   attribute price_in_cents type:positive32 end
end

If we want to convert the product to an XML string, we can add the following command:

command convert_to_XML
   out result type:string end
end

	The command's identifier is convert_to_XML.
	The command's result is stored in output argument result of type string

The final code for type product now becomes:

type product

   attribute identifier type:positive32 end
   attribute name type:string end
   attribute price_in_cents type:positive32 end
   
   command convert_to_XML
      out result type:string end
   end

end

That's all for the type. As objects are created by factories, let's start defining a factory that will be used to create products:

factory product_factory type: product
end factory

	A factory starts with the keyword factory.
	The factory's identifier is product_factory
	The factory implements type product

Each factory must have at least one creator. We will use a standard creator that enables us to specify values for all attributes:

factory product_factory type: product
   creator create kind:in_all end
end factory

	A creator starts with the keyword creator.
	The creator's identifier is create
	By specifying kind:in_all the compiler will automatically generate a creator with one input argument for each attribute defined in the type. See the section called “Creator” for more information.

A factory must define an implementation for each feature defined in the implemented type. However, the compiler generates a default implementation for each attribute if no explicit implementation is defined in the factory's source code. Hence, we don't have to code something for the attributes.

But a command's implementation must always be coded explicitly. In our case, command convert_to_XML could be implemented as follows:

   command convert_to_XML
      script
         result = """
           <product>
             <id>{{identifier.to_string}}</id>
             <name>{{name}}</name>
             <price_in_cents>{{price_in_cents.to_string}}</price_in_cents>
           </product>"""
      end script
   end command

	start of the script that implements command convert_to_XML
	the result is stored in output argument result
	start of a triple quoted string (for more information see the section called “Triple quoted string literal”)
	start of an expression embedded in the string
	identifier.to_string is an expression embedded in the string (attribute identifier of type positive32 is converted to type string)
	end of an expression embedded in the string
	another embedded expression
	end of triple quoted string

The complete code for factory product_factory is:

factory product_factory type: product

   command convert_to_XML
      script
         result = """
           <product>
             <id>{{identifier.to_string}}</id>
             <name>{{name}}</name>
             <price_in_cents>{{price_in_cents.to_string}}</price_in_cents>
           </product>"""
      end script
   end command

   creator create kind:in_all end

end factory

Now an object of type product can be created as follows:

var product banana = product_factory.create ( &
   identifier = 123 &
   name = "banana" &
   price_in_cents = 20 )

	declare variable banana of type product
	assignment operator
	use creator create of factory product_factory to create an object of type product
	& is the 'line continuation character' in Obix. (see the section called “Line continuation”)
	assign the value 123 to input argument identifier
	assign "banana" to input argument name
	assign 20 to input argument price_in_cents

To display an XML representation of the banana on the system console, we can write:

console.message ( banana.convert_to_XML )

	use command message of service console to display a message on the system console
	execute command convert_to_XML on the object stored in variable banana

We can embed the above instructions in a service, as follows:

service product_tests

   command display_banana_XML
      script
         var product banana = product_factory.create ( &
            identifier = 123 &
            name = "banana" &
            price_in_cents = 20 )
         console.message ( banana.convert_to_XML )
      end script
   end command

end service

Executing product_tests.display_banana_XML will display the following:

           <product>
             <id>123</id>
             <name>banana</name>
             <price_in_cents>20</price_in_cents>
           </product>

	Note
	The above example is written without using prefixed identifiers. Those are optional and they will be explained in the section called “Prefixed identifier”.