DEV Community: nico_lrx

Any thoughts on how AI is going to change language learning?

nico_lrx — Sat, 11 Jan 2025 10:52:20 +0000

5 Ways AI Is Reshaping Language Learning Apps

nico_lrx ・ Jan 10

5 Ways AI Is Reshaping Language Learning Apps

nico_lrx — Fri, 10 Jan 2025 10:14:54 +0000

I’m a language nerd who speaks six languages. I’ve been using Duolingo for the past six years and love trying out new language learning apps.

Over the years, I’ve seen the shift from textbooks to online courses & gamified apps, but now artificial intelligence is taking things to a whole new level.

AI isn’t just speeding things up, it’s changing how we learn, practice, and memorize languages altogether. Here are 5 examples on how AI is quietly—but completely—reshaping the language learning experience.

1. Duolingo Max

Duolingo Max is a new subscription tier above Super Duolingo that gives learners access to two brand-new features and exercises: Explain My Answer and Roleplay. Both are powered by OpenAI’s models.

Explain My Answer is a feature in Duolingo that helps learners understand why their answers are right or wrong.

If you make a mistake and can’t figure out the correct answer—or if you keep repeating the same error—the AI gives you instant feedback.

After certain exercises, you can also tap a button to start a chat with Duo AI assistant. Duo explains the reasoning behind your response, whether it was correct or incorrect, and can provide examples or extra clarification if needed.
It’s like having a personal tutor built into the app, ready to clear up any confusion and help you learn from your mistakes.

Roleplay is another AI-powered feature that lets learners practice real-world conversations with characters in the app.

It’s designed to simulate real-life scenarios—like ordering coffee at a café in Paris, planning a vacation, or shopping for furniture—so learners can build confidence using the language in practical situations.

During the interaction, the AI adapts to the learner’s responses, making each conversation unique. After finishing, Duo provides personalized feedback on grammar, vocabulary, and sentence complexity, along with suggestions for improvement.

It’s like chatting with a teacher who’s always available and endlessly patient, no matter how many mistakes you make!

2. La langue française Automated Quizzes and Interactive Dictation Exercises

La langue française is the leading website for improving your French online. In addition to a wealth of articles on the complexities of French grammar, it offers a wide range of interactive exercises to help learners practice and refine their skills.

Over the past year, the website has leveraged cutting-edge AI technologies, including MistralAI and OpenAI’s models, to produce new quizzes and dictation exercises.

With over 2,000 grammar questions crafted by professional French teachers, they trained a model to generate new quiz questions quickly. Explanations of the quiz mistakes are also generated based on the site’s grammar content before being meticulously reviewed by the La langue française team.

Another standout feature is the “Dictée”, a classic French exercise where learners listen to a text and have to type it out without errors. These dictations are brought to life using AI voices powered by ElevenLabs, enabling the site to publish new dictation exercises almost instantly.

Since integrating AI to streamline the creation of its exercises, La langue française has seen an impressive 278% increase in engagement.

This serves as a prime example of how AI can be used creatively to boost productivity and deliver even greater value to customers.

3. Aimigo AI Learning Coach

Gymglish is a French company that specializes in teaching languages through fun and interactive lessons.

Their latest innovation, Aimigo, is an AI-powered personal language learning coach designed to provide tailored coaching sessions based on your skill level—similar to Duolingo’s Roleplay feature.

Aimigo offers a wide range of personalized activities, including conversational practice, speaking exercises, original stories, cultural insights, and more. It adapts to your level, learning goals, and pace, ensuring a fully customized learning experience to help you confidently master a new language.

Once again, Aimigo proves that, with the right content, AI can serve as an effective coach for mastering new skills.

4. TurkishFluent’s News Converter

TurkishFluent is an online course that teaches Turkish through real-life dialogues and interactive exercises.

Leveraging AI, it offers an innovative feature designed to help learners improve their reading skills. Powered by OpenAI, the Turkish News Converter simplifies news articles to match different proficiency levels (A1, B1, and C1), making advanced content accessible to learners at any stage.

In addition, the converter provides instant word translations and an English summary to further help comprehension.

By using AI to adapt complex texts for beginners, TurkishFluent allows learners to start reading from day one, turning real-world content into an engaging and motivating resource.

5. Your Best Accent: AI Voice Cloning for Pronunciation Training

I recently came across Your Best Accent on Reddit. This app uses AI-powered voice cloning technology to help you refine your accent in any language.

By creating a digital replica of your voice, the AI allows you to hear yourself speaking your target language with native-like pronunciation, offering a unique and effective way to improve your speaking skills.

