Forem: Deotyma

Starting June 2025, the European Accessibility Act makes digital accessibility legally mandatory across the EU. Developers must comply with WCAG 2.1 AA for websites, apps, and digital services—or risk audits, fines, and legal issues.

Deotyma — Thu, 24 Apr 2025 10:13:04 +0000

Deotyma

Apr 24 '25

From June 2025, Accessibility Becomes Mandatory Across the EU – Here’s What Developers Need to Know

#news #webdev #a11y #design

Comments 1

4 min read

From June 2025, Accessibility Becomes Mandatory Across the EU – Here’s What Developers Need to Know

Deotyma — Thu, 24 Apr 2025 10:11:19 +0000

If you’re building digital products for the European market, June 28, 2025 is a date you need to highlight in red on your calendar.

That’s when the European Accessibility Act (EAA) officially takes effect, making digital accessibility legally required for a wide range of consumer-facing digital services—not just public institutions, but private companies too.

📜 The Legal Framework

Here’s how the law evolved over time.

First, the Directive 2016/2102 (EU) came into force in 2018. It only applied to public sector websites and apps.

Now, the Directive 2019/882 (European Accessibility Act) will take effect on June 28, 2025, extending accessibility obligations to the private sector across all EU member states.

This means that if you’re developing digital products—websites, apps, SaaS—that target EU consumers, they’ll need to be accessible according to WCAG 2.1 (AA level), no matter when they were launched.

Even services released before the 2025 deadline must be updated if they’re still publicly available.

🚨 Who Is Affected?

The EAA applies to a wide range of digital services.

If you operate an e-commerce site, an online booking platform, a banking or financial application, an e-book or e-learning platform, or any software with a user interface, you are affected.

In short, if your product is consumer-facing and operates in the EU, it falls under this law—regardless of the launch date.

✅ What Are the Technical Requirements?

To comply, your product must meet the criteria defined in WCAG 2.1 Level AA.

Every image, logo, or icon must include alt text so that screen readers can interpret the visuals for users with visual impairments.

Text color and background must maintain a minimum contrast ratio of 4.5:1 for normal text and 3:1 for large text, ensuring legibility for people with low vision.

All functionalities must be accessible using only a keyboard. That means every menu, button, and form must respond to inputs like Tab, Enter, Space, and ESC.

HTML must be structured with semantic headings such as <h1>, <h2>, and appropriate ARIA attributes. This allows assistive technologies to interpret and navigate the content more effectively.

Forms must include clear labels and error messages. Messages like "Invalid data" are not enough—users need to know exactly what went wrong and where.

Finally, the interface must remain usable when zoomed in up to 200%, and adapt well to all screen sizes, including mobile devices.

🇫🇷 Who Will Enforce This in France?

Several national authorities will be responsible for enforcing accessibility compliance in France.

ARCOM will handle digital content and audiovisual services. DGCCRF will oversee commercial and consumer-facing digital services such as e-commerce and financial platforms. ARCEP will regulate telecom and electronic communication services.

Users will have the right to report accessibility issues. Once a complaint is filed, authorities may initiate audits. Companies will have 30 days to fix violations before facing penalties.

💣 What Are the Risks?

Non-compliance may lead to financial penalties. For repeated offenses, fines can reach €15,000 for legal entities.

In addition, companies may receive public reprimands, potentially damaging their reputation. If the product was funded through public programs or grants, the company could lose eligibility or funding entirely.

👨‍💻 Developer & Tech Team Responsibilities

If you’re a freelancer, and your contract includes language about legal compliance, you’re legally obligated to deliver an accessible product. Clients may even withhold payment if the product doesn't comply.

To protect yourself, make sure your contract specifies whether accessibility compliance is included or not—and always inform the client clearly.

If you're working in B2B or agency settings, your employer or the agency technically holds the legal liability. However, if you’re aware of the law and knowingly deliver a non-compliant product, the agency or client may hold you accountable under "regression" liability.

The safest route is to notify your manager or product owner and document the communication in tools like Jira or email.

As a CTO, founder, or product owner, you bear full responsibility. If your product is flagged for inaccessibility, you may have to pay for retroactive fixes, face user complaints or legal action, and risk product suspension if it's deemed critical (e.g., banking or public service apps).

Now is the right time to start preparing. You don’t need a huge budget to begin. Free tools like axe, WAVE, and Chrome's Lighthouse can help you start identifying accessibility gaps.

🚀 What You Can Do Today

Start by learning the WCAG 2.1 (AA) guidelines—there are tons of resources online.

Raise awareness within your team, especially if you're working in agile environments. Accessibility often gets overlooked unless someone advocates for it.

Talk to your clients or product stakeholders. They might not even know that the law applies to them.

Include accessibility in your contracts and proposals. This can protect you legally, and helps clients understand the importance of compliance.

Plan an accessibility audit for your current products and workflows. Build accessibility into your next sprint, code review, or QA checklist.

Digital accessibility is no longer just a “nice to have.” It’s becoming a legal obligation—and an ethical imperative.

If you're a developer, designer, or digital founder working with EU users, don’t wait until 2025. Start integrating accessibility into your dev workflows now.

The Luhn Algorithm — Validating Numbers the Smart Way

Deotyma — Thu, 10 Apr 2025 10:16:08 +0000

