101 Matching Annotations
  1. Sep 2026
    1. De eisen voor culpaAchter de omschrijving van culpa als een verwijtbare aanmerkelijke onvoorzichtigheid schuilen drieeisen, die je in een casus telkens afzonderlijk moet langslopen:• Aanmerkelijke onvoorzichtigheid: Het feitelijke gedrag moet onder de concrete omstandig-heden strijdig zijn met de eisen van zorgvuldigheid, dus afwijken van hoe een normaal zorg-vuldig mens in dezelfde situatie zou hebben gehandeld. Niet elke onoplettendheid is genoeg,want de onvoorzichtigheid moet grof of aanmerkelijk zijn.• Vermijdbaarheid: De dader moet de gevolgen hebben kunnen en moeten voorzien, en opgrond van die voorzienbaarheid moet er een zorgplicht op hem hebben gerust om dat gedragte laten. Was het gevolg volstrekt onvoorzienbaar of onvermijdbaar, dan is er geen culpa maareen ongeluk.• Verwijtbaarheid: De onvoorzichtigheid moet de dader te verwijten zijn, dus moet hij rede-lijkerwijs anders hebben kunnen handelen en mocht dat in die omstandigheden ook van hemworden verwacht. Culpa is daarmee sterk normatief, want zij houdt een morele afkeuring vande onvoorzichtigheid in.

      Culpa!!!

    2. OpzetOpzet betekent willens en wetens uitvoeren van een strafbare handeling. De dader weet waar hijmee bezig is en wil het ook doen. Dat klinkt eenvoudig, maar in de praktijk is opzet lang niet altijdevident, want tussen de dader die zijn slachtoffer doelbewust doodsteekt en de dader die een risicoop de koop toe neemt zit een groot grijs gebied. De rechtspraak onderscheidt daarom drie gradaties,die in zwaarte aflopen. Belangrijk is dat die indeling vooral dient om opzet beter van schuld te kunnenonderscheiden, want voor het vervullen van het bestanddeel opzet maakt het niet uit welke vorm zichvoordoet. Alle drie leveren zij volwaardig opzet op.• Opzet met bedoeling: De hoogste vorm, ook wel zuiver opzet genoemd. De dader weetvolledig wat hij doet en wil dat gevolg ook bereiken, zoals bij het doelbewust toebrengen vanletsel in de zin van art. 300 Sr.• Opzet met noodzakelijkheidsbewustzijn: De dader heeft een ander doel voor ogen, maarweet zeker dat het strafbare gevolg daarmee gepaard gaat. Hij aanvaardt dus een kans vanhonderd procent. Wie een gebouw opblaast om een andere reden, weet dat er slachtoffersvallen. Deze vorm komt weinig voor, simpelweg omdat zulke absolute zekerheid zeldzaam is.• Voorwaardelijk opzet: De ondergrens van het opzet en verreweg de belangrijkste vorm in derechtspraak. De dader heeft een bepaald doel voor ogen en aanvaardt daarbij de aanmerke-lijke kans dat daardoor ook andere gevolgen intreden.Tip!Verwar het subjectieve bestanddeel schuld niet met het element schuld uit de definitie van hetstrafbare feit. Als bestanddeel in de delictsomschrijving betekent schuld culpa, dus een verwijtbaremate van onvoorzichtigheid die je moet bewijzen. Als element betekent schuld de verwijtbaarheidvan de dader in het algemeen, die in beginsel wordt verondersteld.Voorbeeld ter illustratieDenk aan Boaz, die na een ruzie op Cloé afloopt en haar met opzet een vuistslag in hetgezicht geeft om haar pijn te doen. Zijn handeling is precies op dat letsel gericht, dus er issprake van mishandeling in de zin van art. 300 Sr.Voorbeeld ter illustratieSultan plaatst een bom in een vliegtuig om één bepaalde passagier te doden. Dat de andereinzittenden daarbij eveneens omkomen is niet haar doel, maar staat voor haar wel vast,zodat zij ook op hun dood opzet heeft.Voorbeeld ter illustratieDenk aan Martijn, die haast heeft en bij een druk kruispunt door rood rijdt. Een aanrijdingis niet zijn bedoeling, maar hij weet dat er verkeer van rechts kan komen en dat de kans opeen botsing dus reëel is. Door toch door te rijden, aanvaardt hij die kans bewust.

      Opzet!!

    1. Soorten delictenNiet elk strafbaar feit is van dezelfde soort. Het maakt uit of de wet een handeling verbiedt of juist eengevolg, of zij iets van je verlangt of je juist iets verbiedt, en hoe zwaar zij het feit opneemt. Om dieverschillen te benoemen, worden strafbare feiten op verschillende manieren ingedeeld:• Misdrijven en overtredingen. Dit onderscheid draait om de ernst van het feit. Misdrijven zijnin de regel de zwaardere feiten. In het Wetboek van Strafrecht is het onderscheid eenvoudigterug te vinden, want de misdrijven staan in Boek II en de overtredingen in Boek III.• Formele en materiële delicten. Bij formele delicten stelt de wet een bepaalde handeling straf-baar. Zodra die handeling is verricht, is het delict voltooid, ongeacht wat er verder gebeurt. Bijmateriële delicten (gevolgdelicten) gaat het juist om het veroorzaken van een bepaald gevolg.• Commissie- en omissiedelicten. Hier draait het om de vraag of iemand iets heeft gedaan ofjuist heeft nagelaten. Bij commissiedelicten is het actieve handelen strafbaar, terwijl bijomissiedelicten juist het niet handelen strafbaar is, een niet-doen.

      Soorten delicten!!

    2. Omdie uitleg navolgbaar te houden, wordt gebruikgemaakt van interpretatiemethoden:• De grammaticale interpretatie. Hierbij wordt gekeken naar de taalkundige betekenis van debepaling. Deze methode sluit het nauwst aan bij het legaliteitsbeginsel, omdat de burger nueenmaal afgaat op wat er staat.• De wetshistorische interpretatie. Hierbij wordt gekeken naar de bedoeling die de wetgeverdestijds met de bepaling had. Die bedoeling blijkt uit de totstandkomingsgeschiedenis, waar-van de memorie van toelichting het bekendste onderdeel is.• De wetssystematische interpretatie. Hierbij wordt de bepaling uitgelegd aan de hand van hetsysteem van de regeling waarvan zij deel uitmaakt. De plaats en samenhang van een artikel inhet wetboek en de bepalingen eromheen zeggen namelijk iets over de betekenis ervan.• De teleologische interpretatie. Hierbij wordt gekeken naar het doel van de bepaling en naarhet rechtsbelang dat zij beoogt te beschermen. Anders dan bij de wetshistorische methodegaat het hier niet om wat de wetgever ooit voor ogen had, maar om wat de bepaling naarhuidige maatschappelijke opvattingen behoort te betekenen.

      Interpretatiemethoden!!

    3. Het legaliteitsbeginsel valt uiteen in vier onderdelen, die elk een eigen aspect van de rechtszekerheidbeschermen. Hieronder worden zij afzonderlijk besproken.• De eis van een wettelijke basis. Strafbaarstelling moet altijd berusten op een geschrevenwettelijke bepaling, want alleen zo weet de burger vooraf welk gedrag verboden is en waaropde overheid haar optreden baseert.• Het verbod van terugwerkende kracht. Iemand kan alleen worden vervolgd en veroordeeldvoor gedrag dat op het moment van handelen al strafbaar was gesteld. De wetgever kan dusniet achteraf bepalen dat iets verboden was, want dan zou niemand zijn gedrag daarop hebbenkunnen afstemmen.• Het gebod van toegankelijke en scherpe normen (het lex certa-beginsel). De wetgever moetduidelijk omschrijven wat strafbaar is, zodat een burger uit de wettekst kan opmaken wat hijwel en niet mag doen. Een vage of onduidelijke bepaling voldoet daar niet aan.• Het verbod van te extensieve en analogische interpretatie. De rechter mag een strafbepalingniet zo ruim uitleggen dat er ook gedrag onder valt waar de wetgever helemaal niet aan heeftgedacht, ook al lijkt dat gedrag sterk op wat wel verboden is. Zou hij dat wel doen, dan maakthij in feite zelf nieuwe strafbare feiten, terwijl dat de taak van de wetgever is.

      Legaliteitsbeginsel!!

    4. • Een menselijke gedraging. Ieder strafbaar feit begint bij een gedraging, waarbij het zowel omactief handelen kan gaan (het toebrengen van letsel) als om nalaten (het niet verlenen vanhulp aan iemand in nood). Gedachten alleen zijn nooit genoeg, hoe verwerpelijk zij ook mogenzijn, want zonder gedraging is er niets om op af te rekenen. Alleen natuurlijke personen enrechtspersonen kunnen zo’n gedraging verrichten. Kan de rechter niet bewijzen dat deverdachte de gedraging heeft verricht, dan volgt vrijspraak.• Een wettelijke delictsomschrijving. De gedraging moet passen binnen een strafbepaling, wantzonder wettelijke basis is er geen strafbaar feit. Iedere strafbepaling heeft een eigenomschrijving met eigen eisen. Bij diefstal (art. 310 Sr) moet er bijvoorbeeld sprake zijn van hetwegnemen van een goed dat aan een ander toebehoort, met het oogmerk om het zichwederrechtelijk toe te eigenen.• Wederrechtelijkheid. De gedraging moet in strijd zijn met het recht. Meestal volgt dit vanzelfuit het feit dat de gedraging onder een strafbepaling valt, want wat de wetgever verbodenheeft, is in beginsel ook onrechtmatig. Toch zijn er uitzonderingen, want soms had deverdachte wel degelijk het recht om te doen wat hij deed. Wie zich verdedigt tegen een aanvalkan zich beroepen op een rechtvaardigingsgrond (zie Week 4). Slaagt dat beroep, dan is degedraging niet wederrechtelijk en volgt eveneens ontslag van alle rechtsvervolging.• Verwijtbaarheid (schuld). De dader moet een verwijt kunnen worden gemaakt, in die zin dathij zich anders had kunnen en moeten gedragen. Bij sommige delicten moet de rechtervaststellen dat de dader met opzet heeft gehandeld, terwijl bij andere delicten juist nalatigheidcentraal staat, zoals bij dood door schuld (art. 307 Sr). Verder gaat de rechter er in beginselvan uit dat de verwijtbaarheid aanwezig is, tenzij er een schulduitsluitingsgrond geldt. Dat isbijvoorbeeld het geval wanneer de verdachte door een ernstige geestelijke stoornis niettoerekeningsvatbaar was of wanneer hij onder zware psychische druk stond. Ook dan volgtontslag van alle rechtsvervolging, al kan de rechter in zo’n geval wel een maatregel opleggenzoals tbs, omdat de samenleving mogelijk nog steeds beschermd moet worden.

      Vierlagenmodel!!!!!

  2. May 2025
  3. Jun 2024
  4. Oct 2023
  5. Sep 2023
  6. Aug 2023
    1. Add aliases to vite.config.ts

      ```js import { defineConfig } from 'vite' import react from '@vitejs/plugin-react' import path from 'path';

      // https://vitejs.dev/config/ export default defineConfig({ resolve: { alias: { '@': path.resolve(__dirname, './src'), '@assets': path.resolve(__dirname, './src/assets'), '@components': path.resolve(__dirname, './src/components'), }, }, plugins: [react()] }) ```

      Add aliases to tsconfig.json

      ```js { "compilerOptions": { // ... your other compiler options "baseUrl": ".", "paths": { "@/": ["src/"], "@components/": ["src/components/"], "@assets/": ["src/assets/"] }, }, "include": ["src"], "references": [{ "path": "./tsconfig.node.json" }] } ````

      Use alias

      js import image from `@assets/image.png`

  7. Jul 2023
  8. Jun 2023
  9. May 2023
    1. With TypeScript 3.7, TypeScript added support for generating .d.ts files from JavaScript using JSDoc syntax. This set up means you can own the editor experience of TypeScript-powered editors without porting your project to TypeScript, or having to maintain .d.ts files in your codebase.

      npx -p typescript tsc src/**/*.js --declaration --allowJs --emitDeclarationOnly --outDir types

    1. js /** * This component is just a Box with border. * It serves as an example of how you can incorporate * components together. * * Component also has slots, methods and events. * * @component * @example <caption>Basic usage just with the default slot</caption> * <Box> * I am inside a slot * </Box> * * @example <caption>Using second component inside</caption> * <Box> * <ProgressBar :spent="spent" :remaining="50"></ProgressBar> * </Box> * * @example <caption>Example of passing an entire component in a preview</caption> * { * template: `<Box> * <ProgressBar :spent="spent" :remaining="50"></ProgressBar> * <ProgressBar :spent="50" :remaining="50" style="margin-top: 20px"></ProgressBar> * </Box>`, * data: function() { * return {spent: 223}; * } * } */ export default { name: "Box", props: { /** * This will be in the header */ title: { type: String, default: "My box" } }, methods: { /** * Also, you can describe methods for each component * the same as you would do this in regular @jsdoc * documented file * * @param {string} prop1 some example property * @param {string} prop2 other property */ exampleMethod(prop1, prop2) { // method body // The method could even throw an event /** * This event could be thrown by component in case * of some kind of unexpected behaviour. * * @category API * @event unexpectedEvent */ this.$emit('unexpecteEvent') } } }

    1. ```ts

      /* * Initiates a connection to the selected port. / async function connectToServer(): Promise<void> { hostInput.disabled = true; portInput.disabled = true; connectButton.textContent = 'Connecting...'; connectButton.disabled = true;

      try { socket = new TCPSocket(hostInput.value, parseInt(portInput.value)); connection = await socket.opened; term.writeln('<CONNECTED>'); connectButton.textContent = 'Disconnect'; connectButton.disabled = false; } catch (e) { console.error(e); term.writeln(<ERROR: ${e.message}>); markDisconnected(); return; }

      try { reader = connection?.readable.getReader(); for (;;) { const {value, done} = await reader.read(); if (value) { await new Promise<void>((resolve) => { term.write(value, resolve); }); } if (done) { break; } } reader.releaseLock(); reader = undefined; } catch (e) { console.error(e); term.writeln(<ERROR: ${e.message}>); }

      markDisconnected(); }

      /* * Closes the currently active connection. / async function disconnectFromServer(): Promise<void> { // Canceling |reader| will close the connection and cause the read loop in // connectToServer() to exit when read() returns with done set to true. if (reader) { await reader.cancel(); } } ```

  10. Apr 2023
  11. Mar 2023
    1. Put that TS code in a file your app imports, for example, in remix.env.d.ts, and now the type of name will be the expected one.

      ts declare module "@remix-run/server-runtime" { export interface AppLoadContext { name: string; } }

    1. Unlike the tuple type in vanilla Javascript, Typescript Tuples by default are mutable - so they can be changed. As such, we can update a Tuple by simply referring to the element we want to update, and redefining it, assuming it isn't a constant:
      Mutating a Typescript Tuple

      ```ts let myTuple:[ string, number ] = [ "some", 15 ]

      myTuple[1] = 20; ```

    2. We can also define an array of Tuples in Typescript. This is done by adding [] to the end of our Tuple type definition:

      ts let myTuple:[ string, number ][] = [ [ "some", 15 ], [ "other", 20 ], [ "tuple", 50 ] ];

    1. Now we have autocomplete and typechecking.

      ```ts type ColorDSValue = "black100" | "black80" | "blue100" | "red150" // | etc type ColorOtherString = string & {}

      type Color = ColorDSValue | ColorOtherString ```

    2. This is so so useful for types or props where you want the general type for support (string), but you also want the specific type for autocomplete ("black100"). It made my whole week when I figured that out and made that color type.
    3. This weird-looking intersection of string & {} makes it so that the specific strings "hello" and "world" are distinguished from string as a whole type.

      ts const wow: ("hello" | "world") | (string & {}) // `wow` is of type `"hello"` or `"world"` or `string`.


  12. Feb 2023
  13. Jan 2023
  14. Dec 2022
  15. Nov 2022
  16. Aug 2022
    1. The unary plus operator (+) precedes its operand and converts it into a number. If it fails to convert the operand into a number, then it returns NaN. The unary (-) operator converts the operand into a number and negates it.

      an alternative to !!, in order to convert null, empty strings, boolean values into 0 or 1.

  17. May 2022
  18. Apr 2022
  19. Feb 2022
  20. Jan 2022
  21. Dec 2021
    1. The correct way to handle TypeScript functional destructuring is to define an interface and reference the interface after the destructure. TypeScript is then able to understand that the function takes an object argument that is of the shape of the Person interface and destructuring occurs as you would expect it to in ES6.
      // a 'Person' object requires 'first' and 'last' 
      // properties whose values are strings
      interface Person {
        first: string;
        last: string;
      }
      
      // This defines that the first functional argument 
      // must be an Array of 'Person' objects, then destructs
      // the first person's first and last name properties
      const helloFirstPerson = ([{ first, last }]: Person[]) =>
        `Hello ${first} ${last}!`;
      
      const people = [
        { first: 'John', last: 'Doe' },
        { first: 'Jane', last: 'Smith' }
      ];
      
      // outputs "Hello John Doe!"
      helloFirstPerson(people);
      
      /* --------- Example of a Type Error ----------- */
      // This creates an array argument that will be invalid for
      // the helloFirstPerson() function, because there are no 'last'
      // props on the 'people' objects
      const badArgs = [{ first: 'John' }, { first: 'Jane' } ];
      
      // Type Error! 
      // Property 'last' is missing in type '{ first: string; }'
      helloFirstPerson(badArgs);
      
  22. Nov 2021
    1. You'll use a (70%, 20%, 10%) split for the training, validation, and test sets. Note the data is not being randomly shuffled before splitting. This is for two reasons: It ensures that chopping the data into windows of consecutive samples is still possible. It ensures that the validation/test results are more realistic, being evaluated on the data collected after the model was trained.

      Train, Validation, Test: 0.7, 0.2, 0.1

  23. May 2020
  24. Nov 2019
  25. Oct 2019
  26. Sep 2019
  27. Nov 2018
  28. Oct 2018
  29. Sep 2018