In addition to voice replication, the app provides real-time feedback on your pronunciation, making it an invaluable tool for learners striving for fluency.

Your Best Accent is yet another example of how AI is revolutionizing language learning!

Conclusion

I believe we’re only scratching the surface of how AI will revolutionize language learning. As AI become more advanced, we’ll likely see even more personalized, interactive, and immersive experiences that make mastering a new language faster and more accessible than ever.

What other use cases do you imagine? How can we harness AI to make language learning even more effective? Share your thoughts in the comments!

How the tagging system work in Forem?

nico_lrx — Fri, 09 Dec 2022 08:09:15 +0000

Hello Dev Community!
I am building a Rails App and I need to add a tagging system for articles. I tried to analyze how tagging works in Forem but it's quite hard to understand the logic.

I see there is an index in the Article table called cached_tag_list. I guess the idea is to have a bridge between the Tags table and the Articles table, with a connection table for each article with a specific tag (article_id, tag_id).

Can anyone explain to me the logic to create an efficient tagging system with Rails? Thanks.

How to Use Stripe Checkout From a Rails Controller (Without Javascript)

nico_lrx — Tue, 23 Nov 2021 14:25:41 +0000

As I was launching my first French online course, I needed to use Stripe to process payments. The course was built using Ruby on Rails as it's the technology I am most proficient with.

However, I felt it was hard to create a simple experience for the end-user:

The user visits the Devise Registration page to create an account
When he/she clicks on the button to submit the form, he/she is redirected to Stripe Checkout to perform the payment

If you follow Stripe's logic, an event listener in Javascript will listen to the submission of the form, perform an Ajax call to create the Stripe session, and then redirect to Checkout.

However, this will prevent the normal submission of Devise's registration form. You will have to submit the Devise form using Ajax, which is not the easiest.

Here are a few steps to implement a simpler solution, using no Javascript. The whole Stripe logic is managed in a Rails controller.

Move Stripe's logic to Devise's Registration controller

After setting up Devise, you will have to generate Devise's controllers to be able to customize them. Just run the following command in your terminal:

rails generate devise:controllers users

Then, change the controllers to the devise_for routes:

devise_for :users, controllers: { registrations: 'users/registrations' }

Now we are all set to customize the after_sign_up_path_for method of the Registration controller.

First, we initialize the Stripe API Key.
Then, we create a session with our product's parameters.
Finally, we return the session URL. This will make the page to be automatically redirected to the Checkout generated URL.

def after_sign_up_path_for(resource)
    super(resource)

        Stripe.api_key = "#{ENV['STRIPE_API_KEY']}"

        # See https://stripe.com/docs/api/checkout/sessions/create
        # for additional parameters to pass.
        # {CHECKOUT_SESSION_ID} is a string literal; do not change it!
        # the actual Session ID is returned in the query parameter when your customer
        # is redirected to the success page.
        session = Stripe::Checkout::Session.create(
            success_url: "success_url",
            cancel_url: "cancel_url",
            payment_method_types: ['card'],
            mode: 'payment',
            line_items: [{
                # For metered billing, do not pass quantity
                quantity: 1,
                price: ENV['STRIPE_PRICE_ID']
            }],
            locale: "fr",
            customer_email: current_user.email
        )

        return session.url

  end

Listen to Stripe's webhook

After setting up the logic to redirect the user to Checkout, we need to listen to Stripe's events to make sure he/she completed the payment of the product.

Stripe has a comprehensive documentation about setting up webhooks so I won't enter into details here.

In our routes, we add the following line (assuming you have created a Stripe controller):

post 'webhook', to: "stripe#webhook"

In order to make it work, you need to initialize Stripe's API key. Add the following method to your Stripe controller, with a before action so it's called before the webhook method:

before_action :set_stripe_api, only: [:webhook]

...

  private 

  def set_stripe_api
    Stripe.api_key = "#{ENV['STRIPE_API_KEY']}"
  end

Then, we add the webhook method to the Stripe controller. We use here a case / when loop to process the events we are listening to (don't forget to register them in Stripe's webhook dashboard):

    def webhook
        payload = request.body.read
        event = nil

        begin
            event = Stripe::Event.construct_from(
                JSON.parse(payload, symbolize_names: true)
            )
        rescue JSON::ParserError => e
            # Invalid payload
            respond_to do |format|
                format.json { render json: { error: e }, :status => :bad_request } 
            end
        rescue Stripe::SignatureVerificationError => e
            # Invalid signature
            respond_to do |format|
                format.json { render json: { error: e }, :status => :bad_request } 
            end
        end

        data_object = event.data.object

        case event.type
        when 'charge.succeeded'
            # get the data (see doc)
            customer_id = data_object["customer"]
            email = data_object["billing_details"]["email"]
            # do something with the customer_id and email
            # ...
        else
            puts "Unhandled event type: #{event.type}"
        end

        respond_to do |format|
            format.json { render json: {}, :status => 200 } 
        end
    end