When applying for jobs as a junior developer, one of the common algorithm questions you might encounter is the Luhn Algorithm. It’s simple, clever, and widely used in the real world, especially in banking and telecommunication. Understanding this algorithm not only helps you sharpen your logic skills but also gives you insight into how some real systems validate important information like credit card numbers.

What is the Luhn Algorithm?

The Luhn algorithm, also called the "modulus 10" algorithm or "mod 10", is a checksum formula. It was developed in 1954 by Hans Peter Luhn, an engineer at IBM. The main purpose of this algorithm is to verify whether a sequence of numbers is valid, usually for identification or payment purposes.

While it does not protect against fraud (it’s not encryption), it helps to catch simple human errors such as a single digit mistyped or digits swapped by accident. This is extremely useful when working with long strings of numbers.

Where is it used?

The Luhn algorithm is widely used in real-life applications. It is used by credit card companies (Visa, Mastercard, American Express), in mobile phone IMEI numbers, and even in some national ID numbers. Whenever a form tells you “this card number is invalid” before you even click submit, it is probably using Luhn to validate it.

Problem Statement

You are given a string that represents a card number. The number may include spaces or dashes. Your task is to write a function that verifies whether this number is valid using the Luhn algorithm.

The function should return true if the number is valid and false otherwise.

Pseudocode

Before jumping into real code, let's write down the logic of the Luhn algorithm in plain pseudocode:

function isValidLuhn(number):
    clean the input by removing spaces and dashes
    reverse the cleaned number
    initialize total to 0

    for each digit in the reversed number:
        if the digit is in an even position (starting from 0):
            add the digit to total as is
        if the digit is in an odd position:
            double it
            if the result is greater than 9:
                subtract 9 from the result
            add that result to total

    if total modulo 10 is 0:
        return true (number is valid)
    else:
        return false (number is invalid)

This pseudocode captures the essence of the algorithm and will guide us when implementing it in real programming languages.

Python:

def verify_card_number(card_number):
    sum_of_odd_digits = 0
    card_number_reversed = card_number[::-1]
    odd_digits = card_number_reversed[::2]

    for digit in odd_digits:
        sum_of_odd_digits += int(digit)

    sum_of_even_digits = 0
    even_digits = card_number_reversed[1::2]
    for digit in even_digits:
        number = int(digit) * 2
        if number >= 10:
            number = (number // 10) + (number % 10)
        sum_of_even_digits += number

    total = sum_of_odd_digits + sum_of_even_digits
    return total % 10 == 0

def main():
    card_number = '4111-1111-4555-1141'
    cleaned = card_number.replace('-', '').replace(' ', '')

    if verify_card_number(cleaned):
        print('VALID!')
    else:
        print('INVALID!')

main()

JavaScript:

function verifyCardNumber(cardNumber) {
    const cleaned = cardNumber.replace(/[\s-]/g, '');
    const reversed = cleaned.split('').reverse();
    let total = 0;

    for (let i = 0; i < reversed.length; i++) {
        let digit = parseInt(reversed[i]);

        if (i % 2 === 1) {
            digit *= 2;
            if (digit > 9) digit -= 9;
        }

        total += digit;
    }

    return total % 10 === 0;
}

console.log(verifyCardNumber("4111-1111-4555-1141") ? "VALID!" : "INVALID!");

Java:

public class LuhnCheck {

    public static boolean verifyCardNumber(String cardNumber) {
        String cleaned = cardNumber.replaceAll("[\\s-]", "");
        int total = 0;
        boolean doubleDigit = false;

        for (int i = cleaned.length() - 1; i >= 0; i--) {
            int digit = Character.getNumericValue(cleaned.charAt(i));
            if (doubleDigit) {
                digit *= 2;
                if (digit > 9) digit -= 9;
            }
            total += digit;
            doubleDigit = !doubleDigit;
        }

        return total % 10 == 0;
    }

    public static void main(String[] args) {
        String number = "4111-1111-4555-1141";
        System.out.println(verifyCardNumber(number) ? "VALID!" : "INVALID!");
    }
}

Real-World Applications

The Luhn algorithm is not just an exercise. It is used in many systems that need to validate identifiers quickly and reliably. Credit cards are the most famous example. Before a payment is even processed, the system checks whether the card number could be valid using the Luhn algorithm.

Phone manufacturers also use it to validate IMEI numbers, which are unique to each mobile device. Some government-issued identification numbers use similar validation techniques to reduce human error during registration.

Going Further

To go deeper into this topic, here are some interesting questions you can try to answer:

What changes would you make to generate a valid card number instead of just checking it?
Can you adapt this algorithm to detect other types of errors, like swapped digits?
What are other checksum algorithms used in the real world, and how do they compare to Luhn?
Can you implement the algorithm in a functional programming style using languages like Haskell or Scala?
How would you optimize your implementation for verifying millions of numbers quickly in a database?

The Luhn algorithm is a perfect example of how a small piece of logic can have a big impact in real systems. By practicing it, you’re not only preparing for coding interviews but also learning how developers build safer and more reliable applications.

Loglan'82, a historical informatic language, introduced advanced object-oriented programming, secure memory management, and built-in concurrency. Though forgotten, it could be an inspiration for new solutions in modern programming languages.

Deotyma — Thu, 20 Mar 2025 19:22:04 +0000

Loglan'82: A Forgotten Programming Language Ahead of Its Time

Deotyma ・ Mar 20

#programming #opensource #coding

Loglan'82: A Forgotten Programming Language Ahead of Its Time

Deotyma — Thu, 20 Mar 2025 16:18:47 +0000

Introduction

On March 15, 2025, I had the opportunity to present a six-minute talk as part of Les Conférences Éclair during the Assemblée Générale of APRIL, the French association dedicated to the defense of open source software. My talk focused on Loglan'82, a forgotten but pioneering programming language developed in the 1980s at the Institute of Informatics, University of Warsaw.

In this short presentation, I highlighted how Loglan'82 introduced advanced object-oriented programming, secure memory management, and built-in concurrency support—features that were revolutionary at the time and are still relevant today. Despite its technical strengths, the language remained largely confined to academia and never gained widespread industry adoption. My goal was to shed light on this overlooked language and spark interest in its innovative approach to software design, particularly within the free software community.

This article expands on my talk, providing a deeper look into the history, key features, and legacy of Loglan'82.

Origins and Development

The story of Loglan'82 begins with the creation of the MERA-400, one of the first Polish minicomputers. The research team, led by Elżbieta Jezierska-Ziemkiewicz, initially considered using Fortran but found it unsuitable for their needs. Inspired by Simula 67, the team decided to create a new language that could fully leverage object-oriented programming and concurrent execution.

Key contributors to Loglan'82 include Andrzej Salwicki, Hanna Oktaba, Wiesława Bartol, and Antoni Kreczmar, among others. The project was ambitious, incorporating features that would later be seen in Java and modern concurrent programming paradigms.

Key Features of Loglan'82

Loglan'82 was decades ahead of its time, offering functionalities that even today’s languages struggle to implement efficiently.

Object-oriented programming in Loglan'82 was more advanced than in Java, which enforces single inheritance. Loglan'82 allowed multiple inheritance, deep multi-level inheritance, and inheritance within functions and modules. This flexibility provided a more powerful way of structuring software systems.

Memory management in Loglan'82 was particularly innovative. It introduced safe object deallocation through the kill(x) instruction, which ensured that once an object was deleted, all references to it were automatically set to none, preventing dangling references. This provided an alternative to garbage collection, offering direct memory management without the risk of memory leaks.

Parallel and distributed computing were integral to Loglan'82. The language was designed with processes as first-class objects, enabling true parallel execution. It supported coroutines with built-in suspend and resume functionality, allowing seamless concurrency. A major breakthrough was the Alien Call mechanism, which enabled inter-process communication in a way that was both simpler and more efficient than Java RMI or CORBA.

Exception handling was another key feature, providing structured error recovery. The concurrent programming model in Loglan'82 eliminated common pitfalls like race conditions and deadlocks by enforcing structured inter-process communication.

Example Code in Loglan'82

The syntax of Loglan'82 was similar to Pascal, making it relatively easy to learn for those familiar with structured programming. The following is a simple example of a "Hello, World!" program:

program HelloWorld;

begin
    write("Hello, World!");
end.

Loglan'82 is a Typed Language

Loglan'82 is a strongly typed programming language, meaning that every variable must be explicitly declared with a specific type before it can be used. This ensures type safety, reducing errors related to unintended type conversions or misuse of data. Unlike dynamically typed languages where variables can hold values of different types at runtime, Loglan'82 enforces strict type rules at compile-time, preventing operations between incompatible types.

Types in Loglan'82

According to the provided documentation, Loglan'82 supports the following primitive types:

int (integer) – Represents whole numbers, similar to int in C or Java.
real (floating-point number) – Used for decimal numbers, equivalent to float or double in modern languages.
char (character) – Represents a single character, similar to char in C.
bool (boolean) – Can hold the values true or false, used for logical operations.
string (string of characters) – Only constant strings are allowed, meaning they cannot be modified at runtime.

Complex Types and Data Structures

In addition to basic types, Loglan'82 also provides more complex types and structured data representation, allowing programmers to create modular and object-oriented designs.

arrayof <type> – Defines an array of a given type, supporting multidimensional and dynamic arrays with runtime-determined bounds.
unit <name> : class – Defines a class, which can have attributes and methods. This is an extension of the record-based structures seen in Pascal.
process – A special type used for concurrent programming, where each process is treated as an object.
coroutine – A specialized construct that allows execution to be suspended and resumed, enabling cooperative multitasking.

Type Checking and Safety

Loglan'82 enforces strong type checking at both compile-time and runtime. This means that:

Every variable must be declared with a type before it is used.
Functions and procedures must have clearly defined parameter types and return types.
Operations between different types (e.g., adding an int to a real) require explicit type conversion.
Type safety is guaranteed when handling memory allocation and deallocation, particularly with the kill(x) instruction, which prevents dangling references.

program SumTwoVariables;

const a = 1;
var b, sum: real;

begin
    b := 2.5;
    sum := a + b;
    write("Result: ", sum);
end.

Comparison with Java

Loglan'82 introduced many features that Java adopted years later but in a more structured and efficient manner. Unlike Java, which relies on single inheritance and interfaces, Loglan'82 supported multiple and deep inheritance, providing more flexibility in designing software architectures.

Memory management in Loglan'82 was safer, as the kill(x) instruction ensured objects were properly deallocated, whereas Java relies on garbage collection, which can lead to performance issues.

Concurrency was a fundamental part of Loglan'82. Instead of Java's threads and complex concurrency models requiring frameworks like Spring Cloud or Kubernetes for distributed computing, Loglan'82 included built-in support for processes and coroutines. The Alien Call mechanism provided a more efficient way of handling inter-process communication compared to Java RMI or gRPC.

Characteristic	Loglan'82	Java
Object Model	Multiple and hierarchical inheritance	Single inheritance with interfaces
Memory Management	`kill(x)`, secure object deletion	Automatic Garbage Collector, no manual deletion
Concurrent Programming	Object-based processes, native coroutines	Threads (Thread, ExecutorService), coroutines possible with Kotlin
Distributed Programming	Built-in support (Alien Call)	Requires external tools (Spring Cloud, RMI, gRPC)
Inter-process Communication	Simple, via Alien Call	Complex, via RMI, CORBA, gRPC

Why Did Loglan'82 Fade into Obscurity?

Despite its technical superiority, Loglan'82 did not achieve widespread adoption. One of the main reasons was the lack of industry support. Unlike Java, which was backed by Sun Microsystems, Loglan'82 remained an academic project.

The limited availability of hardware was another factor. The MERA-400 minicomputer, for which Loglan'82 was initially developed, was not widely accessible outside Poland, making it difficult for the language to gain traction.

Another reason for its decline was the rise of C++ and Java in the 1990s. These languages gained traction with strong corporate backing and extensive developer communities, while Loglan'82 remained confined to academia.

Legacy and Influence

Although Loglan'82 is no longer actively used, many of its concepts have influenced modern programming languages. The Alien Call mechanism remains a point of interest in distributed computing, and its memory safety model could still offer insights for future programming languages.

The ideas behind Loglan'82 have resurfaced in recent years, especially in languages like Kotlin and Rust, which emphasize safety, concurrency, and structured object-oriented programming. The systematic approach Loglan'82 took toward multi-level inheritance, coroutines, and inter-process communication shows that its designers were decades ahead of their time.

Conclusion

Loglan'82 was a visionary language, pioneering object-oriented programming, safe memory management, and distributed computing long before they became industry standards. While it may not be widely known, its influence can be seen in modern programming paradigms. For those interested in programming history, Loglan'82 remains an underrated gem worth exploring.

Bibliography on Loglan Language

Wasielewska, Karolina - Cyfrodziewczyny. Krytyka Polityczna Publishing, 2016.
Bartol, Wiesława Maria, et al. - Report on the Loglan 82 Programming Language. Read online.
Ciesielski, Bolesław J. - Alien Call - A Synchronization Mechanism for Distributed Processes. Read online.
Kreczmar, Antoni - A Micro-Manual of the Programming Language LOGLAN-82. Read online.
Salwicki, Andrzej - Loglan Project: Yesterday, Today, Tomorrow. Read online.
Salwicki, Andrzej - Which Parallel Virtual Machine? - PVM/MPI, Java RMI, ... or PVLM. Read online.
Salwicki, Andrzej - Invitation to Collaborate: Loglan and LEM'12. Read online.
Institute of Informatics, University of Warsaw - LOGLAN'82 User’s Guide. Read online.
Various Authors - LOGLAN'82 Quick Reference Card. Read online.
Comparison of Object-Oriented Languages - Comparison of Loglan'82 with other Object-Oriented Languages. Read online.

Triangle of Differences - Simple Algorithms for Programmers Looking for a Job: Part three

Deotyma — Fri, 21 Feb 2025 14:01:45 +0000

Introduction

I have always been fascinated by mathematical structures, and one of the most intriguing ones I have explored is the Triangle of Differences. This construct involves iteratively computing the absolute differences between consecutive elements to form a triangular pattern. The process follows a bottom-up dynamic programming approach, where each row is derived using previously computed values.

The algorithm is related to finite difference methods commonly used in numerical analysis for interpolation and sequence prediction. It also shares similarities with grid-based structure generation algorithms, where patterns emerge through recursive computation. Additionally, it can be seen as a greedy algorithm, as each step only considers local differences without an overarching optimization strategy. Some applications of this approach also use recursive formulations, particularly in higher-order differences, making it a versatile computational tool.

Understanding the principles behind the Triangle of Differences not only improves algorithmic thinking but also opens doors to a variety of problem-solving techniques found in combinatorics, numerical methods, and data transformation.

Problem Statement

Given an array of integers as the last row of a triangle, construct the Triangle of Differences, where each row is formed by computing the absolute difference between consecutive elements of the previous row, until only one element remains at the top.

Pseudocode

FUNCTION generate_triangle(height):
    GENERATE a last row with 'height' random numbers
    STORE this as the last row of the triangle

    FOR i FROM height - 1 DOWNTO 1:
        CREATE an empty new row
        FOR j FROM 0 TO i - 1:
            COMPUTE absolute difference between adjacent elements
            APPEND result to the new row
        INSERT new row at the start of the triangle

    RETURN the complete triangle

FUNCTION print_triangle(triangle):
    DETERMINE max width for formatting
    FOR EACH row IN triangle:
        PRINT row centered based on max width

Implementations

Python

import random

def generate_triangle(height):
    last_row = [random.randint(1, 20) for _ in range(height)]
    triangle = [last_row]

    for i in range(height - 1, 0, -1):
        new_row = [abs(triangle[0][j] - triangle[0][j + 1]) for j in range(i)]
        triangle.insert(0, new_row)

    return triangle

def print_triangle(triangle):
    max_width = len(" ".join(map(str, triangle[-1])))
    for row in triangle:
        print(" ".join(map(str, row)).center(max_width))

# Test with height = 6
triangle = generate_triangle(6)
print_triangle(triangle)

JavaScript

function generateTriangle(height) {
    let triangle = [];
    let lastRow = Array.from({ length: height }, () => Math.floor(Math.random() * 20) + 1);
    triangle.push(lastRow);

    for (let i = height - 1; i > 0; i--) {
        let newRow = [];
        for (let j = 0; j < i; j++) {
            newRow.push(Math.abs(triangle[0][j] - triangle[0][j + 1]));
        }
        triangle.unshift(newRow);
    }
    return triangle;
}

function printTriangle(triangle) {
    let maxWidth = triangle[triangle.length - 1].join(" ").length;
    for (let row of triangle) {
        let rowString = row.join(" ");
        let padding = " ".repeat((maxWidth - rowString.length) / 2);
        console.log(padding + rowString);
    }
}

let triangle = generateTriangle(6);
printTriangle(triangle);

Java

import java.util.Random;

public class TriangleOfDifferences {
    public static void main(String[] args) {
        int height = 6;
        int[][] triangle = generateTriangle(height);
        printTriangle(triangle);
    }

    public static int[][] generateTriangle(int height) {
        Random random = new Random();
        int[][] triangle = new int[height][];

        triangle[height - 1] = new int[height];
        for (int i = 0; i < height; i++) {
            triangle[height - 1][i] = random.nextInt(20) + 1;
        }

        for (int i = height - 2; i >= 0; i--) {
            triangle[i] = new int[i + 1];
            for (int j = 0; j <= i; j++) {
                triangle[i][j] = Math.abs(triangle[i + 1][j] - triangle[i + 1][j + 1]);
            }
        }
        return triangle;
    }

    public static void printTriangle(int[][] triangle) {
        int height = triangle.length;
        for (int[] row : triangle) {
            for (int num : row) {
                System.out.print(num + " ");
            }
            System.out.println();
        }
    }
}

Real-World Applications

The Triangle of Differences has practical applications in various domains, ranging from data science to cryptography and procedural generation.

In financial analysis, this algorithm helps in detecting patterns in stock prices and predicting trends by analyzing successive variations. It is useful in time-series forecasting, where detecting sudden changes in value helps in understanding market shifts or anomalies in sensor data.

In data compression, techniques such as delta encoding rely on storing differences rather than absolute values, reducing redundancy. This is widely used in image and video compression algorithms like MPEG and PNG formats. Similarly, error detection mechanisms in communication protocols apply successive difference calculations to identify transmission errors.

In cryptography, obfuscating data through recursive numerical transformations makes it harder to decipher, providing an additional layer of security. This concept is particularly relevant in hashing algorithms and encryption techniques.

In computer graphics, procedural generation of terrains and fractals is influenced by recursive difference calculations, enabling the creation of natural-looking landscapes in video games and simulations. Algorithms for edge detection in image processing also leverage differences between pixel intensities to identify boundaries and objects within an image.

Lastly, in bioinformatics, analyzing genetic sequences through difference-based calculations helps in identifying mutations and evolutionary changes over generations. This is particularly useful in comparative genomics, where analyzing the differences in DNA sequences aids in evolutionary studies and disease research.

Further Exploration

Implement the Triangle of Differences with recursion instead of iteration.
Explore how the structure relates to numerical interpolation and error detection algorithms.
Modify the algorithm to compute higher-order differences and analyze sequences.
Apply the concept in image processing to detect edges and patterns in pixel data.

By mastering the construction of the Triangle of Differences, programmers can gain insights into pattern recognition, data structures, and efficient algorithm design, making this an essential problem-solving tool in both theoretical and practical computing scenarios.

Improve your algorithmic thinking with my new article on Dev.to! Discover the Latin Square, a simple but useful algorithm for technical interviews. 🔥 Ready for the challenge?

Deotyma — Thu, 13 Feb 2025 16:59:49 +0000

Simple Algorithms for Programmers Looking for a Job: Part Two - Latin Square

Deotyma ・ Feb 13

#beginners #algorithms #tutorial #javascript

Latin Square - Simple Algorithms for Programmers Looking for a Job: Part Two

Deotyma — Thu, 13 Feb 2025 16:14:39 +0000

Introduction

I have always been fascinated by the elegance of mathematical structures, and one of the most intriguing ones I have come across is the Latin Square. During a visit to the Bibliothèque Nationale de France, I stumbled upon a book by René Descombes titled Les carrés magiques, and I was completely fascinated by it. The Latin Square is an array filled with different symbols, each appearing exactly once in each row and column. This concept has been studied for centuries, and I love discovering its real-world applications in statistics, scheduling, and even cryptography.

One of the most fascinating applications of Latin squares is in experimental design. Researchers use them to control variations in two directions, making experiments more reliable in fields like agriculture, medicine, and industry. I also find their use in time planners particularly practical—Latin squares can help organize tasks and personnel schedules to prevent redundancy and conflicts.

Latin squares also pop up in error-correcting codes, Sudoku puzzles, and round-robin tournament schedules. Their structured beauty makes them a great tool for solving problems requiring balanced arrangements.

What truly excites me is the connection between Latin squares and art. At Gonville and Caius College in Cambridge, there's a stained glass window designed by Sir Roland Fischer, depicting a Latin square in seven distinct colors. I would love to visit Cambridge one day and see this masterpiece in person. The idea that something as abstract as a mathematical concept can be transformed into a visually stunning piece of art is inspiring.

Problem Statement

Given an integer ( n ), construct an ( n \times n ) Latin square where each row and each column contains the numbers from ( 1 ) to ( n ) exactly once.

Pseudocode

FUNCTION generate_latin_square(n)
    CREATE a matrix 'square' of size (n x n) filled with zeros

    FOR i from 0 to n - 1 DO
        FOR j from 0 to n - 1 DO
            COMPUTE the value for cell (i, j) using the formula:
                square[i][j] = (i + j) MOD n + 1
        END FOR
    END FOR

    RETURN the 'square' matrix
END FUNCTION

Implementations

Python

import numpy as np

def generate_latin_square(n):
    square = np.zeros((n, n), dtype=int)
    for i in range(n):
        for j in range(n):
            square[i][j] = (i + j) % n + 1
    return square

def print_latin_square(square):
    for row in square:
        print(" ".join(map(str, row)))

if __name__ == "__main__":
    while True:
        try:
            n = int(input("Your latin square have to be between 3 and 7 : "))
            if 3 <= n <= 7:
                break
            else:
                print("Give me a number between 3 and 7.")
        except ValueError:
            print("Wrong entry. Give me a number between 3 and 7.")

    latin_square = generate_latin_square(n)
    print("latin square generated:")
    print_latin_square(latin_square)

JavaScript

function generateLatinSquare(n) {
    let square = Array.from({ length: n }, () => Array(n).fill(0));
    for (let i = 0; i < n; i++) {
        for (let j = 0; j < n; j++) {
            square[i][j] = (i + j) % n + 1;
        }
    }
    return square;
}

function printLatinSquare(square) {
    square.forEach(row => console.log(row.join(" ")));
}

(function main() {
    let n;
    while (true) {
        n = parseInt(prompt("Your Latin square must be between 3 and 7: "), 10);
        if (n >= 3 && n <= 7) break;
        alert("Give me a number between 3 and 7.");
    }

    let latinSquare = generateLatinSquare(n);
    console.log("Latin square generated:");
    printLatinSquare(latinSquare);
})();

Java

import java.util.Scanner;

public class LatinSquare {
    public static int[][] generateLatinSquare(int n) {
        int[][] square = new int[n][n];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                square[i][j] = (i + j) % n + 1;
            }
        }
        return square;
    }

    public static void printLatinSquare(int[][] square) {
        for (int[] row : square) {
            for (int num : row) {
                System.out.print(num + " ");
            }
            System.out.println();
        }
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n;
        while (true) {
            System.out.print("Your Latin square must be between 3 and 7: ");
            n = scanner.nextInt();
            if (n >= 3 && n <= 7) break;
            System.out.println("Give me a number between 3 and 7.");
        }

        int[][] latinSquare = generateLatinSquare(n);
        System.out.println("Latin square generated:");
        printLatinSquare(latinSquare);
        scanner.close();
    }
}

