joeni

{% load i18n %}

{% load humanize %}

{% load joeni_org %}

{% block title %}

    {% trans "Buses" %} | {{ block.super }}

{% endblock %}

{% block main %}

    <h1>{% trans "Bus departures" %}</h1>

    <h2 id="diepenbeek">Campus Diepenbeek</h2>

    <div class="flex-container">

    {% for bus in departures_diepenbeek %}

    <div class="flex-items timetable" style="border-color: {{ bus.color }};">

        <span class="number" style="background-color: {{ bus.color }};">

            {{ bus.number }}</span>

        {{ bus.time|time }}

        <span style="color: {{ bus.color }}; font-weight:bold;">🡺</span>

        {{ bus.destination }}

        <div class="timetable-under">

        <time>{{ bus.time|naturaltime|capfirst }}</time>

        {% if bus.via %}

            <span class="undernote">| Gaat via {{ bus.via }}</span>

        </div>

    </div>

    {% empty %}

    {% trans "There are currently no buses that stop here." %}

    {% endfor %}

    </div>

    <h2 id="hasselt">Campus Hasselt (Dusartplein)</h2>

    <div class="flex-container">

    {% for bus in departures_dusart %}

    <div class="flex-items timetable" style="border-color: {{ bus.color }};">

        <span class="number" style="background-color: {{ bus.color }};">

            {{ bus.number }}</span>

        {{ bus.time|time }}

        <span style="color: {{ bus.color }}; font-weight:bold;">🡺</span>

        {{ bus.destination }}

        <div class="timetable-under">

        <time>{{ bus.time|naturaltime|capfirst }}</time>

        {% if bus.via %}

            <span style="color: {{ bus.color }}; font-weight:bold;">|</span>

            <span class="undernote"> Gaat via {{ bus.via }}</span>

        {% endif %}

        </div>

    </div>

    {% empty %}

    {% trans "There are currently no buses that stop here." %}

    {% endfor %}

    </div>

{% endblock main %}

from django.contrib.auth import views as auth_views

from . import views

from django.utils.translation import gettext_lazy as _

urlpatterns = ([

    path('', views.index, name='administration-index'),

    path(_('pre-registration'), views.pre_registration, name='administration-pre-registration'),  # HOLD

    path(_('settings'), views.settings, name='administration-settings'),

    path(_('curriculum'), views.curriculum, name='administration-curriculum'),  # TODO

    # Commented because they might very well be merged with curriculum

    path(_('forms/<str:form>'), views.forms, name='administration-forms'),  # HOLD

    path(_('rooms'), views.rooms, name='administration-rooms'),  # TODO

    path(_('rooms/<str:room>'), views.room_detail, name='administration-room-detail'),  # TODO

    #path(_('rooms/reservate'), views.room_reservate, name='administration-room-reservate'),

    path(_('roster'), views.roster, name='administration-roster'),  # TODO

    re_path(_('roster/(?P<begin>[0-9]{2}-[0-9]{2}-[0-9]{4})/(?P<end>[0-9]{2}-[0-9]{2}-[0-9]{4})'), views.roster, name='administration-roster'),  # TODO

    path(_('jobs'), views.jobs, name='administration-jobs'),  # HOLD

    path(_('bulletin-board'), views.bulletin_board, name='administration-bulletin-board'),  # TODO

    path(_('user/<slug:slug_name>'), views.user, name='administration-user'),  # TODO

    path(_('buses'), views.buses, name='administration-buses'),

    path(_('roster/<slug:user_slug>.ics'), views.roster_ics, name='administration-roster-ics'),  # TODO

    path('login', views.login, name='administration-login'),  # FIXME

    ])

from . import bus

from collections import OrderedDict

from django.http import HttpResponseRedirect

import datetime

from django.urls import reverse # Why?

from django.utils.translation import gettext as _

from .models import *

from .forms import UserDataForm

from .new_roster import create_roster_rows

import administration

from django.contrib.auth.decorators import login_required