Voilà ! You have a working Stripe Checkout implementation without using any Javascript. When the user will submit the Devise registration form, he/she will be redirected automatically to Stripe Checkout!

Is clearing session data for edge caching mandatory?

nico_lrx — Mon, 25 Oct 2021 14:05:11 +0000

I try to replicate the Forem caching system for my Rails app. I just wonder if there is any security issues with keeping Session cookies while caching a page?

In Forem's controller concern, which sets cache headers, request.session_options[:skip] = true is skipping session cookies.

Could someone explain to me why? I use session data in order to redirect the user after login to the last page visited.

Thanks for your help, I am quite a noob about caching!

Wordpress Cron Job is not running

nico_lrx — Wed, 20 Nov 2019 17:21:28 +0000

Related to this post where I shared on DEV how to schedule articles using Buffer and the Wordpress Cron, it seems I misunderstood something about how Cron works...

Nov 20 '19 Comments: 4 Answers: 1

I set up a Wordpress Cron Job to run every 5 minutes and execute a function called bulk_update(). When I run the function manually through the admin, it works.

However, it seems the Cron job is not executing the function. I added error_log(print_r("EXECUTION OF BULK_UPDATE"));to the beginning of…

Open Full Question

Any help appreciated ;)

How to Automatically Share Your Wordpress Articles with Buffer and Cron

nico_lrx — Mon, 18 Feb 2019 12:30:12 +0000

For bloggers writing a lot of articles, it's a kind of a headache when it comes to sharing them on Social Media. We usually do it after publishing and then forgot to share it again on a regular basis, hence losing a whole bunch of potential readers.

That's why I decided to automatize the Social Media publications for my Wordpress blog, using Cron and the Buffer API. Cron in Wordpress allows you to schedule time-based tasks. Buffer is a service to schedule posts on Social Media.

Let's set up the new cron job

First, we need to set up the new Wordpress cron job. The cron system comes with default intervals of hourly, twicedaily, and daily. However, it's possible to define your own interval:

// We add a new interval running the task every three hour
add_filter( 'cron_schedules', 'example_add_cron_interval' );
function example_add_cron_interval( $schedules ) {
    $schedules['three_hours'] = array(
        'interval' => 10800,
        'display'  => esc_html__( 'Every Three Hours' ),
    );

    return $schedules;
}

The parameter interval is an integer for the duration in seconds. With this code, you can now use the new cron interval "three_hours".

Then, we need to add the new cron task. We can add a button in our admin menu in order to do that:

function buffer_init_cron() {
    if ( ! wp_next_scheduled( 'buffer_cron_hook' ) ) {
    wp_schedule_event( time(), 'three_hours', 'buffer_cron_hook' );
        echo '<pre>'; print_r( _get_cron_array() ); echo '</pre>'; // to confirm that the new cron job is scheduled
    }
}

function add_buffer_menu_item_cron() {
  // $page_title, $menu_title, $capability, $menu_slug, $callback_function
  add_menu_page(__('Schedule Cron Buffer Posts'), __('Schedule Cron Buffer Posts'), 'manage_options', 'buffer_menu1', 'buffer_init_cron');
}
add_action('admin_menu', 'add_buffer_menu_item_cron');

Pressing the button "Schedule Cron Buffer Posts" in the admin menu will initialize the cron job.

wp_schedule_event takes three parameters: the first time that you want the event to occur, the recurrence (three hours in that case), and the function to call that links the cron to a function to execute. For this last parameter, we need to add this action:

add_action( 'buffer_cron_hook', 'buffer_schedule_posts' );

If you want to be able to manage your cron intervals and cron jobs, you can install the WP Crontrol plugin. This plugin will allow you to create new intervals, to run your cron jobs directly in the admin panel, to create and remove cron jobs.

Create the function to schedule posts with the Buffer API

In the buffer_schedule_posts function we want to get a random post:

        $args = array(
                'post_type' => 'post',
                'orderby'   => 'rand',
                'posts_per_page' => 1,
                );

        $the_query = new WP_Query( $args );

Then, we want to extract the relevant information in order to create the text of the Social Media publication. In my case, I wanted to get the title of the post, the excerpt for the description of Social Media's rich cards, and of course the URL.

    if ( $the_query->have_posts() ) {
            while ( $the_query->have_posts() ) {
                $the_query->the_post();
                $page_title = get_the_title();
                $page_description = get_the_excerpt();
                $link = get_permalink();
                $text = $page_title . " " . $link;
            }
        }