Further Exploration

Implement Latin squares using different methods, such as backtracking for more complex constraints.
Explore applications of orthogonal Latin squares in statistical experiments.
Modify the algorithm to generate randomized Latin squares instead of deterministic ones.
Study how Latin squares relate to other combinatorial structures like magic squares and Sudoku puzzles.

By mastering the construction of Latin squares, programmers can improve their problem-solving skills and prepare for algorithmic coding interviews where combinatorial logic is tested. Understanding these structures opens doors to practical applications in various domains, making them a valuable topic to explore.

Palindrome - Simple Algorithms for Programmers Looking for a Job: Part One

Deotyma — Tue, 11 Feb 2025 14:56:46 +0000

Introduction

What is an Algorithm?

An algorithm is a step-by-step procedure or a set of rules for solving a specific problem. In programming, algorithms are essential as they provide structured ways to process data, perform computations, and solve complex challenges efficiently. Whether sorting numbers, searching for information, or performing mathematical calculations, algorithms form the foundation of software development.

Why Are Algorithms Important in Programming?

Algorithms help optimize performance, reduce computational complexity, and ensure that software applications run efficiently. Mastering common algorithms is crucial for programmers, especially those preparing for technical job interviews. Many companies evaluate candidates based on their ability to implement and analyze fundamental algorithms.