from django.contrib.auth import authenticate

from django.contrib.auth import login as login_auth

@login_required

def roster(request, begin=None, end=None):

    """Collects and renders the data that has to be displayed in the roster.

    The begin and end date can be specified. Only roster points in that range

    will be included in the response. If no begin and end are specified, it will

    take the current week as begin and end point. If it's

    weekend, it will take next week."""

    # TODO Handle given begin and end

    context = dict()

    #context = {'money' : update_balance(None)}

    template = "administration/roster.djhtml"

    if begin is None or end is None:

        today = datetime.date.today()

        if today.isoweekday() in {6,7}:  # Weekend

            begin = today + datetime.timedelta(days=8-today.isoweekday())

            end = today + datetime.timedelta(days=13-today.isoweekday())

        else:  # Same week

            begin = today - datetime.timedelta(days=today.weekday())

            end = today + datetime.timedelta(days=5-today.isoweekday())

    else:  # Changing regexes to date objects

        b = begin.split("-")

        e = end.split("-")

        begin = datetime.datetime(int(b[2]),int(b[1]),int(b[0]))

        end = datetime.datetime(int(e[2]),int(e[1]),int(e[0]))

    context['begin'] = begin

    context['end'] = end

    context['prev_begin'] = (begin - datetime.timedelta(days=7)).strftime("%d-%m-%Y")

    context['prev_end'] = (begin - datetime.timedelta(days=2)).strftime("%d-%m-%Y")

    context['next_begin'] = (end + datetime.timedelta(days=2)).strftime("%d-%m-%Y")

    context['next_end'] = (end + datetime.timedelta(days=7)).strftime("%d-%m-%Y")

    days = [begin]

    while (end-days[-1]).days != 0:

        # Human translation: Keep adding days until the last day in the array of

        # days is the same day as the last day the user wants to see the roster for.

        days.append(days[-1] + datetime.timedelta(days=1))

    context['days'] = days

    # Collecting events

    course_events = CourseEvent.objects.filter(begin_time__gte=begin).filter(end_time__lte=end).order_by("begin_time")

    #university_events = UniversityEvent.objects.filter(begin_time__gte=begin).filter(end_time__lte=end)

    #study_events = StudyEvent.objects.filter(begin_time__gte=begin).filter(end_time__lte=end)

    #events = Event.objects.filter(begin_time__gte=begin).filter(end_time__lte=end)

    conflicts, table_code = create_roster_rows(course_events)

    context['time_blocks'] = table_code

    context['conflicts'] = conflicts

    #print(time_blocks)

    return render(request, template, context)

    # TODO Finish!

def roster_ics(request, user_slug):

    template = "administration/roster.ics"

    context = dict()

    context['events'] = CourseEvent.objects.all()  # FIXME: Filter to personal calendar items!

    return render(request, template, context)

def index(request):

    template = "administration/index.djhtml"

    #context = {'money': update_balance(None)}

    context = dict()

    context['links'] = [

        ("administration-settings",

         _("Personal settings"),

         _("Edit your personal information, billing address, home address, and so on.")),

        ("administration-curriculum",

         _("Curricula"),

         _("View all information related to your curricula, including exam results.<br />"

           "You can also change your current curriculum here, or request a change.")),

        ("administration-forms",

         _("Forms"),

         _("All forms for special services can be found on this page.")),

        ("administration-rooms",

         _("Rooms"),

         _("Room occupancy, free rooms, properties, ... <br />"

           "All this and much more is available on this page.")),

        ("administration-roster",

         _("Personal roster"),

         _("Everything about your roster and events at Hasselt University is available here.")),

        ("administration-bulletin-board",

         _("Bulletin board"),

         _("From time to time, UHasselt publishes announcements regarding changes, events, ..."

           "<br />All publications are neatly organized here for easy reference.")),

        ]

    return render(request, template, context)

    pass

