00:00:15.440
Hello everyone! It's a great honor to be here today as an invited speaker. Thank you to those who voted for me; I really appreciate it.
00:00:23.039
So, it looks like I'm the only person in Japan in this group. Many of you might not know who I am, so let me introduce myself a little bit.
00:00:28.800
To begin with, this is my name in English and Japanese, and I’m from Tokyo, Japan. I heard that last year the creator of Ruby, Yukihiro Matsumoto, gave a keynote at this conference.
00:00:39.840
You might be missing his presence, but no problem—this year, I came instead!
00:00:47.120
My name is written in Japanese like this, and my family name shares the same kanji character as his, which is quite interesting. However, please don't call me that; you can just call me Akira.
00:01:02.159
A bit more about myself: I have been working in Ruby and the Rails framework for about eight months. I’ve authored some Ruby gems and am part of the most active Japanese Ruby community, which meets every Tuesday, and we have held more than 200 meetups.
00:01:22.640
I'm also one of the organizers for Ruby Kaigi 2014, which will probably be held around September next year. Please save the date on your iPhone!
00:01:30.560
So, my question for you is: Who here considers themselves a Rails engineer? Please raise your hand. Okay, a lot of you! Thank you.
00:01:48.480
Let me start my talk with a quotation that defines what an engineer is. Do you know this guy? This person is the creator of both Ruby and Rails.
00:02:01.920
He is a phenomenal programmer and once shared an anecdote on Twitter. He mentioned that when he introduced himself as a software engineer to someone from Boeing, that person got angry.
00:02:14.080
The Boeing engineer said you shouldn't call yourself an engineer unless you're working on engines like I do. That got me thinking.
00:02:26.160
Fortunately, we software engineers still have a chance to be considered engineers, because our Rails framework also has engines!
00:02:39.200
So, let’s hack on Rails engines! By doing that, we can establish ourselves as genuine software engineers.
00:02:48.560
Now, what are engines? Rails engines are plugins and can be considered miniature applications with required functionality.
00:03:05.360
Some of you might remember that there used to be a plugin platform called engines during the Rails 1 era, which provided features like a login engine. However, Rails engines are quite different.
00:03:13.440
A Rails engine is essentially a plugin, a gem that fits nicely within the Rails ecosystem. In Rails 3 and 4, a plugin is nothing more than a gem.
00:03:29.200
Let's explore how Rails plugins work from the bottom up to understand how they function.
00:03:41.680
For any engine, the first requirement is a gem because plugins are essentially gems. The gem spec should include its name and version.
00:03:48.639
So, let's get started! We will implement a simple plugin that greets users every time they start a server or console.
00:04:02.160
Now that I’ve created a gem, let's delve deeper to see how it works. The engine directory will contain the load path and then call the relevant resources.
00:04:11.920
This way, Ruby can locate and load the resources from the specified directories.
00:04:22.800
So far, this was just a demonstration of how engines can be implemented.
00:04:29.600
Now, let’s add a specific behavior. Adding some code into the Rails engine will enable it to print messages during application initialization.
00:04:40.239
The way that Rails handles the loading of engine subclasses is quite logical and allows for the automatic integration of features. We don’t need to explicitly register the initial object.
00:04:56.399
The way Rails engines inherit creates efficiencies that avoid unnecessary complexity while still ensuring necessary functionality.
00:05:08.480
The crucial aspect to understand is that the Rails engine is actually a plugin that can contain various application components, including models, controllers, and views.
00:05:26.639
This functionality allows engines to behave almost like standalone Rails applications.
00:05:34.079
In the example of our engine, let’s create a simple class with minimal functionality.
00:05:45.119
Now, if we inherit from the Rails engine, we can specify its location within our application structure.
00:06:01.040
An important takeaway is that we don't necessarily need to name the class explicitly—it can simply inherit functionality from the parent engine.
00:06:17.400
This flexibility means we can focus on the essential purposes of the engine rather than on the naming structure.
00:06:30.479
Another feature of engines is that they can contain various components, such as models and controllers, just like any Rails application.
00:06:45.760
This is incredibly useful because it means you can have all your application logic organized neatly within an engine.
00:07:02.160
Now, let’s see how the Rails engine loaded the model without requiring it explicitly. This is made possible due to how Rails organizes and manages its directories.
00:07:18.120
The models directory is automatically included in the load path, enabling Rails to find and utilize the necessary classes without additional instructions.
00:07:30.399
This is an essential feature that allows the Rails ecosystem to operate smoothly.
00:07:40.800
As we continue building engines, we can easily add configuration, routes, and controller actions, allowing them to operate like full-fledged Rails applications.
00:07:51.920
This versatility is one of the key benefits of using Rails engines.
00:08:02.240
Now that I'm demonstrating how an engine can efficiently incorporate software from a parent application, let’s discuss a practical example.
00:08:10.720
My first Rails engine was a little project I created called 'Position Full Game'. I started working on this before the first official Rails release.
00:08:20.399
This was potentially the second Rails engine created; the first was one by my friend José.
00:08:31.679
The beauty of Rails engines is that they allow the encapsulation of components like controllers, models, and views, which makes them an excellent choice for structuring applications.
00:08:42.400
As you can see, Rails engines are complex yet effective for organizing code and creating robust applications.
00:08:55.520
There is an advantage in that they can centralize logic through helpers as well, making it easier to manage code and enhancement iterations.
00:09:06.080
Now, let's take a look at the initial design concept, in contrast to the current version, which has evolved significantly.
00:09:19.920
This is where we can see the strength of utilizing Rails engines.
00:09:26.240
By focusing on modularization, we make upgrades and design iterations more feasible and manageable.
00:09:35.520
Let's pause for a moment and review what I've shared. I've discussed the principles behind Rails engines and their operational logic.
00:09:45.440
As I've shown, an engine serves as a gem that encapsulates multiple components and can operate like a miniature Rails application.
00:09:57.120
Next up, I want to highlight how this framework could further enhance our applications.
00:10:09.680
So, what I will do now is to showcase some practical examples of how to implement Rails engines effectively.
00:10:22.080
With that said, please let me walk you through some straightforward demonstrations.
00:10:35.440
Here is the first example of an engine called 'Entity Relationship Diagram' that I've developed.
00:10:42.080
This is not just an ordinary engine; it allows you to visualize complex models easily.
00:10:52.480
It integrates seamlessly with the main application by loading the necessary components to generate diagrams of entity relationships.
00:11:07.440
The design allows users to manipulate object relationships visually. You can add, modify, and save changes effectively.
00:11:22.960
What is great about this functionality is that it sidesteps the need for documentation or excessive programming.
00:11:36.640
The engine handles these processes, efficiently providing a clear view of interactions in a model's ecosystem.
00:11:49.040
In this setup, entities can be easily manipulated and positioned to generate the needed diagrams instantaneously.
00:12:00.480
It’s a straightforward but powerful addition to any graphical application, providing valuable insights.
00:12:12.080
At this stage, I’m hoping to add even more features and improvements to the engine for future releases.
00:12:21.840
Next, I will demonstrate another gem that I've been working on, which utilizes Rails engines beautifully.
00:12:36.080
This gem generates action diagrams that represent the interactions and relationships between different entities.
00:12:48.960
You’ll see it operates quite effortlessly when integrated into parent applications.
00:13:03.040
The tool creates visual representations of actions, such as getting and posting data, making it highly effective for understanding system interactions.
00:13:16.960
This should clarify further how Rails engines can offer an array of graphical utilities while maintaining simplicity.
00:13:28.400
Let me share one more example before I wrap up. This gem continues with the concept of visual interactions while simplifying the dependency chain.
00:13:45.280
This multiple engine supports browser actions effectively and retains the utility of an organized Rails environment.
00:14:01.600
As I've shown, the plugin remembers and logs the user actions, which enhances the overall user experience.
00:14:19.480
In conclusion, Rails engines provide a compelling way to enhance your web applications, promoting code reuse and modularity.
00:14:39.440
I'm excited to see how you will leverage these concepts in your own projects.
00:14:56.760
Thank you all for your attention, and I look forward to any questions or discussions you may have!