Why This Cycle?

Many recruiters want to test the skill level of a programmer who will join their team. Finding a job requires knowing how to translate requirements into working code. In this series, I would like to present some fundamental algorithms and their implementation in different programming languages. I will showcase one or two solutions, but there are often multiple approaches to solving a problem.

The Reversed Version of a Given String

The first algorithm I would like to introduce is one that returns the reversed version of a given string. This type of algorithm falls under string manipulation algorithms, specifically a reversal algorithm. It is a deterministic, linear-time algorithm (O(n)) that transforms a given string by reversing its order. In programming, it can be classified as a text processing algorithm, as it modifies character sequences, or as an in-place algorithm, since certain implementations allow the reversal without using extra memory. Additionally, it can be implemented either iteratively using loops or recursively through function calls.

Use Cases

Palindrome Checking

A string is reversed and compared with its original form to determine if it reads the same forward and backward. This is useful in word games such as "Wordament" and "Bananagrams," where players must quickly identify palindromes to gain points. In linguistic tests, applications like "Duolingo" and "Memrise" use palindrome detection to reinforce language learning through pattern recognition. Educational tools such as "Scratch" allow students to experiment with text-based algorithms, including string reversal.

Cryptography

String reversal is sometimes used as part of encoding methods, particularly in simple obfuscation techniques or as a step in more complex encryption processes.

