DEV Community: Andrew Molchanov

Introduction to Lecter or quick and easy investigation of web applications

Andrew Molchanov — Sun, 12 Jun 2022 14:05:57 +0000

You're looking, but you're not seeing.
Hannibal Lecter

Today we gonna talk about Rails based applications.

The Problem

We all know that modern web applications are complex. Their structure can be so intricate that it takes a new developer to understand what it is dealing with. Think about it: programmers spend dozens of hours learning other people's code, writing down callable classes, and simply comprehending the business logic of the project.

An experienced reader will say: document your code, and life will become easier. Maybe in the best of both worlds, everyone really does, but in the actual world, the code looks different for some reason.

Ajith disliked this part of his work the most. In general, digging through someone else's code is not fun right away. Even when the code is well structured and described. And if strange naming is used, or if there are strange strange strange clues that only the author understands, you really want to drop everything.

But giving up was impossible: Ajith had just been given a legacy project which he have to:
a) investigate
b) give tasks to two juniors
c) outline a plan of finalization for the company's needs.

So, as usual, we launch the IDE, set breakpoints, and try to understand the creator's somewhat insane logic. Ajith put a call notepad next to him, poured a large cup of coffee, and proceeded to parse...

Here's a simple example: let's say we're learning a simple application like a blog. To have something to learn, let's create it by ourselves :) To speed up development, we will use scaffolding. Let's scaffold a Post model, create a database, and run the migrations.

Then we will start to study. To understand how the application works, we must know where the request is sent. In our blog, it will be /posts.

Then we need to do the following steps:

Find the correct endpoint in the routes.rb file.
Define the controller.
Find the required action in the controller.
Analyzing the code, go from the called classes deep into the application, keeping in mind at the same time the meaning and modification of input parameters and headers.
Keeping the entire chain of calls in mind.

It wasn't hard, was it? Now imagine we're facing a legacy application with a flawed architecture. Plus, the project uses the illogical naming of classes and modules. Also, it doesn't follow basic development patterns. All of this leads to the fact that you can't visualize the whole chain of called classes and can't get a complete picture of the work.

Ajith was on a roll! For the third day, he had been tinkering with the application, trying to understand how it worked. He had the feeling that the project was just teasing him, leading him to a dead-end over and over again.

It is believed that the programmer works by the Pareto rule when he or she interacts with a new project: 80% of the time he or she studies other people's code and 20% writes his or her own. Our hero could not get to the desired 20%.

During my career, I have dealt with onboarding specialists and decomposing projects into tasks to be reworked hundreds of times. Such work is very time-consuming, and any experienced developer will attest to that. If you use an IDE it will help you to save time because you will immediately see the available variables and their values. I also usually recommend using breakpoints, in order to avoid confusion with too many if expressions.

Sometimes ago, being under time pressure and trying to guide new employees in the right direction, I started thinking about automating the task of application analysis. The tool I wanted to develop had to solve four important tasks:

Reduce the onboarding period for a new developer.
Increase the expertise of unknown application components.
Allow you to quickly read a legacy project.
Be used to analyze open-source libs.

The Solution

After several months of development, the Lecter project appeared, allowing you to delve into the innards of web applications (distributed under the MIT License). The name is a little funny, but I wanted to get something more intellectual than a simple Jack the Ripper :) In my opinion, it turned out just right.

To illustrate how Lecter works, let's return to the blog application example. Before we start the analysis, we need to perform some preparatory steps:

Set to use more than one worker for the puma: workers: 3
Let's add a gem to the Gemfile: gem 'lecter'
Run the command: bundle install
Add new Routes to routes.rb mount Lecter::Engine => '/lecter' if Rails.env.development?

Now we are ready to explore our application. To do that let's go to http://localhost:3000/lecter and fill out the form with the following parameters:

HTTP method: POST
Endpoint: localhost:3000/posts
Headers: content_type=text/html,accept=*/*
Body(raw): "post"=>{"title"=>"New title", "description"=>"Desciption"}

Then we press a submit button and see the result:

As you can see from the example, we will immediately see:

All called classes in the right order.
The order in which the lines are executed in each file is shown.
All the codes to be called will be on the same page.
We get class listings.
...and there is even a highlighting.

That's just great! Hint: if we have a lot of files, we will see the whole chain of code being executed.

In Sanskrit, Ajit translates as "one who is not defeated. Using Lecter Ajit was able to quickly read the legacy code and find the transition that was driving him crazy.

Ajit is sure that the next time he needs to investigate someone else's the legacy project, he will use this tool again.

Shortcomings of the solution and development plans

As you can see, I love my Lector. It has already saved me dozens or hundreds of hours of work (which could be spent on reworking it, haha). But alas, my Lector is not yet perfect. For example, its code analysis is available only through API endpoints. I understand that I can evolve towards Kafka, RabbitMQ, and take jobs from Redis, gut web sockets, and webhooks, but this direction still needs to be thought over. That's why I'd be grateful if you could tell me your opinion on the project development in the comments.

I understand that Lecter is not yet flexible enough. In the future, I plan to add options to hide some structural files and/or entire folders.

In addition, I am looking for maintainers for the project to make it perfect. There are some issues which you could choose. If you like it, please give it a star on the github page.

Write me and I would be happy to discuss his work with you.

Ruby interview questions

Andrew Molchanov — Mon, 23 May 2022 20:48:18 +0000

In this post, I've created a collection of Ruby basics for a Middle-level developer.

In common cases, interviewers have a pre-prepared set of tasks. While others prefer a conversation about experience mixed with technical questions. On the other hand, some companies care most about soft skills. But all of these understand one thing correctly. An interview is a costly process. All companies want to decrease costs.

After interviewing for many companies, there is an understanding that the candidate should know and be able to apply the basic principles on which modern applications are built. Although in my practice there has been no such thing as an interview ending after the first wrong answer, there are basics that need to be understood ahead of time.

A Junior developer is not tied to the programming language in any way, but a Senior can write more complex code. Then if you can solve these problems without any hints, most of the practical preparation for the Middle position is passed and you can focus on other topics during preparing for an interview.

1. Implement the method Array#map

A possible answer

class Array
  def map
    return unless block_given?

    result = []
    i = 0

    while self[i] do
      result << yield(self[i])
      i += 1
    end

    result
  end
end

Checking the usage

[1,2,3,4].map { |x| x * 10 }

2. Implement the method attr_accessor

A possible answer

module AttrAccessor
  def self.included(klass)
    klass.extend(ClassMethods)
  end

  module ClassMethods
    def custom_attr_accessor(*args)
      args.each do |arg|
        define_method(arg) do
          self.instance_variable_get("@#{arg}")
        end

        define_method("#{arg}=") do |value|
          self.instance_variable_set("@#{arg}", value)
        end
      end
    end
  end
end

Checking the usage

class Car
  include AttrAccessor
  custom_attr_accessor :wheels_count, :driver_name
end

car = Car.new
car.wheels_count = 4
car.wheels_count

car.driver_name = 'Kevin'
car.driver_name

3. Refactor the code by removing `if`s

class HtmlFormatter
  def initialize(body)
    @body = body
  end

  def to_s
    "<body>#{@body}</body>"
  end
end

class JsonFormatter
  def initialize(body)
    @body = body
  end

  def to_s
    "{ body: #{@body} }"
  end
end

class Text
  def initialize(body)
    @body = body
  end

  def formatted(type=nil)
    if type == :json
      JsonFormatter.new(@body)
    elsif type == :html
      HtmlFormatter.new(@body)
    else
      raise 'an unknown format type'
    end
  end
end

A possible answer

class Text
  def initialize(body, formatter)
    @body = body
    @formatter = formatter
  end

  def formatted
    @formatter.render(@body)
  end
end

class BaseFormatter
  def render(text)
    raise 'Not implemented :render method'
  end
end

class HtmlFormatter < BaseFormatter
  def render(text)
    "<body>#{text}</body>"
  end
end

class JsonFormatter < BaseFormatter
  def render(text)
    "{ body: #{text} }"
  end
end

class XmlFormatter < BaseFormatter
end

Checking the usage

text = Text.new('Text', JsonFormatter.new)
puts text.formatted

4. Write a code which help a command `(1..10).select(&3)` return `[3, 6, 9]`

A possible answer

class Fixnum
  def to_proc
    Proc.new { |item| item % self == 0 }
  end
end

5. There is a code

class Post
  attr_reader :state, :title, :body

  def initialize(title, body)
    @title = title
    @body = body
    @state = :draft
  end

  def publish!
    @state = :published if @state == :draft
  end

  def delete!
    @state = :deleted if @state == :published
  end
end

Extend the functionality of the class Post which allows changing any attribute of an instance of Post.
For example, Post.new.force_title('An awesome article') will be correct.

A possible answer

module Forceable
  def method_missing(method, *args, &block)
    if method =~ /force_(\w+)/ && previous_value = self.instance_variable_get("@#{$1}")
      self.instance_variable_set("@#{$1}", args.first)

      puts "Post changes #{$1} value from #{previous_value} to #{args.first}"
    else
      super
    end
  end
end

Post.include(Forceable)

Checking the usage

post = Post.new('Title', 'Body')
post.force_state(:draft)
p post.state

Ruby quiz

Andrew Molchanov — Mon, 23 May 2022 19:39:02 +0000

Hi, dev.to!
Here is my first post there. I hope there are people who like mind games. So I would like to introduce you to some interesting puzzles.

1. Choose the correct result of the code (ruby 3.0):

{ language: 'ruby’, 'position' => 'engineer' }.transform_keys({ language: 'rust’ }, &:to_sym)

{"rust"=>"ruby", :position=>"engineer"}
{ :rust => 'ruby', :position => 'engineer' }
{ "rust" => :ruby, 'position' => :engineer }
{ :rust => :ruby, :position => :engineer }

Answer {"rust"=>"ruby", :position=>"engineer"}

2. Choose the correct result of the code (ruby 3.0):

{ e: :n, g: :i, n: :e, e: :r }.except(:e)

NoMethodError (undefined method 'except')
{:g=>:i, :n=>:e}
{:g=>:i, :n=>:e, :e => :r}
{:e => :n, :g=>:i, :n=>:e}

Answer
{:g=>:i, :n=>:e}

3. Choose the wrong way to call a lambda

->(){}::call
->(){}[]
->(){}()
->(){}::===

Answer
->(){}()

4. Choose the correct result of the code

!?q::!. |001

true
false
raise an error
1

Answer
false

5. Choose the correct way to create an array [0,1,2,3,4,5]

Array[0..5]
(0..4).take(5)
[*0..5]
String(012345).split('').map(&:to_i)

Answer
[*0..5]

6. There is a code

class Animal
  @@count = 0

  def self.inc
    @@count += 1
  end

  def self.count
    @@count
  end  
end

class Cat < Animal
  @@count = 100

  def self.count
    @@count
  end
end

Animal.inc
Cat.inc

Choose the correct result of the code

[Animal.count, Cat.count]

[1, 101]
[101, 101]
[1, 102]
[102, 102]

Answer
[102, 102]

7. There is a code

class Item
  def self.count
    $COUNT
  end

  def self.increment
    $COUNT += 1
  end
end

BEGIN { $COUNT = 0 }
Item.increment

Choose the correct result of the code

Item.count

0
1
101
undefined method '+' for nil:NilClass

Answer 1

DEV Community: Andrew Molchanov

Introduction to Lecter or quick and easy investigation of web applications

The Problem

The Solution

Shortcomings of the solution and development plans

Ruby interview questions

1. Implement the method Array#map

2. Implement the method attr_accessor

3. Refactor the code by removing ifs

4. Write a code which help a command (1..10).select(&3) return [3, 6, 9]

5. There is a code

Ruby quiz

1. Choose the correct result of the code (ruby 3.0):

2. Choose the correct result of the code (ruby 3.0):

3. Choose the wrong way to call a lambda

4. Choose the correct result of the code

5. Choose the correct way to create an array [0,1,2,3,4,5]

6. There is a code

Choose the correct result of the code

7. There is a code

Choose the correct result of the code

3. Refactor the code by removing `if`s

4. Write a code which help a command `(1..10).select(&3)` return `[3, 6, 9]`