Search
Enter at least two characters without personal information.

    LibraryArticles & FAQ Your projectRequest a quote
    LanguageEN
    Development and code

    Understand development and code

    Development turns intent into behaviour. Separate document structure, browser interactions and server decisions. Define accepted inputs and output states before assessing a library or framework.

    101 concepts to explore with definitions and practical advice.

    Search the full glossary
    Two people working on a laptop
    AI-generated illustration

    A reading path

    1. Structure and presentation

    HTML describes elements; CSS organises presentation. Use components suited to the action before adding custom behaviour.

    • HTML

      Markup language giving content structure and meaning through headings, paragraphs, links, lists and form fields. Elements have roles and sometimes native behaviours. CSS primarily handles presentation, while JavaScript can add interactions.

    • CSS

      Language describing document presentation: layout, colours, spacing, typography and screen adaptations. The cascade determines which rules apply. A visual change does not transform an element’s HTML role: making text look like a button does not add button behaviour.

    • Semantic HTML

      Use of HTML elements according to their role: headings organise documents, links lead to destinations and buttons trigger actions. Meaning does not depend only on appearance. Correct semantics aids interpretation but still requires usable labels and behaviours.

    2. Exchanges and contracts

    An API describes expected exchanges. An endpoint, its inputs and responses should remain compatible with the journey using it.

    • API

      Interface defining how software exchanges data or requests operations. Its contract specifies inputs, responses and errors; knowing an address does not automatically grant access rights. Before integration, distinguish available operation, response format and permission. A technically received response may still contain an error or an incomplete result.

    • Endpoint

      API access point for a particular operation. Address, method and parameters form a usage to document; two methods at one address can have different effects.

    • API contract

      Documented agreement on an API’s inputs, outputs, errors and usage conditions. Defining versions and edge cases helps client software detect an incompatible change.

    3. Errors and change

    Test empty states, interruptions and unexpected input on a copy. Keep versions and checks needed for an update.

    • Progressive enhancement

      Approach providing essential content and functionality first, then adding capabilities according to browser support. For example, a linked list remains usable when its JavaScript filter fails. Define and test that baseline rather than assuming failures will be rare.

    • Staging

      Pre-production environment similar to the live website where changes are checked before release.

    • Version control

      System keeping file-change history, facilitating collaboration and allowing return to a previous state. Define which files are actually tracked and verify that a state can be recovered. Code history does not replace a backup of operational data.

    Useful distinctions

    Front-end / Back-end

    Front-end covers the interface executed or rendered for the browser; back-end handles server processing. A visible interface check does not replace server validation.

    API / Webhook

    An API provides an exchange contract; a webhook sends a notification when an expected event occurs. The receiving system should account for repetition or delay.

    Educational example

    Use the vocabulary to make a decision

    Laptop, external keyboard, closed notebook and blank cards
    AI-generated illustration · Prepare tests of empty states and interruptions on a copy.

    Situation

    A submission displays success but no record is retained.

    Before deciding

    Follow request and response, then the actual saved state. Separate the interface message from server confirmation.

    A concrete check

    Reproduce on a copy with test data and compare expected and observed results.

    From a word to an observation

    Distinguish the interface from the stored outcome

    In a test environment, prepare a successful case and a rejected case. Compare the screen message, request response and state retained by the application.

    On a narrow screen, scroll the table horizontally to read all three columns.

    Illustrative observations to adapt to your project
    Observed signalWhat to checkWhat it means
    Success appears after a server rejectionCompare status, response and the interface processing branch.The message should reflect the received outcome.
    An action happens twiceTry a double click and a retry after an interruption.Processing should account for repetition in the journey.
    Navigation disappears without JavaScriptOpen a page directly and disable scripts.Essential links and content can retain basic access.

    Next step : Write the expected result for each case before fixing it, then verify it again on the same site copy.

    Technical reference : MDN — HTTP response status codes. The scenarios and numerical examples above are educational, not measurements of this website.

    Examine the interpretation

    A browser check does not replace server validation

    Fictional teaching case. Open each interpretation to examine its scope; there is no score or professional assessment.

    1. Input guided
    2. Request checked
    3. Business result confirmed

    In a demonstration, a form reports an empty required field. The team asks whether the server can now accept all incoming data without further checks.

    Which responsibility was observed?

    Browser-side input assistance

    The message can help people correct input before sending. It does not establish that every request reaching the server follows the rules.

    Complete server validation

    That conclusion does not follow from this test. The server must enforce its own checks on data and permitted operations.

    A useful next step : Define useful interface feedback separately from server checks. Keep demonstration cases in an environment intended for testing.

    Reference to explore : MDN · Website security · Consulted .

    All concepts in this topic

    Links open the full definition on its alphabet page. Acronyms and synonyms remain searchable in the main glossary.

    Frequently asked questions

    Is a complex application always needed?

    Choose functionality according to need and maintainability. A simple page or form may suffice; complexity is useful only when it addresses a real constraint.

    Is JavaScript validation sufficient?

    It helps guide input, but data and permission rules should also be enforced server-side. Test an input submitted outside the normal interface.

    Primary reference documents

    These documents explain technical concepts. Reading paths and examples are editorial methods to adapt to your project.

    Related topics