Bioinformatics

Detecting palindromic sequences in DNA is critical for understanding restriction enzymes, which play a crucial role in genetic engineering and medical research. For instance, bioinformatics software such as "BLAST" and "BioPython" use sequence analysis to identify key genetic patterns.

File Recovery

When a file becomes corrupted, forensic tools like "Scalpel" and "Recuva" may attempt to read data in reverse to reconstruct missing information. Similarly, in data compression algorithms, reversing strings can be a step in encoding and decoding processes.

Problem Statement:

Write a function that takes a string as input and returns the reversed version of that string. Additionally, provide a real-life use case for this algorithm.

Real-World Use Case: Palindrome Detection

Imagine an application that checks whether a word or phrase is a palindrome. This functionality can be useful in word games, linguistic tests, or educational applications.

Pseudo-Code Implementation:

FUNCTION reverse_string(string)
    RETURN string reversed
END FUNCTION

FUNCTION is_palindrome(string)
    SET string TO lowercase version of string
    REMOVE spaces, commas, and apostrophes from string
    RETURN string EQUALS reverse_string(string)
END FUNCTION

// Example usage
SET word TO "Kayak"
PRINT "Is the word 'word' a palindrome? ", is_palindrome(word)

SET phrase TO "Was it a car or a cat I saw"
PRINT "Is the phrase 'phrase' a palindrome? ", is_palindrome(phrase)

