Talks
Diary of a Mad Rails Engineer
Summarized using AI

Diary of a Mad Rails Engineer

by Akira Matsuda

In 'Diary of a Mad Rails Engineer,' Akira Matsuda discusses the powerful concept of Rails Engines at the LoneStarRuby Conference in 2013. He emphasizes the potential of Rails Engines as plugins that enable developers to create modular and reusable code structures within Ruby on Rails applications. The talk begins with Matsuda's introduction, where he shares his background and connection to the Ruby community, including his role in organizing Ruby Kaigi 2014.

Key points from the presentation include:

- Definition of Rails Engines: Matsuda defines Rails Engines as miniature applications, or plugins, which can encapsulate various components such as models, controllers, and views, allowing them to function like standalone Rails applications.

- Historical Context: He contrasts earlier Rails plugins with modern Rails Engines, noting how they evolved into gems that seamlessly integrate within the Rails ecosystem.

- Implementation Overview: He illustrates the process of creating a Rails Engine by developing a simple plugin that greets users on application startup. He explains the gem specifications, necessary directory structures, and loading mechanisms that Rails employs to manage engine components efficiently.

- Encapsulation and Modularity: Matsuda highlights the benefits of using Rails Engines for code organization and logic centralization, facilitating manageable upgrades and enhancing the overall structure of applications.

- Real-world Examples: The presentation features practical examples of engines he has developed, such as an 'Entity Relationship Diagram' engine that visually represents model relationships and an action diagram generator that maps interactions between different entities. Both tools simplify complex processes and improve user experience by providing visual insights.

In conclusion, Matsuda advocates for the use of Rails Engines to promote better coding practices through modular design and code reuse, encouraging developers to explore and implement these concepts in their projects. He wraps up his talk with an invitation for questions and further discussion, expressing enthusiasm for the potential of Rails Engines in enhancing web applications.

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!
Explore all talks recorded at LoneStarRuby Conf 2013
+21