def pre_registration(request):

    user_data_form = UserDataForm()

    template = "administration/pre_registration.djhtml"

    context = dict()

    if request.method == 'POST':

        user_data_form = UserDataForm(request.POST)

        context['user_data_form'] = user_data_form

        if user_data_form.is_valid():

            user_data_form.save()

            context['messsage'] = _("Your registration has been completed. You will receive an e-mail shortly.")

        else:

            context['messsage'] = _("The data you supplied had errors. Please review your submission.")

    else:

        context['user_data_form'] = UserDataForm(instance = user_data_form)

    return render(request, template, context)

    pass

@login_required

def settings(request):

    user_data = UserData.objects.get(user=request.user)

    user_data_form = UserDataForm(instance = user_data)

    template = "administration/settings.djhtml"

    context = dict()

    #context = {'money' : update_balance(None)}

    if request.method == 'POST':

        user_data_form = UserDataForm(request.POST, instance = user_data)

        context['user_data_form'] = user_data_form

        if user_data_form.is_valid():

            user_data_form.save()

            context['messsage'] = _("Your settings were successfully updated.")

        else:

            context['messsage'] = _("The data you supplied had errors. Please review your submission.")

    else:

        context['user_data_form'] = UserDataForm(instance = user_data)

    return render(request, template, context)

@login_required

def bulletin_board(request):

    context = dict()

    #context = {'money' : update_balance(None)}

    context['exam_commission_decisions'] = ExamCommissionDecision.objects.filter(user=request.user)

    context['education_department_messages'] = EducationDepartmentMessages.objects.all()

    for item in context['education_department_messages']:

        print(item.text)

    template = "administration/bulletin_board.djhtml"

    return render(request, template, context)

def jobs(request):

    context = dict()

    #context = {'money' : update_balance(None)}

    template = "administration/jobs.djhtml"

    #@context['decisions'] = ExamCommissionDecision.objects.filter(user=request.user)

    return render(request, template, context)

@login_required

def curriculum(request):

    context = dict()

    #context = {'money' : update_balance(None)}

    template = "administration/curriculum.djhtml"

    context['curricula'] = Curriculum.objects.filter(student=request.user)

    for item in context['curricula']:

        for co in item.course_programmes_results():

            print(co)

    return render(request, template, context)

def result(request):

    return render(request, template, context)

@login_required

def results(request):

    results = CourseResult.objects.filter(student=request.user)

    template = "administration/results.djhtml"

    # TODO

    return render(request, template, context)

def forms(request):

    context = dict()

    #context = {'money' : update_balance(None)}

    template = "administration/forms.djhtml"

    return render(request, template, context)

def user(request, slug_name):

    pass

def rooms(request):

    context = dict()

    #context = {'money' : update_balance(None)}

    context['rooms'] = Room.objects.all()

    context['room_reservations'] = RoomReservation.objects.all()

    context['course_events'] = CourseEvent.objects.all()

    context['blocks'] = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H']

    # Collecting all rooms that are free for at least one two hours from now

    now = datetime.datetime.now(datetime.timezone.utc)

    end = now + datetime.timedelta(hours=2)

    free_rooms = dict()

    for room in context['rooms']:

        if room.reservation_possible(now, end):

            event = room.next_event(end)

            reservation = room.next_reservation(end)

            if event is None and reservation is None:

                free_rooms[room] = None

            elif reservation is not None:

                free_rooms[room] = event.begin_time

            elif event is not None:

                free_rooms[room] = reservation.begin_time

            elif event.begin_time < reservation.begin_time:

                free_rooms[room] = event.begin_time

            else:

                free_rooms[room] = reservation.begin_time

    context['free_rooms'] = free_rooms

    template = "administration/rooms.djhtml"

    return render(request, template, context)