This pseudocode represents the logic in a simplified way, making it easy to translate into different programming languages.

Example Implementations

Python Implementation:

def reverse_string(string):
    return string[::-1]

def is_palindrome(string):
    string = string.lower().replace(" ", "").replace(",", "").replace("'", "")
    return string == reverse_string(string)

# Example usage
word = "Kayak"
print(f"Is the word '{word}' a palindrome? {is_palindrome(word)}")

phrase = "Was it a car or a cat I saw"
print(f"Is the phrase '{phrase}' a palindrome? {is_palindrome(phrase)}")

JavaScript Implementation:

function reverseString(string) {
    return string.split("").reverse().join("");
}

function isPalindrome(string) {
    string = string.toLowerCase().replace(/[\s,']/g, ""); // Remove spaces, commas, and apostrophes
    return string === reverseString(string);
}

// Example usage
let word = "Kayak";
console.log(`Is the word '${word}' a palindrome? ${isPalindrome(word)}`);

let phrase = "Was it a car or a cat I saw";
console.log(`Is the phrase '${phrase}' a palindrome? ${isPalindrome(phrase)}`);

Java Implementation:

public class PalindromeChecker {
    public static String reverseString(String string) {
        return new StringBuilder(string).reverse().toString();
    }

    public static boolean isPalindrome(String string) {
        string = string.toLowerCase().replace(" ", "").replace(",", "").replace("'", "");
        return string.equals(reverseString(string));
    }

    public static void main(String[] args) {
        String word = "Kayak";
        System.out.println("Is the word '" + word + "' a palindrome? " + isPalindrome(word));

        String phrase = "Was it a car or a cat I saw";
        System.out.println("Is the phrase '" + phrase + "' a palindrome? " + isPalindrome(phrase));
    }
}

Want to Go Further? 🎯

To further solidify your understanding of string reversal and palindrome detection, try the following exercises:

Rewrite the palindrome checking algorithm using an iterative approach instead of slicing or built-in functions.
Implement the algorithm using recursion.
Modify the function to ignore case sensitivity and special characters but consider diacritical marks (e.g., accents in words like "résumé").
Extend the algorithm to work with numeric palindromes, checking if a number reads the same forward and backward.

This is part one of a series on simple algorithms that can help junior developers prepare for technical job interviews. Stay tuned for more!

Spring boot REST- API - configurations (Part 1)

Deotyma — Sun, 20 Nov 2022 11:58:58 +0000

Hello. I've just started a new work-study formation and I learn Java and Spring.
I will use Spring 2.4.7 with Java 11 and Eclipse for this tutorial and I work on MacBook with macOS Monterey version 12.

1). Creating a new workspace:

I open my Eclipse editor and I create a new workspace:

After tapping on switch workspace I browse where I want to create my new workspace:

and I create a new folder where I will create a new workspace:

Now I restart Eclipse:

2)Eclipse configuration for this workspace:

I open preferences on Eclipse (if you have Windows the preferences ai in the window tab)

I will use Java 11 this time so I configure my JRE:

To continue I apply this change and I adapt its environment:

In input I write foramtter - this is a plugin that helps to format a code, after I chose Code style formatter and Java Conventions and I edit it:

I change the ligne wrapping from 120 to 60:

and I change a Java Conventions [built-in] to Java Conventions custom

and I press OK.

Next, I write save in input: to format save actions: and I check this and I press Configure...:

And I change the use of parentheses in expressions:

and I press OK.

After that I change the configuration of Javadoc and uncheck it:

And the last change is the spelling which can pollute the work if is always active so I uncheck it also:

I apply all these changes and now I can start a new spring project.

See you in the next part.

How to customized Bootstrap 5.2 checks and radios

Deotyma — Fri, 28 Oct 2022 00:25:53 +0000

