Finite-State Morphology Explorer
Building the browser interface and Python API that connect an existing finite-state morphology engine to an interactive web application.
Turning a language engine into usable software
Finite-state transducers are powerful computational tools used to analyze and generate word forms. They can provide the linguistic engine behind language analysis systems, but transforming that capability into usable software requires more than running an analyzer.
This case study documents an earlier open-source prototype in which I developed the HTML, CSS, and JavaScript frontend and implemented a Python API using FastAPI. The application connected a browser-based experience to existing finite-state language analysis technology.
I was responsible for the web interface and API integration, not the underlying finite-state transducers, linguistic rules, or language models, which were developed by collaborators. This prototype is separate from my later Ishkodens dictionary development contract.
Working at the boundaries between disciplines
The prototype brought together computational linguistics, web development, API implementation, UX, and technical communication. I built the application-facing components while collaborating with specialists responsible for the linguistic technology.
Implementing both the browser interface and Python API meant working across the request-response path: from user interaction to backend processing and back to a readable result.
My responsibility was to turn an existing language-analysis capability into an interactive web prototype—implementing the interface and API while coordinating with the people building the linguistic engine.
Cross-disciplinary thinking
Connecting software engineering, UX, computational linguistics, and education rather than treating them as isolated concerns.
Systems integration
Following the complete path from user interaction to API request, analyzer execution, structured response, and presentation.
Human-centered design
Making sophisticated information approachable without removing the detail specialists need.
Technical communication
Using diagrams, documentation, interface concepts, and collaborative discussion to make complex ideas easier to evaluate.
The engine may be the same. The experience should not be.
The application must support people with very different goals and levels of linguistic expertise while drawing from the same underlying language data.
A learner may need a clear definition and a simple breakdown. A teacher may need examples and reusable explanations. A linguist may need complete feature bundles, alternate analyses, and raw output. Designing for those differences without fragmenting the platform is one of the project’s central engineering and UX problems.
Building the frontend and API integration
I implemented the web-facing application and Python API for this prototype. Collaborators developed the finite-state engine, linguistic rules, and language models; my work connected that technology to an interactive interface.
Frontend Implementation
- Built the browser interface using HTML, CSS, and JavaScript
- Implemented interactions for submitting language data and presenting results
- Developed the frontend presentation and behavior
- Considered how different audiences would navigate linguistic information
Python API & Integration
- Implemented the Python API using FastAPI
- Connected JavaScript requests to backend endpoints
- Integrated the API layer with existing finite-state analysis functionality
- Handled data exchange between the frontend, API, and analyzer
Testing & Troubleshooting
- Tested frontend-to-backend interactions and analyzer responses
- Investigated unexpected output and integration behavior
- Helped distinguish software integration issues from linguistic questions
- Documented observations and potential improvements
Design & Collaboration
- Designed interface concepts and workflows for language analysis
- Coordinated with developers and linguistic specialists
- Produced diagrams and technical documentation
- Translated requirements across the interface, API, and language engine
Precision for experts. Clarity for everyone else.
An experienced linguist and a beginning learner may need access to the same underlying information, but they do not need the same presentation or the same interaction path.
How can one interface present the same computational analysis differently depending on who is using it?
These decisions affect much more than visual styling. They influence API response structure, frontend state, terminology, navigation, error handling, and the broader architecture of the platform.
From user interaction to morphological analysis—and back again
This diagram illustrates the prototype’s request-response architecture. The frontend and Python/FastAPI integration were my implementation; the finite-state engine and linguistic data were supplied by collaborators. The API mediates requests to the analyzer and returns structured results for presentation in the browser.
Where the layers meet
Frontend
- HTML
- CSS
- JavaScript
- Figma
Service Layer
- FastAPI
- REST APIs
- JSON
Integration
- Python
- Process orchestration
- Output parsing
Language Technology
- Finite-State Transducers
- HFST
- XFST
- Foma
Interface, integration, and engineering artifacts
These artifacts illustrate the interface and integration work without publishing collaborators’ source code or linguistic models.
Software as a bridge between systems and people
Building the frontend and API for this prototype reinforced that useful language technology depends on more than computational models.
It depends on integration.
On communication.
On thoughtful user experience.
On collaboration between disciplines.
Good engineering is not only about making a system function. It is also about designing the relationships between its parts so that sophisticated technology becomes understandable, maintainable, and genuinely useful.
Continuing the integration work
As the project evolves, I am continuing to explore frontend development, FastAPI integration, analyzer workflows, and interaction design that can make computational language tools more intuitive, scalable, and useful to a wide range of users.