def room_detail(request, room):

    template = "administration/room_detail.djhtml"

    context = dict()

    #context = {'money' : update_balance(None)}

    room = Room.objects.get(name=room)

    context['room'] = room

    context['reservations'] = RoomReservation.objects.filter(room=room).filter(begin_time__gte=datetime.datetime.now())

    context['course_events'] = CourseEvent.objects.filter(room=room).filter(begin_time__gte=datetime.datetime.now())

    # Building the room occupancy of today:

    today = datetime.date.today()

    if today.isoweekday() in {6,7}:  # Weekend

        today = today + datetime.timedelta(days=8-today.isoweekday())

    context['days'] = [today]

    # Collecting events

    course_events = CourseEvent.objects.filter(room=room).filter(begin_time__date=today)

    print(course_events)

    #university_events = UniversityEvent.objects.filter(begin_time__gte=begin).filter(end_time__lte=end)

    #study_events = StudyEvent.objects.filter(begin_time__gte=begin).filter(end_time__lte=end)

    #events = Event.objects.filter(begin_time__gte=begin).filter(end_time__lte=end)

    conflicts, table_code = create_roster_rows(course_events)

    context['time_blocks'] = table_code

    context['conflicts'] = conflicts

    print(context['time_blocks'])

    return render(request, template, context)

def buses(request):

    context = dict()

    context["departures_diepenbeek"] = bus.arrivals(["401474","401475"])

    #for testing: context["departures_diepenbeek"] = bus.arrivals(["205919","205916","205915"])

    context["departures_dusart"] = bus.arrivals(["403041","403040"])

    template = 'administration/buses.djhtml'

    return render(request, template, context)

def login(request):

    context = dict()

    #context = {'money' : update_balance(None)}

    if request.method == "POST":

        name = request.POST['name']

        passphrase = request.POST['pass']

        user = authenticate(username=name, password=passphrase)

        if user is not None: # The user was successfully authenticated

            print("YA")

            login_auth(request, user)

            return HttpResponseRedirect(request.POST['next'])

        else: # User credentials were wrong

            context['next'] = request.POST['next']

            context['message'] = _("The given credentials were not correct.")

    else:

        context['next'] = request.GET.get('next', None)

        if context['next'] is None:

            context['next'] = reverse('administration-index')

    template = 'administration/login.djhtml'

    return render(request, template, context)

Tijdens het maken van dit proefwerk ben ik op enkele kleine punten gestoten die

Alle benodigde informatie, alsook een redenering wordt per punt uitgeschreven.

** Verouderde informatie

Op de pagina https://www.uhasselt.be/Contact-en-ligging onder de rubriek "Campus

 Hasselt/Gevangenis" wordt verteld dat men de

Campushopper kan nemen, maar deze werd al in 2017 afgeschaft. Beter is om Boulevardpendel