Bootstrap is one of the more known and used UI frameworks. It is completely free and open source. Bootstrap 5 is based on HTML, CSS, and vanilla JavaScript. It permits the build of quickly fully responsive sites and is very customizable.

However, some elements like radios, checks, and switches are complicated to personalize.

Here there is documentation of Bootstrap checks and radios.

But how to customize those elements?
There is a pure design of checks and radios with Bootstrap 5.2

To examine how it is stylized it is necessary to inspect a website.

Thanks to this analysis we see that circle in the middle of the radio input is an image. The same is for the checkbox and switch. We can see which class is necessary to change the background color of a checked element.

To change an element in the middle of the radio or checkbox I downloaded some images. Now I can change a css of each element:
This is a CSS for a switch box:

.form-switch .form-check-input {
  background-image: url(/ball-147676_640.png);
  background-color: yellow;
}

.form-switch .form-check-input:checked {
  background-image: url(/ball-147676_640.png);
  background-color: red;
  border-color: red;
}

.form-switch .form-check-input:focus {
  background-image: url(/ball-147676_640.png);
  box-shadow: 0 0 4px 4px violet;
  border-color: violet;
}

switchbox:

focused switchbox:

active switchbox:

To personalize a radio we do the same:

.form-check-input:checked[type=radio] {
  background-image: url(/colors-155896_640.png);
  background-color: aquamarine;
  border-color: aquamarine;
}
.form-check-input:focus[type=radio] {
  box-shadow: 0 0 4px 4px aquamarine
}

and this is a result:

It is time to see how it works for the checkbox:

.form-check-input:checked[type=checkbox]{
  background-image: url(/bootstrap.jpeg);
}

.form-check-input:focus[type=checkbox] {
  box-shadow: 0 0 4px 4px violet;
}

Although it is not obvious, it is possible to customize even those elements.

Oct 27 '22

The circle inside is an SVG so to change it I need to use a new SVG

This is a basic switch checkbox Bootstrap code:

 <div class="form-check form-switch back"&gt
        <input class="form-check-input" type="checkbox" role="switch" id="flexSwitchCheckDefault">
        <label class="form-check-label" for="flexSwitchCheckDefault">Default switch checkbox input</label>
 </div>

I downloaded an image to the local repository

And…

Open Full Answer

5 recruitment tasks with Python

Deotyma — Sat, 13 Aug 2022 01:07:00 +0000

At this moment I'm seeking a work-study job (alternance in french) as a programmer so I have to pass lots of tests each day and I decided to show you some of them this time with Python. Here This is only one solution, there is lots of solution for each of those problems so try your own solution.

1) Write a function that will print even numbers:

Solution 1 - while loop:

def evenNumbers(number):
    n=0
    while n < number:
        n += 1
        if n % 2 == 0:
            print(n, end="\t")

evenNumbers(10)

Solution 2 - for loop:

def evenNumbers2(number):
    numbers = range(0, number+1)
    for n in numbers:
        if n % 2 == 1:
            continue
        print(n, end="\t")

evenNumbers2(10)

2) Find a prime number:

Solution:

def isPrimeNumber(number):
    if number > 1:
        for i in range(2,number):
            if number % i == 0:
                #print(f"{i} times {number//i} is {number}")
                #print(f"{number} is not a prime number")
                return False    
        return True
    else:
        return False    

print("7 is prime", isPrimeNumber(7))
print("9 is prime", isPrimeNumber(9))

So we know how to find if a number is prime we can use it to find a prime number in a range:

def allPrimeNumbers(num):
    for i in range(num + 1):
        if isPrimeNumber(i):
            print(i, end = ", ")


print("prime numbers to 100")
allPrimeNumbers(100)

3) How to know if a number is a palindrome:
Solution:

def palindrome_number (number):
    number_str = str(number) # it is necessary to change the number to string to compare each digit
    number2_str = number_str[::-1] # number2_str is renversed by [::–1] slice which starts from last sign

    if number_str == number2_str:
        print(f"{number} this is a palindrome")
    else:
        print(f"{number} isn't a palindrome")  

palindrome_number(123321)

4) Fizz Buzz is one of most favorite exercises given to juniors and not only:

def fizz_buzz(number):
    for i in range(1, number+1):
        if i % 3 == 0 and i % 5 == 0:
            print("fizzBuzz",end=", ")
        elif i % 3 == 0:
            print ("fizz",end=", ")
        elif i % 5 == 0:
            print ("buzz",end=", ")
        else:
            print (i,end=", ")

fizz_buzz(20)

Yes, I know it is better and proper to use "return" than "print" 😉

5) This exercise was more difficult for me to understand: Fibonacci. Here I will show you 3 solutions:

Solution 1 - recursive function:

def fib_r(n):
    assert n>=0
    if n<=1: 
        return n
    else:
        return fib_r(n-1)+fib_r(n-2)

print(fib_r(10))

Solution 2 - iterative function

def fib_i(num):
    a, b = 0,1 

    for i in range(0, num):
        a, b = b, a + b
        print(a, end= ", ")

print(fib_i(10))

Solution 3 - function with generator

def fib_g():
    yield 0
    a=0
    b=1
    while True:
        yield b
        a,b = b,a+b

g=fib_g()

for i in range (11): 
    print( next(g), end = ", ")

These are just 5 tasks that I encountered during various recruitment tests and are only examples of solutions. If you have other suggestions, don't hesitate to leave a comment.