The Buffer API provides an access token. I create a function with the code above in order to return a $fields variable containing the POST parameters needed for the API to run.

    // we get a random pages
    function wpb_rand_posts() {

        $args = array(
                'post_type' => 'post',
                'orderby'   => 'rand',
                'posts_per_page' => 1,
                );

        $the_query = new WP_Query( $args );

        if ( $the_query->have_posts() ) {

            while ( $the_query->have_posts() ) {
                $the_query->the_post();
                $page_title = get_the_title();
                $page_description = get_the_excerpt();
                $link = get_permalink();
                $text = $page_title . " " . $link;

                $fields = "access_token=YOUR_TOKEN&text=" . $text . "&profile_ids[]=YOUR_PROFILE_ID&media[link]=".$link."&media[description]=".$page_description."&now=false";

        }
            return $fields;
            /* Restore original Post Data */
            wp_reset_postdata();
        }
    }

Great, we get a random page with all the information needed for the Social Media publication! One last step is to perform the Buffer API call, using Curl:

    $ch = curl_init();

    $page_fields = wpb_rand_posts();

    curl_setopt($ch, CURLOPT_URL,"https://api.bufferapp.com/1/updates/create.json");
    curl_setopt($ch, CURLOPT_POST, 1);
    curl_setopt($ch, CURLOPT_POSTFIELDS, $page_fields);
    curl_setopt($ch, CURLOPT_HTTPHEADER, array('Content-Type: application/x-www-form-urlencoded'));

    // Receive server response ...
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

    $server_output = curl_exec($ch);

    curl_close ($ch);

Voilà! We have our buffer_schedule_posts function, running every three hours to publish a post via Buffer. Sit back and relax 😎

How to Easily Avoid Hitting the Memory Limit on Heroku

nico_lrx — Thu, 12 Apr 2018 16:01:04 +0000

Heroku is a great tool to launch a new app easily. However, dynos can quickly reach their limit if your app is memory intensive. It was the case of my Rails app and I started to spend way more money than expected!

If you have already optimized memory following those Heroku tips, it's time to find another solution to avoid spending too much money.

How to restart Heroku dynos periodically

One efficient workaround is to restart dynos when the memory limit is close. Unfortunately, you will have to pass the whole day (and night!) in front of your computer if your app is leaking memory!

The solution is to create a scheduled task to restart the dynos consuming too much memory before they hit the limit.

Write a task in your app

First, add the platform-api gem to your Rails app:

gem 'platform-api'

bundle install

Create an OAuth token using the heroku-oauth toolbelt plugin:

$ heroku plugins:install heroku-cli-oauth
$ heroku authorizations:create -d "Platform API example token"
Created OAuth authorization.
  ID:          2f01aac0-e9d3-4773-af4e-3e510aa006ca
  Description: Platform API example token
  Scope:       global
  Token:       e7dd6ad7-3c6a-411e-a2be-c9fe52ac7ed2

Then, create a scheduler.rake file in the lib/tasks folder of your Rails app.

  require 'platform-api'

  task :restart_dyno => :environment do
    puts "task restart_worker is on"
    heroku = PlatformAPI.connect_oauth(YOUR OAUTH TOKEN)
    heroku.dyno.restart("APP_NAME", "web.1")
  end

You can specify which dyno you want to restart by passing its name. According to the documentation, you can also restart all dynos at the same time:

  require 'platform-api'

  task :restart_dyno => :environment do
    puts "task restart_worker is on"
    heroku = PlatformAPI.connect_oauth(YOUR OAUTH TOKEN)
    heroku.dyno.restart_all("APP_NAME")
  end

Schedule your task

In order to perform a task on a repetitive basis, you will have to install the Heroku Scheduler add-on.

The Scheduler comes with a frequency limitation: you can only choose between "Daily", "Hourly" or "Every 10 minutes".

In case those frequencies are not ideal regarding your memory consumption, you can add a condition in your task to match the frequency you want. For example, if you want to restart your dyno twice a day:

  require 'platform-api'

  task :restart_dyno => :environment do
    t = Time.now.strftime('%H')
    if t == "07" or t == "14"
        puts "task restart_worker is on"
        heroku = PlatformAPI.connect_oauth(YOUR OAUTH TOKEN)
        heroku.dyno.restart("APP_NAME", "web.1")
    end
  end

Once you have defined your frequency, add a new job to the Scheduler: rake restart_dyno.

Now, you will have your dynos restarting automatically before hitting the memory limit. If you have any questions, feel free to contact me on Twitter.