te nemen, of elke bus die het Dusartplein aandoet.[fn::Dit zijn de volgende

 lijnen: 1, 3, 5, 11, 13, 16, 18a, 20a, 22, 23, 35, 36, 45, 46, 48, 51, 52, 180,

 182, AL, BP, H13, H14, H41, H51. (https://www.delijn.be/nl/haltes/halte/403040/Hasselt_Dusartplein)]

** Onnodige informatie

Op https://www.uhasselt.be/Contact-en-ligging staat een link naar een

PDF-bestand omtrent het Spartacusplan. Dit heeft inderdaad te maken met het

openbaar vervoer, maar voegt weinig toe aan het eigenlijke doel van deze pagina:

Bezoekers informeren over hoe ze de UHasselt kunnen bereiken.\\

Ik stel voor om de vermelding hierover de verwijderen.

*** Wachtwoorden plaintext

*Op het Studentendossier is het eerste wachtwoord dat studenten toegewezen

krijgen /plain text/ in te kijken.* Dit gaat via de link "Initieel paswoord".

Het spreekt voor zich dat de implicaties voor veiligheid dicteren dat

*het onversleuteld opslaan van wachtwoorden per direct moet stoppen.*

** Slecht te vinden informatie

Er is weinig te vinden van plattegronden op de website; waar zijn welke lokalen

 te vinden, plattegronden van de 1ste verdieping, ...

Het kan ook zijn dat dit niet per sé nodig is; indien op de campus zelf adequate

 wegbewijzering wordt aangebracht, wordt een plattegrond minder belangrijk.

 Waar vind ik alle plattegronden van de campussen? Het zijn er maar 2...

 Ik heb er eentje gevonden van de campus Diepenbeek op https://www.uhasselt.be/Contact-en-ligging:

 https://www.uhasselt.be/images/UHasselt/maps/2015/campus-diepenbeek/campus-diepenbeek-gebouwDE.jpg

 Maar dat is ook enkel gelijkvloers, en niet up-to-date met nieuwe aanbouw.

** Mogelijke versimpelingen

In de broncode van de websites binnen de UHasselt zijn in de header links te

vinden naar speciale logo's voor Apple-browsers.\\

Binnen Joeni worden er geen <GO ON>

Op https://www.uhasselt.be/Videos zijn er veel filmpjes te vinden over het

reilen en zeilen in de universiteit. Maar eigenlijk zijn het links naar het

videoplatform YouTube, onderdeel van Google Inc. Eerder werd in deze thesis

[[Google-privacy][de integratie met diensten van Google] op de korrel genomen.\\

Dit is makkelijk op te lossen door de video's simpelweg via de eigen website aan

te bieden, middels het [[https://developer.mozilla.org/en-US/docs/Web/HTML/Element/Video][~<video>~]]-element.

**** Licensiëring video's

De aangegeven licentie van de video's is de "Standaard YouTube-licentie", deze

licentie voldoet niet aan de vereisten voor een "Vrij cultureel werk".

De aard van deze video's is duidelijk: Ze dienen om toekomstige studenten te

informeren over de UHasselt en al haar richtingen, een blik te werpen op

studentenfaciliteiten (zoals verenigingen), en ook als een advertentie om voor

UHasselt te kiezen.\\

De doelstelling bereiken wordt met deze licentiekeuze actief tegengewerkt;

mensen mogen deze video's niet delen, of aanpassen voor nieuwe werken. Er zijn

ook voorwaarden op het privégebruik ervan.\\

Creatieve werken met deze doelstellingen dienen zo vrij mogelijk uitgegeven te

worden om de zichtbaarheid en verspreidingskansen ervan te maximaliseren. Door de huidige wetgeving

omtrent kopieerrechten is dit niet automatisch mogelijk, maar er bestaan wel

licenties die hiervoor een zeer toereikend soelaas bieden.

Ik raad aan om de licenties op de video's te vervangen met de

[[https://creativecommons.org/licenses/by/4.0/deed.nl][CC-BY 4.0]]-licentie, die deze problemen direct oplost. Dit kan ook gedaan worden als beslist

wordt de video's op YouTube te laten staan.

*** Google & privacy

 Ingewijden zijn bekend met het feit dat JavaScript een Turing-complete

 programmeertaal is; je kunt er dus daadwerkelijk programma's mee schrijven.

 Een prominent voorbeeld hiervan is Google met haar Google Docs, Sheets,

 Presentations, GMail, ...

 Het valt dan natuurlijk op dat binnen Joeni *geen enkele lijn JavaScript

 geschreven is*. En dat is ook expres gedaan.

 Dat klinkt misschien nogal contra-intuïtief; een volledig programma, dat

 hoofdzakelijk gebruikt zal worden via de browser, dat client-side scripting

 expres aan zijn neus voorbij laat gaan.

 Hier zijn meerdere redenen voor. Eén van de voornaamste redenen (en eentje die

 Google, Facebook, ... allemaal klaarblijkelijk vergeten zijn) is dat een

 grondregel van /web development/ is dat je er niet van mag uitgaan dat de

 gebruiker JavaScript ondersteunt.

 *Client-side scripting (Css* (niet te verwarren met Cascading Style Sheets, CSS))

 *mag enkel een strikt cosmetisch effect hebben op

 een website.* De functionaliteit gaat namelijk compleet verloren als de

 gebruiker geen ondersteuning biedt.

 Alhoewel het in de praktijk steeds neerkomt op "JavaScript (JS) dient vermeden te

 worden op het web", ga ik enkel spreken over "Client side scripting" (Css),

 omdat veel van de problemen die zich met JS zouden voordoen, zich eveneens

 zouden voordoen bij eender welke andere taal (Python, Clojure, ...),

 als die voor Css gebruikt zou worden. JS is sinds [[http://es6-features.org/][ES6]] een betere taal geworden,

 maar de "kwaliteit" van een taal is volledig irrelevant in deze discussie. Het

 bespreken van de faciliteiten die JS als programmeertaal biedt wordt in dit

 hoofdstuk dus achterwege gelaten.

 Er wordt hier ook enkel gefocust op het gebruik van Css om bepaalde

 functionaliteit te laten werken. Css die enkel een cosmetisch effect heeft is

 niet het onderwerp van dit stuk, maar wordt eveneens vermeden om aan te tonen

 dat een bruikbare web-applicatie ook mooi kan zijn met enkel HTML en CSS.

*** Verschillende versies

 Alles wat netwerkgerelateerd is, moet zich houden aan vooraf opgelegde

 standaarden om correct te kunnen communiceren, en met het WWW is dat niet

 anders.

 Dit geeft ook een reden om geen Css te gebruiken; op dit moment moet ik

 rekening houden met

 - De standaard van HTML(5) en welke tags ondersteund worden

 - De standaard van CSS(3) en de ondersteunde /properties/ binnen browsers

 Dit op zich is al een hele klus, en vereist *continu onderhoud van de software*.

 Stel dat men geen website ontwerpt, en /native software/ ontwikkelt, dan hoeft

 men enkel rekening te houden met de syntax van de programmeertaal; als het

 compileert kan het bij wijze van spreken gebruikt worden.[fn::In de praktijk is het niet zo voor de hand liggend, maar om het punt te maken volstaat dit.]

 Met Css moet men rekening houden met welke onderdelen van de gebruikte

 programmeertaal door de browsers wordt ondersteund, en dat is van vitaal belang,

 want als het script niet ondersteund wordt, wordt het simpelweg niet uitgevoerd,

 met als gevolg dat de website aan functionaliteit moet inboeten.

 Als dit bij HTML of CSS gebeurt (bv. gebruik van [[https://developer.mozilla.org/en-US/docs/Web/HTML/Element/marquee][<marquee>]]), dan kan de browser

 nog terugvallen op een standaardwaarde. Dit is ook mogelijk, omdat geen van

 groot risico te lopen om de site kapot te maken.

 Een goed voorbeeld hiervan is het ~<tel>~-element, dat wordt gebruikt om een

 telefoonnummer aan te duiden op een webpagina. Op mobiele browsers wordt een

 klik hierop behandeld als een telefoongesprek. Op (oudere) desktopbrowsers wordt

 dit als gewone tekst weergegeven.

*** Turing-compleetheid

 De aantrekkingskracht van Css schuilt in de [[https://nl.wikipedia.org/wiki/Turingvolledigheid][Turing-compleetheid]]. Dit maakt het tot een

 programmeertaal waarin elk mogelijk computerprogramma geprogrammeerd kan worden.

 De grote máár in deze kracht, is dat dat ook een hoop verantwoordelijkheid met

 zich meebrengt. Er kunnen fouten in de code sluipen, die de hele website kunnen

 doen vastlopen.

 JavaScript heeft dan ook nog de ongelukkige eigenschap dat het een enorm

 [[https://en.wikipedia.org/wiki/Strong_and_weak_typing][zwak getypeerde programmeertaal]] is; de taal doet in de achtergrond stille

 conversies tussen verschillende types, en geeft liever foute resultaten terug

 dan de programmeur te vertellen dat er een fout in de code zit.

 Deze punten gelden natuurlijk ook voor de /server-side/, maar dit is (in

 tegenstelling tot Css) absoluut onvermijdelijk om een dergelijke website te

 creëren.

 Daarnaast zijn er ook een hoop voordelen die men niet heeft bij Css:

 - Vrije keuze van programmeertaal (en mogelijkheid om te linken met andere

   software)

 - Zekerheid dat, als de software werkt op de ene /client/, die ook voor de

   andere /client/ werkt (zie [[Verschillende versies][Verschillende versies]]).

 HTML en CSS zijn geen "volwaardige programmeertalen". HTML is een opmaaktaal,

 men beschrijft er dus mee hoe bepaalde onderdelen van de website moeten worden

 voorgesteld; als een hyperlink, een paragraaf, ...

 CSS laat toe om de stijl van deze opmaak te definiëren, hoe moet een hyperlink

 uitzien, ...

 Een fout hierin heeft hoogstens een esthetisch vervelend effect tot gevolg; veel

 browsers negeren fouten, en vervangen deze door /fallbacks/. Dit is niet

 mogelijk met een programmeertaal; een fout is een fout, en computers zijn niet

 in staat om een fout programma zelf te repareren.

*** Onbeschikbaarheid

 Er zijn talloze manieren waarop de aangereikte code niet beschikbaar kan zijn

 voor de gebruiker, waardoor een website die afhangt van Css plots zonder

 waarschuwing niet meer werkzaam is. Een wilde greep uit de mogelijkheden:

 - De gebruiker heeft een zwakke computer

 - De computer heeft een slechte verbinding

 - De gebruiker surft via de GSM (een zwakke computer met een slechte verbinding)

 - De gebruiker heeft [[https://noscript.net][NoScript]], [[https://www.gnu.org/software/librejs/][GNU LibreJS,]] of een andere extensie die Css blokkeert

 - De verbinding wordt onderbroken tijdens het inladen, en de pagina blokkeert

   terwijl het tevergeefs wacht op de rest van het script

 - De browser van de gebruiker ondersteunt simpelweg geen Css

 - De browser van de gebruiker ondersteunt niet de Css-implementatie die op de

   website gebruikt wordt (zie [[Verschillende versies]])

 - De website laadt Css in van een externe website, maar er is een fout in het

   certificaat, en de browser weigert om de verbinding op te zetten

 - ...

 Er hoeft maar één (en slechts één) van deze mogelijkheden op te treden, en *de

 volledige website is per direct compleet onbruikbaar*.

 Voor elk van deze mogelijkheden zou met Css een controle moeten worden

 ingebouwd, en dan weer voor elke mogelijkheid een oplossing bedacht (want "Het

 werkt niet en dat is de schuld van de gebruiker" is geen oplossing).

 Daarentegen, wat als er server-side een fout optreedt? \\

 Veel webframeworks hebben ingebouwde /debugging tools/ die bij fouten direct de

 programmeur wijzen op de fout. Django is hier een goed voorbeeld van.

 Daarnaast biedt de betere webserver ook ingebouwde oplossingen om vaak

 voorkomende fouten af te handelen (zoals een HTTP 404). In dat geval kan er

 gemakkelijk een e-mail naar de ontwikkelaar gestuurd worden, of kan een log

 aangemaakt worden. En dit is vaak allemaal /ingebouwd/.

*** Uitgesteld resultaat

 Bestanden over het WWW worden quasi altijd verzonden via [[https://nl.wikipedia.org/wiki/Hypertext_Transfer_Protocol][HTTP]]([[https://nl.wikipedia.org/wiki/HyperText_Transfer_Protocol_Secure][S]]), en de browser

 is daarna verantwoordelijk voor het in elkaar steken van alle ontvangen

 onderdelen.

 Het handige hieraan, is dat elke browser zelf kan bepalen hoe, en in welke volgorde dit

 moet gebeuren, al dan niet in functie van bepaalde instellingen die de gebruiker

 zelf kan aanpassen (bv. geen afbeeldingen laden via 4G).

 Css interfereert op haast elk mogelijk niveau met deze werkwijze. Net omdat het

 niet op voorhand geweten is wat er zal worden aangepast, of wanneer de code